diff --git a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java
index e9e0ffa6ec7..6745cfcf87c 100644
--- a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java
+++ b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java
@@ -29,8 +29,8 @@ import org.jetbrains.kotlin.codegen.CodegenTestFiles;
 import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.generators.tests.generator.TestGeneratorUtil;
-import org.jetbrains.kotlin.idea.JetFileType;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.idea.KotlinFileType;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.TestJdkKind;
@@ -133,7 +133,7 @@ public class CodegenTestsOnAndroidGenerator extends UsefulTestCase {
     private class FilesWriter {
         private final boolean isFullJdk;
 
-        public List<JetFile> files = new ArrayList<JetFile>();
+        public List<KtFile> files = new ArrayList<KtFile>();
         private KotlinCoreEnvironment environment;
 
         private FilesWriter(boolean isFullJdk) {
@@ -161,11 +161,11 @@ public class CodegenTestsOnAndroidGenerator extends UsefulTestCase {
 
         public void writeFilesOnDisk() {
             writeFiles(files);
-            files = new ArrayList<JetFile>();
+            files = new ArrayList<KtFile>();
             environment = createEnvironment(isFullJdk);
         }
 
-        private void writeFiles(List<JetFile> filesToCompile) {
+        private void writeFiles(List<KtFile> filesToCompile) {
             System.out.println("Generating " + filesToCompile.size() + " files...");
             OutputFileCollection outputFiles;
             try {
@@ -207,7 +207,7 @@ public class CodegenTestsOnAndroidGenerator extends UsefulTestCase {
                     processFiles(printer, listFiles, holderFull, holderMock);
                 }
             }
-            else if (!FileUtilRt.getExtension(file.getName()).equals(JetFileType.INSTANCE.getDefaultExtension())) {
+            else if (!FileUtilRt.getExtension(file.getName()).equals(KotlinFileType.INSTANCE.getDefaultExtension())) {
                 // skip non kotlin files
             }
             else {
diff --git a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.java b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.java
index 1245d6639a2..95125017cf9 100644
--- a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.java
+++ b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.java
@@ -32,9 +32,9 @@ import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilKt;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.*;
 
@@ -63,9 +63,9 @@ public class CodegenUtil {
     }
 
     @Nullable
-    public static PropertyDescriptor getDelegatePropertyIfAny(JetExpression expression, ClassDescriptor classDescriptor, BindingContext bindingContext) {
+    public static PropertyDescriptor getDelegatePropertyIfAny(KtExpression expression, ClassDescriptor classDescriptor, BindingContext bindingContext) {
         PropertyDescriptor propertyDescriptor = null;
-        if (expression instanceof JetSimpleNameExpression) {
+        if (expression instanceof KtSimpleNameExpression) {
             ResolvedCall<?> call = CallUtilKt.getResolvedCall(expression, bindingContext);
             if (call != null) {
                 CallableDescriptor callResultingDescriptor = call.getResultingDescriptor();
@@ -140,8 +140,8 @@ public class CodegenUtil {
     }
 
     @NotNull
-    public static ClassDescriptor getSuperClassByDelegationSpecifier(@NotNull JetDelegationSpecifier specifier, @NotNull BindingContext bindingContext) {
-        JetType superType = bindingContext.get(BindingContext.TYPE, specifier.getTypeReference());
+    public static ClassDescriptor getSuperClassByDelegationSpecifier(@NotNull KtDelegationSpecifier specifier, @NotNull BindingContext bindingContext) {
+        KtType superType = bindingContext.get(BindingContext.TYPE, specifier.getTypeReference());
         assert superType != null : "superType should not be null: " + specifier.getText();
 
         ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor();
@@ -164,16 +164,16 @@ public class CodegenUtil {
         return true;
     }
 
-    private static boolean rawTypeMatches(JetType type, ClassifierDescriptor classifier) {
+    private static boolean rawTypeMatches(KtType type, ClassifierDescriptor classifier) {
         return type.getConstructor().equals(classifier.getTypeConstructor());
     }
 
     public static boolean isEnumValueOfMethod(@NotNull FunctionDescriptor functionDescriptor) {
         List<ValueParameterDescriptor> methodTypeParameters = functionDescriptor.getValueParameters();
-        JetType nullableString = TypeUtils.makeNullable(DescriptorUtilsKt.getBuiltIns(functionDescriptor).getStringType());
+        KtType nullableString = TypeUtils.makeNullable(DescriptorUtilsKt.getBuiltIns(functionDescriptor).getStringType());
         return DescriptorUtils.ENUM_VALUE_OF.equals(functionDescriptor.getName())
                && methodTypeParameters.size() == 1
-               && JetTypeChecker.DEFAULT.isSubtypeOf(methodTypeParameters.get(0).getType(), nullableString);
+               && KotlinTypeChecker.DEFAULT.isSubtypeOf(methodTypeParameters.get(0).getType(), nullableString);
     }
 
     public static boolean isEnumValuesProperty(@NotNull VariableDescriptor propertyDescriptor) {
@@ -183,8 +183,8 @@ public class CodegenUtil {
     @Nullable
     public static Integer getLineNumberForElement(@NotNull PsiElement statement, boolean markEndOffset) {
         PsiFile file = statement.getContainingFile();
-        if (file instanceof JetFile) {
-            if (JetPsiFactoryKt.getDoNotAnalyze((JetFile) file) != null) {
+        if (file instanceof KtFile) {
+            if (KtPsiFactoryKt.getDoNotAnalyze((KtFile) file) != null) {
                 return null;
             }
         }
diff --git a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtilKt.kt b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtilKt.kt
index e43b9de56a8..e80b74e0c1d 100644
--- a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtilKt.kt
+++ b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtilKt.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.MemberComparator
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.isDynamic
 import org.jetbrains.kotlin.utils.keysToMapExceptNulls
 import java.util.Comparator
@@ -38,7 +38,7 @@ public object CodegenUtilKt {
     public fun getDelegates(
             descriptor: ClassDescriptor,
             toTrait: ClassDescriptor,
-            delegateExpressionType: JetType? = null
+            delegateExpressionType: KtType? = null
     ): Map<CallableMemberDescriptor, CallableDescriptor> {
         if (delegateExpressionType?.isDynamic() ?: false) return mapOf();
 
diff --git a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/DataClassMethodGenerator.java b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/DataClassMethodGenerator.java
index 2a292ba0b52..5b9c978b44f 100644
--- a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/DataClassMethodGenerator.java
+++ b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/DataClassMethodGenerator.java
@@ -22,9 +22,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetClass;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetParameter;
+import org.jetbrains.kotlin.psi.KtClass;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtParameter;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
 import org.jetbrains.kotlin.resolve.OverrideResolver;
@@ -39,12 +39,12 @@ import java.util.List;
  *       changed here with the platform backends adopted.
  */
 public abstract class DataClassMethodGenerator {
-    private final JetClassOrObject declaration;
+    private final KtClassOrObject declaration;
     private final BindingContext bindingContext;
     private final ClassDescriptor classDescriptor;
     private final KotlinBuiltIns builtIns;
 
-    public DataClassMethodGenerator(JetClassOrObject declaration, BindingContext bindingContext) {
+    public DataClassMethodGenerator(KtClassOrObject declaration, BindingContext bindingContext) {
         this.declaration = declaration;
         this.bindingContext = bindingContext;
         this.classDescriptor = BindingContextUtils.getNotNull(bindingContext, BindingContext.CLASS, declaration);
@@ -66,7 +66,7 @@ public abstract class DataClassMethodGenerator {
 
     protected abstract void generateComponentFunction(@NotNull FunctionDescriptor function, @NotNull ValueParameterDescriptor parameter);
 
-    protected abstract void generateCopyFunction(@NotNull FunctionDescriptor function, @NotNull List<JetParameter> constructorParameters);
+    protected abstract void generateCopyFunction(@NotNull FunctionDescriptor function, @NotNull List<KtParameter> constructorParameters);
 
     protected abstract void generateToStringMethod(@NotNull FunctionDescriptor function, @NotNull List<PropertyDescriptor> properties);
 
@@ -93,7 +93,7 @@ public abstract class DataClassMethodGenerator {
         }
     }
 
-    private void generateCopyFunctionForDataClasses(List<JetParameter> constructorParameters) {
+    private void generateCopyFunctionForDataClasses(List<KtParameter> constructorParameters) {
         FunctionDescriptor copyFunction = bindingContext.get(BindingContext.DATA_CLASS_COPY_FUNCTION, classDescriptor);
         if (copyFunction != null) {
             generateCopyFunction(copyFunction, constructorParameters);
@@ -123,7 +123,7 @@ public abstract class DataClassMethodGenerator {
 
     private List<PropertyDescriptor> getDataProperties() {
         List<PropertyDescriptor> result = Lists.newArrayList();
-        for (JetParameter parameter : getPrimaryConstructorParameters()) {
+        for (KtParameter parameter : getPrimaryConstructorParameters()) {
             if (parameter.hasValOrVar()) {
                 result.add(bindingContext.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, parameter));
             }
@@ -132,8 +132,8 @@ public abstract class DataClassMethodGenerator {
     }
 
     @NotNull
-    private List<JetParameter> getPrimaryConstructorParameters() {
-        if (declaration instanceof JetClass) {
+    private List<KtParameter> getPrimaryConstructorParameters() {
+        if (declaration instanceof KtClass) {
             return declaration.getPrimaryConstructorParameters();
         }
         return Collections.emptyList();
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForCallableDescriptor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForCallableDescriptor.java
index 2b4077f13b1..0105f98ddd1 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForCallableDescriptor.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForCallableDescriptor.java
@@ -19,12 +19,12 @@ package org.jetbrains.kotlin.codegen;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor;
-import org.jetbrains.kotlin.psi.JetSuperExpression;
+import org.jetbrains.kotlin.psi.KtSuperExpression;
 
 public interface AccessorForCallableDescriptor<T extends CallableMemberDescriptor> {
     @NotNull
     T getCalleeDescriptor();
 
     @Nullable
-    JetSuperExpression getSuperCallExpression();
+    KtSuperExpression getSuperCallExpression();
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt
index 585f0b0d543..eac7f44874b 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt
@@ -18,14 +18,14 @@ package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetSuperExpression
+import org.jetbrains.kotlin.psi.KtSuperExpression
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 public class AccessorForConstructorDescriptor(
         private val calleeDescriptor: ConstructorDescriptor,
         containingDeclaration: DeclarationDescriptor,
-        private val superCallExpression: JetSuperExpression?
+        private val superCallExpression: KtSuperExpression?
 ) : AbstractAccessorForFunctionDescriptor(containingDeclaration, Name.special("<init>")),
         ConstructorDescriptor,
         AccessorForCallableDescriptor<ConstructorDescriptor> {
@@ -35,9 +35,9 @@ public class AccessorForConstructorDescriptor(
 
     override fun isPrimary(): Boolean = false
 
-    override fun getReturnType(): JetType = super.getReturnType()!!
+    override fun getReturnType(): KtType = super.getReturnType()!!
 
-    override fun getSuperCallExpression(): JetSuperExpression? = superCallExpression
+    override fun getSuperCallExpression(): KtSuperExpression? = superCallExpression
 
     init {
         initialize(
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java
index d5e77bc16a6..c5d0954e567 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java
@@ -20,18 +20,18 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetSuperExpression;
+import org.jetbrains.kotlin.psi.KtSuperExpression;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationUtilKt;
 
 public class AccessorForFunctionDescriptor extends AbstractAccessorForFunctionDescriptor implements AccessorForCallableDescriptor<FunctionDescriptor> {
     private final FunctionDescriptor calleeDescriptor;
-    private final JetSuperExpression superCallExpression;
+    private final KtSuperExpression superCallExpression;
 
     public AccessorForFunctionDescriptor(
             @NotNull FunctionDescriptor descriptor,
             @NotNull DeclarationDescriptor containingDeclaration,
-            @Nullable JetSuperExpression superCallExpression,
+            @Nullable KtSuperExpression superCallExpression,
             @NotNull String nameSuffix
     ) {
         super(containingDeclaration,
@@ -57,7 +57,7 @@ public class AccessorForFunctionDescriptor extends AbstractAccessorForFunctionDe
     }
 
     @Override
-    public JetSuperExpression getSuperCallExpression() {
+    public KtSuperExpression getSuperCallExpression() {
         return superCallExpression;
     }
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyBackingFieldInOuterClass.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyBackingFieldInOuterClass.java
index d072f5f0628..4b1baa5746e 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyBackingFieldInOuterClass.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyBackingFieldInOuterClass.java
@@ -20,13 +20,13 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public class AccessorForPropertyBackingFieldInOuterClass extends AccessorForPropertyDescriptor {
     public AccessorForPropertyBackingFieldInOuterClass(
             @NotNull PropertyDescriptor property,
             @NotNull DeclarationDescriptor containingDeclaration,
-            @Nullable JetType delegationType,
+            @Nullable KtType delegationType,
             @NotNull String nameSuffix
     ) {
         super(property, delegationType != null ? delegationType : property.getType(), null, null, containingDeclaration, null, nameSuffix);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyDescriptor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyDescriptor.java
index 536a2c24739..8e0507d4e59 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyDescriptor.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyDescriptor.java
@@ -25,21 +25,21 @@ import org.jetbrains.kotlin.descriptors.impl.PropertyGetterDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.PropertySetterDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetSuperExpression;
+import org.jetbrains.kotlin.psi.KtSuperExpression;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collections;
 
 public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl implements AccessorForCallableDescriptor<PropertyDescriptor> {
     private final PropertyDescriptor calleeDescriptor;
-    private final JetSuperExpression superCallExpression;
+    private final KtSuperExpression superCallExpression;
     @NotNull private final String nameSuffix;
 
     public AccessorForPropertyDescriptor(
             @NotNull PropertyDescriptor property,
             @NotNull DeclarationDescriptor containingDeclaration,
-            @Nullable JetSuperExpression superCallExpression,
+            @Nullable KtSuperExpression superCallExpression,
             @NotNull String nameSuffix
     ) {
         this(property, property.getType(), DescriptorUtils.getReceiverParameterType(property.getExtensionReceiverParameter()),
@@ -48,11 +48,11 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl implem
 
     protected AccessorForPropertyDescriptor(
             @NotNull PropertyDescriptor original,
-            @NotNull JetType propertyType,
-            @Nullable JetType receiverType,
+            @NotNull KtType propertyType,
+            @Nullable KtType receiverType,
             @Nullable ReceiverParameterDescriptor dispatchReceiverParameter,
             @NotNull DeclarationDescriptor containingDeclaration,
-            @Nullable JetSuperExpression superCallExpression,
+            @Nullable KtSuperExpression superCallExpression,
             @NotNull String nameSuffix
     ) {
         super(containingDeclaration, null, Annotations.Companion.getEMPTY(), Modality.FINAL, Visibilities.LOCAL,
@@ -84,7 +84,7 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl implem
 
         @Nullable
         @Override
-        public JetSuperExpression getSuperCallExpression() {
+        public KtSuperExpression getSuperCallExpression() {
             return ((AccessorForPropertyDescriptor) getCorrespondingProperty()).getSuperCallExpression();
         }
 
@@ -108,7 +108,7 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl implem
 
         @Nullable
         @Override
-        public JetSuperExpression getSuperCallExpression() {
+        public KtSuperExpression getSuperCallExpression() {
             return ((AccessorForPropertyDescriptor) getCorrespondingProperty()).getSuperCallExpression();
         }
     }
@@ -120,7 +120,7 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl implem
     }
 
     @Override
-    public JetSuperExpression getSuperCallExpression() {
+    public KtSuperExpression getSuperCallExpression() {
         return superCallExpression;
     }
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java
index 4ceada00ad9..4c8b7bd5b5b 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java
@@ -157,7 +157,7 @@ public abstract class AnnotationCodegen {
         return false;
     }
 
-    private void generateNullabilityAnnotation(@Nullable JetType type, @NotNull Set<String> annotationDescriptorsAlreadyPresent) {
+    private void generateNullabilityAnnotation(@Nullable KtType type, @NotNull Set<String> annotationDescriptorsAlreadyPresent) {
         if (type == null) return;
 
         if (isBareTypeParameterWithNullableUpperBound(type)) {
@@ -253,12 +253,12 @@ public abstract class AnnotationCodegen {
         }
     }
 
-    private static boolean isBareTypeParameterWithNullableUpperBound(@NotNull JetType type) {
+    private static boolean isBareTypeParameterWithNullableUpperBound(@NotNull KtType type) {
         ClassifierDescriptor classifier = type.getConstructor().getDeclarationDescriptor();
         return !type.isMarkedNullable() && classifier instanceof TypeParameterDescriptor && TypeUtils.hasNullableSuperType(type);
     }
 
-    public void generateAnnotationDefaultValue(@NotNull ConstantValue<?> value, @NotNull JetType expectedType) {
+    public void generateAnnotationDefaultValue(@NotNull ConstantValue<?> value, @NotNull KtType expectedType) {
         AnnotationVisitor visitor = visitAnnotation(null, false);  // Parameters are unimportant
         genCompileTimeValue(null, value, visitor);
         visitor.visitEnd();
@@ -418,7 +418,7 @@ public abstract class AnnotationCodegen {
                     for (ConstantValue<?> value : values) {
                         if (value instanceof EnumValue) {
                             ClassDescriptor enumEntry = ((EnumValue) value).getValue();
-                            JetType classObjectType = DescriptorUtilsKt.getClassObjectType(enumEntry);
+                            KtType classObjectType = DescriptorUtilsKt.getClassObjectType(enumEntry);
                             if (classObjectType != null) {
                                 if ("java/lang/annotation/ElementType".equals(typeMapper.mapType(classObjectType).getInternalName())) {
                                     result.add(ElementType.valueOf(enumEntry.getName().asString()));
@@ -446,7 +446,7 @@ public abstract class AnnotationCodegen {
                 ConstantValue<?> compileTimeConstant = valueArguments.iterator().next();
                 if (compileTimeConstant instanceof EnumValue) {
                     ClassDescriptor enumEntry = ((EnumValue) compileTimeConstant).getValue();
-                    JetType classObjectType = DescriptorUtilsKt.getClassObjectType(enumEntry);
+                    KtType classObjectType = DescriptorUtilsKt.getClassObjectType(enumEntry);
                     if (classObjectType != null) {
                         if ("java/lang/annotation/RetentionPolicy".equals(typeMapper.mapType(classObjectType).getInternalName())) {
                             return RetentionPolicy.valueOf(enumEntry.getName().asString());
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java
index dac28a7f51f..a6954c2eccf 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.jvm.RuntimeAssertionInfo;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.load.java.JavaVisibilities;
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor;
@@ -52,7 +52,7 @@ import org.jetbrains.kotlin.serialization.DescriptorSerializer;
 import org.jetbrains.kotlin.serialization.jvm.BitEncoding;
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor;
 import org.jetbrains.kotlin.types.FlexibleTypesKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.org.objectweb.asm.*;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 import org.jetbrains.org.objectweb.asm.commons.Method;
@@ -432,7 +432,7 @@ public class AsmUtil {
             allFields.add(Pair.create(CAPTURED_THIS_FIELD, typeMapper.mapType(captureThis)));
         }
 
-        JetType captureReceiverType = closure.getCaptureReceiverType();
+        KtType captureReceiverType = closure.getCaptureReceiverType();
         if (captureReceiverType != null) {
             allFields.add(Pair.create(CAPTURED_RECEIVER_FIELD, typeMapper.mapType(captureReceiverType)));
         }
@@ -558,7 +558,7 @@ public class AsmUtil {
                 right.put(rightType, v);
                 genAreEqualCall(v);
 
-                if (opToken == JetTokens.EXCLEQ || opToken == JetTokens.EXCLEQEQEQ) {
+                if (opToken == KtTokens.EXCLEQ || opToken == KtTokens.EXCLEQEQEQ) {
                     genInvertBoolean(v);
                 }
                 return Unit.INSTANCE$;
@@ -638,7 +638,7 @@ public class AsmUtil {
             @NotNull CallableDescriptor parameter,
             @NotNull String name
     ) {
-        JetType type = parameter.getReturnType();
+        KtType type = parameter.getReturnType();
         if (type == null || isNullableType(type)) return;
         
         int index = frameMap.getIndex(parameter);
@@ -672,7 +672,7 @@ public class AsmUtil {
 
         if (!isDeclaredInJava(descriptor)) return false;
 
-        JetType type = descriptor.getReturnType();
+        KtType type = descriptor.getReturnType();
         if (type == null || isNullableType(FlexibleTypesKt.lowerIfFlexible(type))) return false;
 
         Type asmType = state.getTypeMapper().mapReturnType(descriptor);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/BranchedValue.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/BranchedValue.kt
index 8eea7c615dd..f3cdd804779 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/BranchedValue.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/BranchedValue.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.codegen
 import com.intellij.psi.tree.IElementType
 import org.jetbrains.kotlin.codegen.pseudoInsns.fakeAlwaysFalseIfeq
 import org.jetbrains.kotlin.codegen.pseudoInsns.fakeAlwaysTrueIfeq
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.Opcodes.*
 import org.jetbrains.org.objectweb.asm.Type
@@ -214,7 +214,7 @@ class NumberCompare(
     override fun patchOpcode(opcode: Int, v: InstructionAdapter): Int {
         when (operandType) {
             Type.FLOAT_TYPE, Type.DOUBLE_TYPE -> {
-                if (opToken == JetTokens.GT || opToken == JetTokens.GTEQ) {
+                if (opToken == KtTokens.GT || opToken == KtTokens.GTEQ) {
                     v.cmpl(operandType)
                 }
                 else {
@@ -234,12 +234,12 @@ class NumberCompare(
     companion object {
         fun getNumberCompareOpcode(opToken: IElementType): Int {
             return when (opToken) {
-                JetTokens.EQEQ, JetTokens.EQEQEQ -> IFNE
-                JetTokens.EXCLEQ, JetTokens.EXCLEQEQEQ -> IFEQ
-                JetTokens.GT -> IFLE
-                JetTokens.GTEQ -> IFLT
-                JetTokens.LT -> IFGE
-                JetTokens.LTEQ -> IFGT
+                KtTokens.EQEQ, KtTokens.EQEQEQ -> IFNE
+                KtTokens.EXCLEQ, KtTokens.EXCLEQEQEQ -> IFEQ
+                KtTokens.GT -> IFLE
+                KtTokens.GTEQ -> IFLT
+                KtTokens.LT -> IFGE
+                KtTokens.LTEQ -> IFGT
                 else -> {
                     throw UnsupportedOperationException("Don't know how to generate this condJump: " + opToken)
                 }
@@ -258,8 +258,8 @@ class ObjectCompare(
     companion object {
         fun getObjectCompareOpcode(opToken: IElementType): Int {
             return when (opToken) {
-                JetTokens.EQEQEQ -> IF_ACMPNE
-                JetTokens.EXCLEQEQEQ -> IF_ACMPEQ
+                KtTokens.EQEQEQ -> IF_ACMPNE
+                KtTokens.EXCLEQEQEQ -> IF_ACMPEQ
                 else -> throw UnsupportedOperationException("don't know how to generate this condjump")
             }
         }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.java
index a15ac23d66f..c81b2b73798 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.java
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.codegen;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.psi.ValueArgument;
 import org.jetbrains.kotlin.resolve.calls.model.*;
 import org.jetbrains.org.objectweb.asm.Type;
@@ -68,7 +68,7 @@ public class CallBasedArgumentGenerator extends ArgumentGenerator {
         Type type = valueParameterTypes.get(i);
         ValueArgument valueArgument = argument.getValueArgument();
         assert valueArgument != null;
-        JetExpression argumentExpression = valueArgument.getArgumentExpression();
+        KtExpression argumentExpression = valueArgument.getArgumentExpression();
         assert argumentExpression != null : valueArgument.asElement().getText();
         callGenerator.genValueAndPut(parameter, argumentExpression, type, i);
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallGenerator.kt
index 9f3953fe0a1..c851844a523 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallGenerator.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallGenerator.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.org.objectweb.asm.Type
 
@@ -57,7 +57,7 @@ abstract class CallGenerator {
 
         override fun genValueAndPut(
                 valueParameterDescriptor: ValueParameterDescriptor,
-                argumentExpression: JetExpression,
+                argumentExpression: KtExpression,
                 parameterType: Type,
                 parameterIndex: Int) {
             val value = codegen.gen(argumentExpression)
@@ -118,7 +118,7 @@ abstract class CallGenerator {
 
     abstract fun genValueAndPut(
             valueParameterDescriptor: ValueParameterDescriptor,
-            argumentExpression: JetExpression,
+            argumentExpression: KtExpression,
             parameterType: Type,
             parameterIndex: Int)
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java
index 940a1bd41d0..b3e69edd2f6 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java
@@ -31,13 +31,13 @@ import java.util.List;
 
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.enumEntryNeedSubclass;
 
-public abstract class ClassBodyCodegen extends MemberCodegen<JetClassOrObject> {
-    protected final JetClassOrObject myClass;
+public abstract class ClassBodyCodegen extends MemberCodegen<KtClassOrObject> {
+    protected final KtClassOrObject myClass;
     protected final OwnerKind kind;
     protected final ClassDescriptor descriptor;
 
     protected ClassBodyCodegen(
-            @NotNull JetClassOrObject myClass,
+            @NotNull KtClassOrObject myClass,
             @NotNull ClassContext context,
             @NotNull ClassBuilder v,
             @NotNull GenerationState state,
@@ -53,14 +53,14 @@ public abstract class ClassBodyCodegen extends MemberCodegen<JetClassOrObject> {
     protected void generateBody() {
         if (kind != OwnerKind.DEFAULT_IMPLS) {
             //generate nested classes first and only then generate class body. It necessary to access to nested CodegenContexts
-            for (JetDeclaration declaration : myClass.getDeclarations()) {
+            for (KtDeclaration declaration : myClass.getDeclarations()) {
                 if (shouldProcessFirst(declaration)) {
                     generateDeclaration(declaration);
                 }
             }
         }
 
-        for (JetDeclaration declaration : myClass.getDeclarations()) {
+        for (KtDeclaration declaration : myClass.getDeclarations()) {
             if (!shouldProcessFirst(declaration)) {
                 generateDeclaration(declaration);
             }
@@ -92,26 +92,26 @@ public abstract class ClassBodyCodegen extends MemberCodegen<JetClassOrObject> {
         generatePrimaryConstructorProperties();
     }
 
-    private static boolean shouldProcessFirst(JetDeclaration declaration) {
-        return !(declaration instanceof JetProperty || declaration instanceof JetNamedFunction);
+    private static boolean shouldProcessFirst(KtDeclaration declaration) {
+        return !(declaration instanceof KtProperty || declaration instanceof KtNamedFunction);
     }
 
-    protected void generateDeclaration(JetDeclaration declaration) {
-        if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) {
+    protected void generateDeclaration(KtDeclaration declaration) {
+        if (declaration instanceof KtProperty || declaration instanceof KtNamedFunction) {
             genFunctionOrProperty(declaration);
         }
-        else if (declaration instanceof JetClassOrObject) {
-            if (declaration instanceof JetEnumEntry && !enumEntryNeedSubclass(bindingContext, (JetEnumEntry) declaration)) {
+        else if (declaration instanceof KtClassOrObject) {
+            if (declaration instanceof KtEnumEntry && !enumEntryNeedSubclass(bindingContext, (KtEnumEntry) declaration)) {
                 return;
             }
 
-            genClassOrObject((JetClassOrObject) declaration);
+            genClassOrObject((KtClassOrObject) declaration);
         }
     }
 
     private void generatePrimaryConstructorProperties() {
         boolean isAnnotation = descriptor.getKind() == ClassKind.ANNOTATION_CLASS;
-        for (JetParameter p : getPrimaryConstructorParameters()) {
+        for (KtParameter p : getPrimaryConstructorParameters()) {
             if (p.hasValOrVar()) {
                 PropertyDescriptor propertyDescriptor = bindingContext.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, p);
                 if (propertyDescriptor != null) {
@@ -127,9 +127,9 @@ public abstract class ClassBodyCodegen extends MemberCodegen<JetClassOrObject> {
     }
 
     @NotNull
-    protected List<JetParameter> getPrimaryConstructorParameters() {
-        if (myClass instanceof JetClass) {
-            return ((JetClass) myClass).getPrimaryConstructorParameters();
+    protected List<KtParameter> getPrimaryConstructorParameters() {
+        if (myClass instanceof KtClass) {
+            return ((KtClass) myClass).getPrimaryConstructorParameters();
         }
         return Collections.emptyList();
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java
index db7d9902069..796bf6531b2 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 import org.jetbrains.kotlin.load.kotlin.PackageParts;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
 import org.jetbrains.kotlin.serialization.jvm.JvmPackageTable;
 import org.jetbrains.org.objectweb.asm.Type;
@@ -223,7 +223,7 @@ public class ClassFileFactory implements OutputFileCollection {
     }
 
     @NotNull
-    public PackageCodegen forPackage(@NotNull FqName fqName, @NotNull Collection<JetFile> files) {
+    public PackageCodegen forPackage(@NotNull FqName fqName, @NotNull Collection<KtFile> files) {
         assert !isDone : "Already done!";
         PackageCodegen codegen = package2codegen.get(fqName);
         if (codegen == null) {
@@ -235,7 +235,7 @@ public class ClassFileFactory implements OutputFileCollection {
     }
 
     @NotNull
-    public MultifileClassCodegen forMultifileClass(@NotNull FqName facadeFqName, @NotNull Collection<JetFile> files) {
+    public MultifileClassCodegen forMultifileClass(@NotNull FqName facadeFqName, @NotNull Collection<KtFile> files) {
         assert !isDone : "Already done!";
         MultifileClassCodegen codegen = multifileClass2codegen.get(facadeFqName);
         if (codegen == null) {
@@ -341,7 +341,7 @@ public class ClassFileFactory implements OutputFileCollection {
     }
 
     @TestOnly
-    public List<JetFile> getInputFiles() {
+    public List<KtFile> getInputFiles() {
         return state.getFiles();
     }
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java
index 755a5aa53cf..a2f8b3e8f06 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java
@@ -35,15 +35,15 @@ import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
-import org.jetbrains.kotlin.psi.JetElement;
+import org.jetbrains.kotlin.psi.KtElement;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.serialization.DescriptorSerializer;
 import org.jetbrains.kotlin.serialization.ProtoBuf;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
 import org.jetbrains.kotlin.utils.FunctionsKt;
 import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
@@ -66,12 +66,12 @@ import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
 import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.NO_ORIGIN;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
-public class ClosureCodegen extends MemberCodegen<JetElement> {
+public class ClosureCodegen extends MemberCodegen<KtElement> {
     private final FunctionDescriptor funDescriptor;
     private final ClassDescriptor classDescriptor;
     private final SamType samType;
-    private final JetType superClassType;
-    private final List<JetType> superInterfaceTypes;
+    private final KtType superClassType;
+    private final List<KtType> superInterfaceTypes;
     private final FunctionDescriptor functionReferenceTarget;
     private final FunctionGenerationStrategy strategy;
     private final CalculatedClosure closure;
@@ -83,7 +83,7 @@ public class ClosureCodegen extends MemberCodegen<JetElement> {
 
     public ClosureCodegen(
             @NotNull GenerationState state,
-            @NotNull JetElement element,
+            @NotNull KtElement element,
             @Nullable SamType samType,
             @NotNull ClosureContext context,
             @Nullable FunctionDescriptor functionReferenceTarget,
@@ -100,10 +100,10 @@ public class ClosureCodegen extends MemberCodegen<JetElement> {
         this.strategy = strategy;
 
         if (samType == null) {
-            this.superInterfaceTypes = new ArrayList<JetType>();
+            this.superInterfaceTypes = new ArrayList<KtType>();
 
-            JetType superClassType = null;
-            for (JetType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
+            KtType superClassType = null;
+            for (KtType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
                 ClassifierDescriptor classifier = supertype.getConstructor().getDeclarationDescriptor();
                 if (DescriptorUtils.isInterface(classifier)) {
                     superInterfaceTypes.add(supertype);
@@ -141,7 +141,7 @@ public class ClosureCodegen extends MemberCodegen<JetElement> {
         sw.writeSuperclassEnd();
         String[] superInterfaceAsmTypes = new String[superInterfaceTypes.size()];
         for (int i = 0; i < superInterfaceTypes.size(); i++) {
-            JetType superInterfaceType = superInterfaceTypes.get(i);
+            KtType superInterfaceType = superInterfaceTypes.get(i);
             sw.writeInterface();
             superInterfaceAsmTypes[i] = typeMapper.mapSupertype(superInterfaceType, sw).getInternalName();
             sw.writeInterfaceEnd();
@@ -428,7 +428,7 @@ public class ClosureCodegen extends MemberCodegen<JetElement> {
             Type type = typeMapper.mapType(captureThis);
             args.add(FieldInfo.createForHiddenField(ownerType, type, CAPTURED_THIS_FIELD));
         }
-        JetType captureReceiverType = closure.getCaptureReceiverType();
+        KtType captureReceiverType = closure.getCaptureReceiverType();
         if (captureReceiverType != null) {
             args.add(FieldInfo.createForHiddenField(ownerType, typeMapper.mapType(captureReceiverType), CAPTURED_RECEIVER_FIELD));
         }
@@ -467,7 +467,7 @@ public class ClosureCodegen extends MemberCodegen<JetElement> {
         ClassDescriptor elementClass = elementDescriptor.getExtensionReceiverParameter() == null
                                    ? DescriptorUtilsKt.getBuiltIns(elementDescriptor).getFunction(arity)
                                    : DescriptorUtilsKt.getBuiltIns(elementDescriptor).getExtensionFunction(arity);
-        JetScope scope = elementClass.getDefaultType().getMemberScope();
+        KtScope scope = elementClass.getDefaultType().getMemberScope();
         return scope.getFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND).iterator().next();
     }
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CodegenFileClassesProvider.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CodegenFileClassesProvider.kt
index e0bc97fbcf1..4cc20975a20 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CodegenFileClassesProvider.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CodegenFileClassesProvider.kt
@@ -19,9 +19,9 @@ package org.jetbrains.kotlin.codegen
 import org.jetbrains.kotlin.fileClasses.JvmFileClassInfo
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
 import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
 public class CodegenFileClassesProvider : JvmFileClassesProvider {
-    override public fun getFileClassInfo(file: JetFile): JvmFileClassInfo =
+    override public fun getFileClassInfo(file: KtFile): JvmFileClassInfo =
             JvmFileClassUtil.getFileClassInfoNoResolve(file)
 }
\ No newline at end of file
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CodegenStatementVisitor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/CodegenStatementVisitor.java
index f6a0be5626c..08dbacb4d9a 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CodegenStatementVisitor.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CodegenStatementVisitor.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.codegen;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.*;
 
-public class CodegenStatementVisitor extends JetVisitor<StackValue, StackValue> {
+public class CodegenStatementVisitor extends KtVisitor<StackValue, StackValue> {
     private final ExpressionCodegen codegen;
 
     public CodegenStatementVisitor(ExpressionCodegen codegen) {
@@ -27,38 +27,38 @@ public class CodegenStatementVisitor extends JetVisitor<StackValue, StackValue>
     }
 
     @Override
-    public StackValue visitJetElement(@NotNull JetElement element, StackValue receiver) {
+    public StackValue visitJetElement(@NotNull KtElement element, StackValue receiver) {
         return element.accept(codegen, receiver);
     }
 
     @Override
-    public StackValue visitIfExpression(@NotNull JetIfExpression expression, StackValue receiver) {
+    public StackValue visitIfExpression(@NotNull KtIfExpression expression, StackValue receiver) {
         return codegen.generateIfExpression(expression, true);
     }
 
     @Override
-    public StackValue visitTryExpression(@NotNull JetTryExpression expression, StackValue data) {
+    public StackValue visitTryExpression(@NotNull KtTryExpression expression, StackValue data) {
         return codegen.generateTryExpression(expression, true);
     }
 
     @Override
-    public StackValue visitNamedFunction(@NotNull JetNamedFunction function, StackValue data) {
+    public StackValue visitNamedFunction(@NotNull KtNamedFunction function, StackValue data) {
         return codegen.visitNamedFunction(function, data, true);
     }
 
     @Override
-    public StackValue visitWhenExpression(@NotNull JetWhenExpression expression, StackValue data) {
+    public StackValue visitWhenExpression(@NotNull KtWhenExpression expression, StackValue data) {
         return codegen.generateWhenExpression(expression, true);
     }
 
     @Override
-    public StackValue visitBlockExpression(@NotNull JetBlockExpression expression, StackValue data) {
+    public StackValue visitBlockExpression(@NotNull KtBlockExpression expression, StackValue data) {
         return codegen.generateBlock(expression, true);
     }
 
     @Override
-    public StackValue visitLabeledExpression(@NotNull JetLabeledExpression expression, StackValue receiver) {
-        JetExpression baseExpression = expression.getBaseExpression();
+    public StackValue visitLabeledExpression(@NotNull KtLabeledExpression expression, StackValue receiver) {
+        KtExpression baseExpression = expression.getBaseExpression();
         assert baseExpression != null : "Label expression should have base one: " + expression.getText();
         return baseExpression.accept(this, receiver);
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt
index 56cc9a1226f..645840b22a4 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.org.objectweb.asm.Opcodes.*
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 import java.util.ArrayList
@@ -187,7 +187,7 @@ class CollectionStubMethodGenerator(
         return ourSuperCollectionClasses.filter { klass -> klass.readOnlyClass !in redundantClasses }
     }
 
-    private fun Collection<JetType>.classes(): Collection<ClassDescriptor> =
+    private fun Collection<KtType>.classes(): Collection<ClassDescriptor> =
             this.map { it.getConstructor().getDeclarationDescriptor() as ClassDescriptor }
 
     private fun findFakeOverridesForMethodsFromMutableCollection(
@@ -213,13 +213,13 @@ class CollectionStubMethodGenerator(
         return result
     }
 
-    private fun Collection<JetType>.findMostSpecificTypeForClass(klass: ClassDescriptor): JetType {
+    private fun Collection<KtType>.findMostSpecificTypeForClass(klass: ClassDescriptor): KtType {
         val types = this.filter { it.getConstructor().getDeclarationDescriptor() == klass }
         if (types.isEmpty()) error("No supertype of $klass in $this")
         if (types.size() == 1) return types.first()
         // Find the first type in the list such that it's a subtype of every other type in that list
         return types.first { type ->
-            types.all { other -> JetTypeChecker.DEFAULT.isSubtypeOf(type, other) }
+            types.all { other -> KotlinTypeChecker.DEFAULT.isSubtypeOf(type, other) }
         }
     }
 
@@ -239,8 +239,8 @@ class CollectionStubMethodGenerator(
         return this.getOverriddenDescriptors().firstOrNull { it.getContainingDeclaration() == classDescriptor }
     }
 
-    private fun newType(classDescriptor: ClassDescriptor, typeArguments: List<TypeProjection>): JetType {
-        return JetTypeImpl.create(Annotations.EMPTY, classDescriptor, false, typeArguments)
+    private fun newType(classDescriptor: ClassDescriptor, typeArguments: List<TypeProjection>): KtType {
+        return KtTypeImpl.create(Annotations.EMPTY, classDescriptor, false, typeArguments)
     }
 
     private fun FunctionDescriptor.signature(): JvmMethodSignature = typeMapper.mapSignature(this)
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueLoader.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueLoader.java
index 1d398ecb68e..db4d853780e 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueLoader.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueLoader.java
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.codegen;
 
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
-import org.jetbrains.kotlin.psi.JetParameter;
+import org.jetbrains.kotlin.psi.KtParameter;
 
 import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.descriptorToDeclaration;
 
@@ -31,7 +31,7 @@ public interface DefaultParameterValueLoader {
                 ValueParameterDescriptor descriptor,
                 ExpressionCodegen codegen
         ) {
-            JetParameter jetParameter = (JetParameter) descriptorToDeclaration(descriptor);
+            KtParameter jetParameter = (KtParameter) descriptorToDeclaration(descriptor);
             assert jetParameter != null;
             return codegen.gen(jetParameter.getDefaultValue());
         }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt
index 1f8c079a177..05380c8a32d 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt
@@ -19,9 +19,9 @@ package org.jetbrains.kotlin.codegen
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasDefaultValue
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmOverloadsAnnotation
@@ -42,7 +42,7 @@ public class DefaultParameterValueSubstitutor(val state: GenerationState) {
             constructorDescriptor: ConstructorDescriptor,
             classBuilder: ClassBuilder,
             contextKind: OwnerKind,
-            classOrObject: JetClassOrObject
+            classOrObject: KtClassOrObject
     ) {
         if (generateOverloadsIfNeeded(classOrObject, constructorDescriptor, constructorDescriptor, contextKind, classBuilder)) {
             return
@@ -70,7 +70,7 @@ public class DefaultParameterValueSubstitutor(val state: GenerationState) {
      * @return true if the overloads annotation was found on the element, false otherwise
      */
     fun generateOverloadsIfNeeded(
-            methodElement: JetElement?,
+            methodElement: KtElement?,
             functionDescriptor: FunctionDescriptor,
             delegateFunctionDescriptor: FunctionDescriptor,
             contextKind: OwnerKind,
@@ -109,7 +109,7 @@ public class DefaultParameterValueSubstitutor(val state: GenerationState) {
             functionDescriptor: FunctionDescriptor,
             delegateFunctionDescriptor: FunctionDescriptor,
             classBuilder: ClassBuilder,
-            methodElement: JetElement?,
+            methodElement: KtElement?,
             contextKind: OwnerKind,
             substituteCount: Int
     ) {
@@ -208,7 +208,7 @@ public class DefaultParameterValueSubstitutor(val state: GenerationState) {
         return functionDescriptor.getValueParameters().filter { !it.declaresDefaultValue() || --remainingCount >= 0 }
     }
 
-    private fun isEmptyConstructorNeeded(constructorDescriptor: ConstructorDescriptor, classOrObject: JetClassOrObject): Boolean {
+    private fun isEmptyConstructorNeeded(constructorDescriptor: ConstructorDescriptor, classOrObject: KtClassOrObject): Boolean {
         val classDescriptor = constructorDescriptor.getContainingDeclaration()
         if (classDescriptor.getKind() != ClassKind.CLASS) return false
 
@@ -220,12 +220,12 @@ public class DefaultParameterValueSubstitutor(val state: GenerationState) {
             return false
 
         if (constructorDescriptor.getValueParameters().isEmpty()) return false
-        if (classOrObject is JetClass && hasSecondaryConstructorsWithNoParameters(classOrObject)) return false
+        if (classOrObject is KtClass && hasSecondaryConstructorsWithNoParameters(classOrObject)) return false
 
         return constructorDescriptor.getValueParameters().all { it.declaresDefaultValue() }
     }
 
-    private fun hasSecondaryConstructorsWithNoParameters(klass: JetClass) =
+    private fun hasSecondaryConstructorsWithNoParameters(klass: KtClass) =
         klass.getSecondaryConstructors().any { it.getValueParameters().isEmpty() }
 
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java
index b1a8bfdb756..6fab26b15f3 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java
@@ -54,7 +54,7 @@ import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.jvm.RuntimeAssertionInfo;
 import org.jetbrains.kotlin.jvm.bindingContextSlices.BindingContextSlicesKt;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptor;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
@@ -80,10 +80,10 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
 import org.jetbrains.kotlin.resolve.scopes.receivers.*;
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeProjection;
 import org.jetbrains.kotlin.types.TypeUtils;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.org.objectweb.asm.Label;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
 import org.jetbrains.org.objectweb.asm.Opcodes;
@@ -104,7 +104,7 @@ import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
 import static org.jetbrains.kotlin.resolve.jvm.annotations.AnnotationUtilKt.hasJvmFieldAnnotation;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
-public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implements LocalLookup {
+public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> implements LocalLookup {
     private final GenerationState state;
     final JetTypeMapper typeMapper;
     private final BindingContext bindingContext;
@@ -125,7 +125,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
      * When we create a temporary variable to hold some value not to compute it many times
      * we put it into this map to emit access to that variable instead of evaluating the whole expression
      */
-    public final Map<JetElement, StackValue> tempVariables = Maps.newHashMap();
+    public final Map<KtElement, StackValue> tempVariables = Maps.newHashMap();
 
     private int myLastLineNumber = -1;
     private boolean shouldMarkLineNumbers = true;
@@ -156,9 +156,9 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     static class LoopBlockStackElement extends BlockStackElement {
         final Label continueLabel;
         final Label breakLabel;
-        public final JetSimpleNameExpression targetLabel;
+        public final KtSimpleNameExpression targetLabel;
 
-        LoopBlockStackElement(Label breakLabel, Label continueLabel, JetSimpleNameExpression targetLabel) {
+        LoopBlockStackElement(Label breakLabel, Label continueLabel, KtSimpleNameExpression targetLabel) {
             this.breakLabel = breakLabel;
             this.continueLabel = continueLabel;
             this.targetLabel = targetLabel;
@@ -168,9 +168,9 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     static class FinallyBlockStackElement extends BlockStackElement {
         List<Label> gaps = new ArrayList<Label>();
 
-        final JetTryExpression expression;
+        final KtTryExpression expression;
 
-        FinallyBlockStackElement(JetTryExpression expression) {
+        FinallyBlockStackElement(KtTryExpression expression) {
             this.expression = expression;
         }
 
@@ -195,8 +195,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @NotNull
-    public ObjectLiteralResult generateObjectLiteral(@NotNull JetObjectLiteralExpression literal) {
-        JetObjectDeclaration objectDeclaration = literal.getObjectDeclaration();
+    public ObjectLiteralResult generateObjectLiteral(@NotNull KtObjectLiteralExpression literal) {
+        KtObjectDeclaration objectDeclaration = literal.getObjectDeclaration();
 
         ClassDescriptor classDescriptor = bindingContext.get(CLASS, objectDeclaration);
         assert classDescriptor != null;
@@ -225,7 +225,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     private static void addReifiedParametersFromSignature(@NotNull MemberCodegen member, @NotNull ClassDescriptor descriptor) {
-        for (JetType type : descriptor.getTypeConstructor().getSupertypes()) {
+        for (KtType type : descriptor.getTypeConstructor().getSupertypes()) {
             for (TypeProjection supertypeArgument : type.getArguments()) {
                 TypeParameterDescriptor parameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(supertypeArgument.getType());
                 if (parameterDescriptor != null && parameterDescriptor.isReified()) {
@@ -258,20 +258,20 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         return inner;
     }
 
-    public StackValue genQualified(StackValue receiver, JetElement selector) {
+    public StackValue genQualified(StackValue receiver, KtElement selector) {
         return genQualified(receiver, selector, this);
     }
 
-    private StackValue genQualified(StackValue receiver, JetElement selector, JetVisitor<StackValue, StackValue> visitor) {
+    private StackValue genQualified(StackValue receiver, KtElement selector, KtVisitor<StackValue, StackValue> visitor) {
         if (tempVariables.containsKey(selector)) {
             throw new IllegalStateException("Inconsistent state: expression saved to a temporary variable is a selector");
         }
-        if (!(selector instanceof JetBlockExpression)) {
+        if (!(selector instanceof KtBlockExpression)) {
             markStartLineNumber(selector);
         }
         try {
-            if (selector instanceof JetExpression) {
-                StackValue samValue = genSamInterfaceValue((JetExpression) selector, visitor);
+            if (selector instanceof KtExpression) {
+                StackValue samValue = genSamInterfaceValue((KtExpression) selector, visitor);
                 if (samValue != null) {
                     return samValue;
                 }
@@ -280,8 +280,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             StackValue stackValue = selector.accept(visitor, receiver);
 
             RuntimeAssertionInfo runtimeAssertionInfo = null;
-            if (selector instanceof JetExpression) {
-                runtimeAssertionInfo = bindingContext.get(BindingContextSlicesKt.getRUNTIME_ASSERTION_INFO(), (JetExpression) selector);
+            if (selector instanceof KtExpression) {
+                runtimeAssertionInfo = bindingContext.get(BindingContextSlicesKt.getRUNTIME_ASSERTION_INFO(), (KtExpression) selector);
             }
 
             if (BuiltinSpecialBridgesKt.isValueArgumentForCallToMethodWithTypeCheckBarrier(selector, bindingContext)) return stackValue;
@@ -300,31 +300,31 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         }
     }
 
-    public StackValue gen(JetElement expr) {
+    public StackValue gen(KtElement expr) {
         StackValue tempVar = tempVariables.get(expr);
         return tempVar != null ? tempVar : genQualified(StackValue.none(), expr);
     }
 
-    public void gen(JetElement expr, Type type) {
+    public void gen(KtElement expr, Type type) {
         StackValue value = Type.VOID_TYPE.equals(type) ? genStatement(expr) : gen(expr);
         value.put(type, v);
     }
 
-    public StackValue genLazy(JetElement expr, Type type) {
+    public StackValue genLazy(KtElement expr, Type type) {
         StackValue value = gen(expr);
         return StackValue.coercion(value, type);
     }
 
-    private StackValue genStatement(JetElement statement) {
+    private StackValue genStatement(KtElement statement) {
         return genQualified(StackValue.none(), statement, statementVisitor);
     }
 
     @Override
-    public StackValue visitClass(@NotNull JetClass klass, StackValue data) {
+    public StackValue visitClass(@NotNull KtClass klass, StackValue data) {
         return visitClassOrObject(klass);
     }
 
-    private StackValue visitClassOrObject(JetClassOrObject declaration) {
+    private StackValue visitClassOrObject(KtClassOrObject declaration) {
         ClassDescriptor descriptor = bindingContext.get(CLASS, declaration);
         assert descriptor != null;
 
@@ -334,7 +334,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         ClassContext objectContext = context.intoAnonymousClass(descriptor, this, OwnerKind.IMPLEMENTATION);
         new ImplementationBodyCodegen(declaration, objectContext, classBuilder, state, getParentCodegen(), /* isLocal = */ true).generate();
 
-        if (declaration instanceof JetClass && ((JetClass) declaration).isInterface()) {
+        if (declaration instanceof KtClass && ((KtClass) declaration).isInterface()) {
             Type traitImplType = state.getTypeMapper().mapDefaultImpls(descriptor);
             ClassBuilder traitImplBuilder = state.getFactory().newVisitor(JvmDeclarationOriginKt.TraitImpl(declaration, descriptor), traitImplType, declaration.getContainingFile());
             ClassContext traitImplContext = context.intoAnonymousClass(descriptor, this, OwnerKind.DEFAULT_IMPLS);
@@ -345,24 +345,24 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, StackValue data) {
+    public StackValue visitObjectDeclaration(@NotNull KtObjectDeclaration declaration, StackValue data) {
         return visitClassOrObject(declaration);
     }
 
     @Override
-    public StackValue visitExpression(@NotNull JetExpression expression, StackValue receiver) {
+    public StackValue visitExpression(@NotNull KtExpression expression, StackValue receiver) {
         throw new UnsupportedOperationException("Codegen for " + expression + " is not yet implemented");
     }
 
     @Override
-    public StackValue visitSuperExpression(@NotNull JetSuperExpression expression, StackValue data) {
+    public StackValue visitSuperExpression(@NotNull KtSuperExpression expression, StackValue data) {
         return StackValue.thisOrOuter(this, getSuperCallLabelTarget(context, expression), true, true);
     }
 
     @NotNull
     public static ClassDescriptor getSuperCallLabelTarget(
             @NotNull CodegenContext<?> context,
-            @NotNull JetSuperExpression expression
+            @NotNull KtSuperExpression expression
     ) {
         BindingContext bindingContext = context.getState().getBindingContext();
         PsiElement labelPsi = bindingContext.get(LABEL_TARGET, expression.getTargetLabel());
@@ -377,38 +377,38 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @NotNull
-    private Type asmType(@NotNull JetType type) {
+    private Type asmType(@NotNull KtType type) {
         return typeMapper.mapType(type);
     }
 
     @NotNull
-    public Type expressionType(@Nullable JetExpression expression) {
-        JetType type = expressionJetType(expression);
+    public Type expressionType(@Nullable KtExpression expression) {
+        KtType type = expressionJetType(expression);
         return type == null ? Type.VOID_TYPE : asmType(type);
     }
 
     @Nullable
-    public JetType expressionJetType(@Nullable JetExpression expression) {
+    public KtType expressionJetType(@Nullable KtExpression expression) {
         return expression != null ? bindingContext.getType(expression) : null;
     }
 
     @Override
-    public StackValue visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression, StackValue receiver) {
+    public StackValue visitParenthesizedExpression(@NotNull KtParenthesizedExpression expression, StackValue receiver) {
         return genQualified(receiver, expression.getExpression());
     }
 
     @Override
-    public StackValue visitAnnotatedExpression(@NotNull JetAnnotatedExpression expression, StackValue receiver) {
+    public StackValue visitAnnotatedExpression(@NotNull KtAnnotatedExpression expression, StackValue receiver) {
         return genQualified(receiver, expression.getBaseExpression());
     }
 
-    private static boolean isEmptyExpression(@Nullable JetElement expr) {
+    private static boolean isEmptyExpression(@Nullable KtElement expr) {
         if (expr == null) {
             return true;
         }
-        if (expr instanceof JetBlockExpression) {
-            JetBlockExpression blockExpression = (JetBlockExpression) expr;
-            List<JetExpression> statements = blockExpression.getStatements();
+        if (expr instanceof KtBlockExpression) {
+            KtBlockExpression blockExpression = (KtBlockExpression) expr;
+            List<KtExpression> statements = blockExpression.getStatements();
             if (statements.size() == 0 || statements.size() == 1 && isEmptyExpression(statements.get(0))) {
                 return true;
             }
@@ -417,16 +417,16 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitIfExpression(@NotNull JetIfExpression expression, StackValue receiver) {
+    public StackValue visitIfExpression(@NotNull KtIfExpression expression, StackValue receiver) {
         return generateIfExpression(expression, false);
     }
 
-    /* package */ StackValue generateIfExpression(@NotNull final JetIfExpression expression, final boolean isStatement) {
+    /* package */ StackValue generateIfExpression(@NotNull final KtIfExpression expression, final boolean isStatement) {
         final Type asmType = isStatement ? Type.VOID_TYPE : expressionType(expression);
         final StackValue condition = gen(expression.getCondition());
 
-        final JetExpression thenExpression = expression.getThen();
-        final JetExpression elseExpression = expression.getElse();
+        final KtExpression thenExpression = expression.getThen();
+        final KtExpression elseExpression = expression.getElse();
 
         if (isEmptyExpression(thenExpression)) {
             if (isEmptyExpression(elseExpression)) {
@@ -463,7 +463,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitWhileExpression(@NotNull JetWhileExpression expression, StackValue receiver) {
+    public StackValue visitWhileExpression(@NotNull KtWhileExpression expression, StackValue receiver) {
         Label condition = new Label();
         v.mark(condition);
 
@@ -486,7 +486,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
 
     @Override
-    public StackValue visitDoWhileExpression(@NotNull JetDoWhileExpression expression, StackValue receiver) {
+    public StackValue visitDoWhileExpression(@NotNull KtDoWhileExpression expression, StackValue receiver) {
         Label beginLoopLabel = new Label();
         v.mark(beginLoopLabel);
 
@@ -497,16 +497,16 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
         PseudoInsnsKt.fakeAlwaysFalseIfeq(v, continueLabel);
 
-        JetExpression body = expression.getBody();
-        JetExpression condition = expression.getCondition();
+        KtExpression body = expression.getBody();
+        KtExpression condition = expression.getCondition();
         StackValue conditionValue;
 
-        if (body instanceof JetBlockExpression) {
+        if (body instanceof KtBlockExpression) {
             // If body's a block, it can contain variable declarations which may be used in the condition of a do-while loop.
             // We handle this case separately because otherwise such variable will be out of the frame map after the block ends
-            List<JetExpression> doWhileStatements = ((JetBlockExpression) body).getStatements();
+            List<KtExpression> doWhileStatements = ((KtBlockExpression) body).getStatements();
 
-            List<JetExpression> statements = new ArrayList<JetExpression>(doWhileStatements.size() + 1);
+            List<KtExpression> statements = new ArrayList<KtExpression>(doWhileStatements.size() + 1);
             statements.addAll(doWhileStatements);
             statements.add(condition);
 
@@ -528,7 +528,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitForExpression(@NotNull JetForExpression forExpression, StackValue receiver) {
+    public StackValue visitForExpression(@NotNull KtForExpression forExpression, StackValue receiver) {
         // Is it a "1..2" or so
         RangeCodegenUtil.BinaryCall binaryCall = RangeCodegenUtil.getRangeAsBinaryCall(forExpression);
         if (binaryCall != null) {
@@ -541,9 +541,9 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             }
         }
 
-        JetExpression loopRange = forExpression.getLoopRange();
+        KtExpression loopRange = forExpression.getLoopRange();
         assert loopRange != null;
-        JetType loopRangeType = bindingContext.getType(loopRange);
+        KtType loopRangeType = bindingContext.getType(loopRange);
         assert loopRangeType != null;
         Type asmLoopRangeType = asmType(loopRangeType);
         if (asmLoopRangeType.getSort() == Type.ARRAY) {
@@ -599,25 +599,25 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     private abstract class AbstractForLoopGenerator {
 
         // for (e : E in c) {...}
-        protected final JetForExpression forExpression;
+        protected final KtForExpression forExpression;
         private final Label bodyStart = new Label();
         private final Label bodyEnd = new Label();
         private final List<Runnable> leaveVariableTasks = Lists.newArrayList();
 
-        protected final JetType elementType;
+        protected final KtType elementType;
         protected final Type asmElementType;
 
         protected int loopParameterVar;
 
-        private AbstractForLoopGenerator(@NotNull JetForExpression forExpression) {
+        private AbstractForLoopGenerator(@NotNull KtForExpression forExpression) {
             this.forExpression = forExpression;
             this.elementType = getElementType(forExpression);
             this.asmElementType = asmType(elementType);
         }
 
         @NotNull
-        private JetType getElementType(JetForExpression forExpression) {
-            JetExpression loopRange = forExpression.getLoopRange();
+        private KtType getElementType(KtForExpression forExpression) {
+            KtExpression loopRange = forExpression.getLoopRange();
             assert loopRange != null;
             ResolvedCall<FunctionDescriptor> nextCall = getNotNull(bindingContext,
                                                                    LOOP_RANGE_NEXT_RESOLVED_CALL, loopRange,
@@ -627,7 +627,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         }
 
         public void beforeLoop() {
-            JetParameter loopParameter = forExpression.getLoopParameter();
+            KtParameter loopParameter = forExpression.getLoopParameter();
             if (loopParameter != null) {
                 // E e = tmp<iterator>.next()
                 final VariableDescriptor parameterDescriptor = bindingContext.get(VALUE_PARAMETER, loopParameter);
@@ -645,7 +645,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
                 });
             }
             else {
-                JetMultiDeclaration multiParameter = forExpression.getMultiParameter();
+                KtMultiDeclaration multiParameter = forExpression.getMultiParameter();
                 assert multiParameter != null;
 
                 // E tmp<e> = tmp<iterator>.next()
@@ -663,15 +663,15 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             assignToLoopParameter();
 
             if (forExpression.getLoopParameter() == null) {
-                JetMultiDeclaration multiParameter = forExpression.getMultiParameter();
+                KtMultiDeclaration multiParameter = forExpression.getMultiParameter();
                 assert multiParameter != null;
 
                 generateMultiVariables(multiParameter.getEntries());
             }
         }
 
-        private void generateMultiVariables(List<JetMultiDeclarationEntry> entries) {
-            for (JetMultiDeclarationEntry variableDeclaration : entries) {
+        private void generateMultiVariables(List<KtMultiDeclarationEntry> entries) {
+            for (KtMultiDeclarationEntry variableDeclaration : entries) {
                 final VariableDescriptor componentDescriptor = bindingContext.get(VARIABLE, variableDeclaration);
 
                 @SuppressWarnings("ConstantConditions") final Type componentAsmType = asmType(componentDescriptor.getReturnType());
@@ -743,7 +743,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         }
     }
 
-    private void generateLoopBody(@Nullable JetExpression body) {
+    private void generateLoopBody(@Nullable KtExpression body) {
         if (body != null) {
             gen(body, Type.VOID_TYPE);
         }
@@ -756,16 +756,16 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         private final ResolvedCall<FunctionDescriptor> nextCall;
         private final Type asmTypeForIterator;
 
-        private IteratorForLoopGenerator(@NotNull JetForExpression forExpression) {
+        private IteratorForLoopGenerator(@NotNull KtForExpression forExpression) {
             super(forExpression);
 
-            JetExpression loopRange = forExpression.getLoopRange();
+            KtExpression loopRange = forExpression.getLoopRange();
             assert loopRange != null;
             this.iteratorCall = getNotNull(bindingContext,
                                            LOOP_RANGE_ITERATOR_RESOLVED_CALL, loopRange,
                                            "No .iterator() function " + DiagnosticUtils.atLocation(loopRange));
 
-            JetType iteratorType = iteratorCall.getResultingDescriptor().getReturnType();
+            KtType iteratorType = iteratorCall.getResultingDescriptor().getReturnType();
             assert iteratorType != null;
             this.asmTypeForIterator = asmType(iteratorType);
 
@@ -793,7 +793,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         public void checkPreCondition(@NotNull Label loopExit) {
             // tmp<iterator>.hasNext()
 
-            JetExpression loopRange = forExpression.getLoopRange();
+            KtExpression loopRange = forExpression.getLoopRange();
             @SuppressWarnings("ConstantConditions") ResolvedCall<FunctionDescriptor> hasNextCall = getNotNull(bindingContext,
                                                                       LOOP_RANGE_HAS_NEXT_RESOLVED_CALL, loopRange,
                                                                       "No hasNext() function " + DiagnosticUtils.atLocation(loopRange));
@@ -802,8 +802,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             result.put(result.type, v);
 
             FunctionDescriptor hasNext = hasNextCall.getResultingDescriptor();
-            JetType type = hasNext.getReturnType();
-            assert type != null && JetTypeChecker.DEFAULT.isSubtypeOf(type, DescriptorUtilsKt.getBuiltIns(hasNext).getBooleanType());
+            KtType type = hasNext.getReturnType();
+            assert type != null && KotlinTypeChecker.DEFAULT.isSubtypeOf(type, DescriptorUtilsKt.getBuiltIns(hasNext).getBooleanType());
 
             Type asmType = asmType(type);
             StackValue.coerce(asmType, Type.BOOLEAN_TYPE, v);
@@ -827,9 +827,9 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     private class ForInArrayLoopGenerator extends AbstractForLoopGenerator {
         private int indexVar;
         private int arrayVar;
-        private final JetType loopRangeType;
+        private final KtType loopRangeType;
 
-        private ForInArrayLoopGenerator(@NotNull JetForExpression forExpression) {
+        private ForInArrayLoopGenerator(@NotNull KtForExpression forExpression) {
             super(forExpression);
             loopRangeType = bindingContext.getType(forExpression.getLoopRange());
         }
@@ -840,7 +840,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
             indexVar = createLoopTempVariable(Type.INT_TYPE);
 
-            JetExpression loopRange = forExpression.getLoopRange();
+            KtExpression loopRange = forExpression.getLoopRange();
             StackValue value = gen(loopRange);
             Type asmLoopRangeType = asmType(loopRangeType);
             if (value instanceof StackValue.Local && value.type.equals(asmLoopRangeType)) {
@@ -898,7 +898,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         // loopParameterVar == finalVar at the end of the iteration (and also if there should be any iterations at all, before the loop)
         protected final boolean isIntegerProgression;
 
-        private AbstractForInProgressionOrRangeLoopGenerator(@NotNull JetForExpression forExpression) {
+        private AbstractForInProgressionOrRangeLoopGenerator(@NotNull KtForExpression forExpression) {
             super(forExpression);
 
             switch (asmElementType.getSort()) {
@@ -949,7 +949,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     private abstract class AbstractForInRangeLoopGenerator extends AbstractForInProgressionOrRangeLoopGenerator {
-        private AbstractForInRangeLoopGenerator(@NotNull JetForExpression forExpression) {
+        private AbstractForInRangeLoopGenerator(@NotNull KtForExpression forExpression) {
             super(forExpression);
         }
 
@@ -1018,7 +1018,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         private final RangeCodegenUtil.BinaryCall rangeCall;
 
         private ForInRangeLiteralLoopGenerator(
-                @NotNull JetForExpression forExpression,
+                @NotNull KtForExpression forExpression,
                 @NotNull RangeCodegenUtil.BinaryCall rangeCall
         ) {
             super(forExpression);
@@ -1036,13 +1036,13 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     private class ForInRangeInstanceLoopGenerator extends AbstractForInRangeLoopGenerator {
-        private ForInRangeInstanceLoopGenerator(@NotNull JetForExpression forExpression) {
+        private ForInRangeInstanceLoopGenerator(@NotNull KtForExpression forExpression) {
             super(forExpression);
         }
 
         @Override
         protected void storeRangeStartAndEnd() {
-            JetType loopRangeType = bindingContext.getType(forExpression.getLoopRange());
+            KtType loopRangeType = bindingContext.getType(forExpression.getLoopRange());
             assert loopRangeType != null;
             Type asmLoopRangeType = asmType(loopRangeType);
             gen(forExpression.getLoopRange(), asmLoopRangeType);
@@ -1059,7 +1059,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
         private int finalVar;
 
-        private ForInProgressionExpressionLoopGenerator(@NotNull JetForExpression forExpression) {
+        private ForInProgressionExpressionLoopGenerator(@NotNull KtForExpression forExpression) {
             super(forExpression);
         }
 
@@ -1074,7 +1074,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
             incrementVar = createLoopTempVariable(asmElementType);
 
-            JetType loopRangeType = bindingContext.getType(forExpression.getLoopRange());
+            KtType loopRangeType = bindingContext.getType(forExpression.getLoopRange());
             assert loopRangeType != null;
             Type asmLoopRangeType = asmType(loopRangeType);
 
@@ -1209,22 +1209,22 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
 
     @Override
-    public StackValue visitBreakExpression(@NotNull JetBreakExpression expression, StackValue receiver) {
+    public StackValue visitBreakExpression(@NotNull KtBreakExpression expression, StackValue receiver) {
         return generateBreakOrContinueExpression(expression, true, new Label());
     }
 
     @Override
-    public StackValue visitContinueExpression(@NotNull JetContinueExpression expression, StackValue receiver) {
+    public StackValue visitContinueExpression(@NotNull KtContinueExpression expression, StackValue receiver) {
         return generateBreakOrContinueExpression(expression, false, new Label());
     }
 
     @NotNull
     private StackValue generateBreakOrContinueExpression(
-            @NotNull JetExpressionWithLabel expression,
+            @NotNull KtExpressionWithLabel expression,
             boolean isBreak,
             @NotNull Label afterBreakContinueLabel
     ) {
-        assert expression instanceof JetContinueExpression || expression instanceof JetBreakExpression;
+        assert expression instanceof KtContinueExpression || expression instanceof KtBreakExpression;
 
         if (!blockStackElements.isEmpty()) {
             BlockStackElement stackElement = blockStackElements.peek();
@@ -1236,7 +1236,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             }
             else if (stackElement instanceof LoopBlockStackElement) {
                 LoopBlockStackElement loopBlockStackElement = (LoopBlockStackElement) stackElement;
-                JetSimpleNameExpression labelElement = expression.getTargetLabel();
+                KtSimpleNameExpression labelElement = expression.getTargetLabel();
                 //noinspection ConstantConditions
                 if (labelElement == null ||
                     loopBlockStackElement.targetLabel != null &&
@@ -1262,8 +1262,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
     private StackValue generateSingleBranchIf(
             final StackValue condition,
-            final JetIfExpression ifExpression,
-            final JetExpression expression,
+            final KtIfExpression ifExpression,
+            final KtExpression expression,
             final boolean inverse,
             final boolean isStatement
     ) {
@@ -1296,38 +1296,38 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitConstantExpression(@NotNull JetConstantExpression expression, StackValue receiver) {
+    public StackValue visitConstantExpression(@NotNull KtConstantExpression expression, StackValue receiver) {
         ConstantValue<?> compileTimeValue = getCompileTimeConstant(expression, bindingContext);
         assert compileTimeValue != null;
         return StackValue.constant(compileTimeValue.getValue(), expressionType(expression));
     }
 
     @Nullable
-    public static ConstantValue<?> getCompileTimeConstant(@NotNull JetExpression expression, @NotNull BindingContext bindingContext) {
+    public static ConstantValue<?> getCompileTimeConstant(@NotNull KtExpression expression, @NotNull BindingContext bindingContext) {
         CompileTimeConstant<?> compileTimeValue = ConstantExpressionEvaluator.getConstant(expression, bindingContext);
         if (compileTimeValue == null) {
             return null;
         }
-        JetType expectedType = bindingContext.getType(expression);
+        KtType expectedType = bindingContext.getType(expression);
         return compileTimeValue.toConstantValue(expectedType);
     }
 
     @Override
-    public StackValue visitStringTemplateExpression(@NotNull JetStringTemplateExpression expression, StackValue receiver) {
+    public StackValue visitStringTemplateExpression(@NotNull KtStringTemplateExpression expression, StackValue receiver) {
         StringBuilder constantValue = new StringBuilder("");
-        final JetStringTemplateEntry[] entries = expression.getEntries();
+        final KtStringTemplateEntry[] entries = expression.getEntries();
 
-        if (entries.length == 1 && entries[0] instanceof JetStringTemplateEntryWithExpression) {
-            JetExpression expr = entries[0].getExpression();
+        if (entries.length == 1 && entries[0] instanceof KtStringTemplateEntryWithExpression) {
+            KtExpression expr = entries[0].getExpression();
             return genToString(gen(expr), expressionType(expr));
         }
 
-        for (JetStringTemplateEntry entry : entries) {
-            if (entry instanceof JetLiteralStringTemplateEntry) {
+        for (KtStringTemplateEntry entry : entries) {
+            if (entry instanceof KtLiteralStringTemplateEntry) {
                 constantValue.append(entry.getText());
             }
-            else if (entry instanceof JetEscapeStringTemplateEntry) {
-                constantValue.append(((JetEscapeStringTemplateEntry) entry).getUnescapedValue());
+            else if (entry instanceof KtEscapeStringTemplateEntry) {
+                constantValue.append(((KtEscapeStringTemplateEntry) entry).getUnescapedValue());
             }
             else {
                 constantValue = null;
@@ -1343,13 +1343,13 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
                 @Override
                 public Unit invoke(InstructionAdapter v) {
                     genStringBuilderConstructor(v);
-                    for (JetStringTemplateEntry entry : entries) {
-                        if (entry instanceof JetStringTemplateEntryWithExpression) {
+                    for (KtStringTemplateEntry entry : entries) {
+                        if (entry instanceof KtStringTemplateEntryWithExpression) {
                             invokeAppend(entry.getExpression());
                         }
                         else {
-                            String text = entry instanceof JetEscapeStringTemplateEntry
-                                          ? ((JetEscapeStringTemplateEntry) entry).getUnescapedValue()
+                            String text = entry instanceof KtEscapeStringTemplateEntry
+                                          ? ((KtEscapeStringTemplateEntry) entry).getUnescapedValue()
                                           : entry.getText();
                             v.aconst(text);
                             genInvokeAppendMethod(v, JAVA_STRING_TYPE);
@@ -1363,19 +1363,19 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitBlockExpression(@NotNull JetBlockExpression expression, StackValue receiver) {
+    public StackValue visitBlockExpression(@NotNull KtBlockExpression expression, StackValue receiver) {
         return generateBlock(expression, false);
     }
 
     @Override
-    public StackValue visitNamedFunction(@NotNull JetNamedFunction function, StackValue data) {
+    public StackValue visitNamedFunction(@NotNull KtNamedFunction function, StackValue data) {
         return visitNamedFunction(function, data, false);
     }
 
-    public StackValue visitNamedFunction(@NotNull JetNamedFunction function, StackValue data, boolean isStatement) {
+    public StackValue visitNamedFunction(@NotNull KtNamedFunction function, StackValue data, boolean isStatement) {
         assert data == StackValue.none();
 
-        if (JetPsiUtil.isScriptDeclaration(function)) {
+        if (KtPsiUtil.isScriptDeclaration(function)) {
             return StackValue.none();
         }
 
@@ -1393,7 +1393,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitFunctionLiteralExpression(@NotNull JetFunctionLiteralExpression expression, StackValue receiver) {
+    public StackValue visitFunctionLiteralExpression(@NotNull KtFunctionLiteralExpression expression, StackValue receiver) {
         if (Boolean.TRUE.equals(bindingContext.get(BLOCK, expression))) {
             return gen(expression.getFunctionLiteral().getBodyExpression());
         }
@@ -1403,7 +1403,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @NotNull
-    private StackValue genClosure(JetDeclarationWithBody declaration, @Nullable SamType samType) {
+    private StackValue genClosure(KtDeclarationWithBody declaration, @Nullable SamType samType) {
         FunctionDescriptor descriptor = bindingContext.get(FUNCTION, declaration);
         assert descriptor != null : "Function is not resolved to descriptor: " + declaration.getText();
 
@@ -1414,7 +1414,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
     @NotNull
     private StackValue genClosure(
-            @NotNull JetElement declaration,
+            @NotNull KtElement declaration,
             @NotNull FunctionDescriptor descriptor,
             @NotNull FunctionGenerationStrategy strategy,
             @Nullable SamType samType,
@@ -1442,7 +1442,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitObjectLiteralExpression(@NotNull JetObjectLiteralExpression expression, StackValue receiver) {
+    public StackValue visitObjectLiteralExpression(@NotNull KtObjectLiteralExpression expression, StackValue receiver) {
         final ObjectLiteralResult objectLiteralResult = generateObjectLiteral(expression);
         final ClassDescriptor classDescriptor = objectLiteralResult.classDescriptor;
         final Type type = typeMapper.mapType(classDescriptor);
@@ -1515,7 +1515,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             }
         }
 
-        JetType captureReceiver = closure.getCaptureReceiverType();
+        KtType captureReceiver = closure.getCaptureReceiverType();
         if (captureReceiver != null) {
             Type asmType = typeMapper.mapType(captureReceiver);
             StackValue.Local capturedReceiver = StackValue.local(AsmUtil.getReceiverIndex(context, context.getContextDescriptor()), asmType);
@@ -1542,8 +1542,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         }
     }
 
-    /* package */ StackValue generateBlock(@NotNull JetBlockExpression expression, boolean isStatement) {
-        if (expression.getParent() instanceof JetNamedFunction) {
+    /* package */ StackValue generateBlock(@NotNull KtBlockExpression expression, boolean isStatement) {
+        if (expression.getParent() instanceof KtNamedFunction) {
             // For functions end of block should be end of function label
             return generateBlock(expression.getStatements(), isStatement, null, context.getMethodEndLabel());
         }
@@ -1562,7 +1562,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     private StackValue generateBlock(
-            List<JetExpression> statements,
+            List<KtExpression> statements,
             boolean isStatement,
             Label labelBeforeLastExpression,
             @Nullable final Label labelBlockEnd
@@ -1573,14 +1573,14 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
         StackValue answer = StackValue.none();
 
-        for (Iterator<JetExpression> iterator = statements.iterator(); iterator.hasNext(); ) {
-            JetExpression possiblyLabeledStatement = iterator.next();
+        for (Iterator<KtExpression> iterator = statements.iterator(); iterator.hasNext(); ) {
+            KtExpression possiblyLabeledStatement = iterator.next();
 
-            JetElement statement = JetPsiUtil.safeDeparenthesize(possiblyLabeledStatement);
+            KtElement statement = KtPsiUtil.safeDeparenthesize(possiblyLabeledStatement);
 
-            if (statement instanceof JetNamedDeclaration) {
-                JetNamedDeclaration declaration = (JetNamedDeclaration) statement;
-                if (JetPsiUtil.isScriptDeclaration(declaration)) {
+            if (statement instanceof KtNamedDeclaration) {
+                KtNamedDeclaration declaration = (KtNamedDeclaration) statement;
+                if (KtPsiUtil.isScriptDeclaration(declaration)) {
                     continue;
                 }
             }
@@ -1629,19 +1629,19 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
 
-    private void putDescriptorIntoFrameMap(@NotNull JetElement statement) {
-        if (statement instanceof JetMultiDeclaration) {
-            JetMultiDeclaration multiDeclaration = (JetMultiDeclaration) statement;
-            for (JetMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
+    private void putDescriptorIntoFrameMap(@NotNull KtElement statement) {
+        if (statement instanceof KtMultiDeclaration) {
+            KtMultiDeclaration multiDeclaration = (KtMultiDeclaration) statement;
+            for (KtMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
                 putLocalVariableIntoFrameMap(entry);
             }
         }
 
-        if (statement instanceof JetVariableDeclaration) {
-            putLocalVariableIntoFrameMap((JetVariableDeclaration) statement);
+        if (statement instanceof KtVariableDeclaration) {
+            putLocalVariableIntoFrameMap((KtVariableDeclaration) statement);
         }
 
-        if (statement instanceof JetNamedFunction) {
+        if (statement instanceof KtNamedFunction) {
             DeclarationDescriptor descriptor = bindingContext.get(DECLARATION_TO_DESCRIPTOR, statement);
             assert descriptor instanceof FunctionDescriptor : "Couldn't find function declaration in binding context " + statement.getText();
             Type type = asmTypeForAnonymousClass(bindingContext, (FunctionDescriptor) descriptor);
@@ -1649,7 +1649,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         }
     }
 
-    private void putLocalVariableIntoFrameMap(@NotNull JetVariableDeclaration statement) {
+    private void putLocalVariableIntoFrameMap(@NotNull KtVariableDeclaration statement) {
         VariableDescriptor variableDescriptor = bindingContext.get(VARIABLE, statement);
         assert variableDescriptor != null : "Couldn't find variable declaration in binding context " + statement.getText();
 
@@ -1666,28 +1666,28 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     private void addLeaveTaskToRemoveDescriptorFromFrameMap(
-            @NotNull JetElement statement,
+            @NotNull KtElement statement,
             @NotNull Label blockEnd,
             @NotNull List<Function<StackValue, Void>> leaveTasks
     ) {
-        if (statement instanceof JetMultiDeclaration) {
-            JetMultiDeclaration multiDeclaration = (JetMultiDeclaration) statement;
-            for (JetMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
+        if (statement instanceof KtMultiDeclaration) {
+            KtMultiDeclaration multiDeclaration = (KtMultiDeclaration) statement;
+            for (KtMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
                 addLeaveTaskToRemoveLocalVariableFromFrameMap(entry, blockEnd, leaveTasks);
             }
         }
 
-        if (statement instanceof JetVariableDeclaration) {
-            addLeaveTaskToRemoveLocalVariableFromFrameMap((JetVariableDeclaration) statement, blockEnd, leaveTasks);
+        if (statement instanceof KtVariableDeclaration) {
+            addLeaveTaskToRemoveLocalVariableFromFrameMap((KtVariableDeclaration) statement, blockEnd, leaveTasks);
         }
 
-        if (statement instanceof JetNamedFunction) {
-            addLeaveTaskToRemoveNamedFunctionFromFrameMap((JetNamedFunction) statement, blockEnd, leaveTasks);
+        if (statement instanceof KtNamedFunction) {
+            addLeaveTaskToRemoveNamedFunctionFromFrameMap((KtNamedFunction) statement, blockEnd, leaveTasks);
         }
     }
 
     private void addLeaveTaskToRemoveLocalVariableFromFrameMap(
-            @NotNull JetVariableDeclaration statement,
+            @NotNull KtVariableDeclaration statement,
             final Label blockEnd,
             @NotNull List<Function<StackValue, Void>> leaveTasks
     ) {
@@ -1715,7 +1715,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     private void addLeaveTaskToRemoveNamedFunctionFromFrameMap(
-            @NotNull final JetNamedFunction statement,
+            @NotNull final KtNamedFunction statement,
             final Label blockEnd,
             @NotNull List<Function<StackValue, Void>> leaveTasks
     ) {
@@ -1747,11 +1747,11 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         this.shouldMarkLineNumbers = shouldMarkLineNumbers;
     }
 
-    public void markStartLineNumber(@NotNull JetElement element) {
+    public void markStartLineNumber(@NotNull KtElement element) {
         markLineNumber(element, false);
     }
 
-    public void markLineNumber(@NotNull JetElement statement, boolean markEndOffset) {
+    public void markLineNumber(@NotNull KtElement statement, boolean markEndOffset) {
         if (!shouldMarkLineNumbers) return;
 
         Integer lineNumber = CodegenUtil.getLineNumberForElement(statement, markEndOffset);
@@ -1820,7 +1820,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             BlockStackElement topOfStack = blockStackElements.pop();
             assert topOfStack == finallyBlockStackElement : "Top element of stack doesn't equals processing finally block";
 
-            JetTryExpression jetTryExpression = finallyBlockStackElement.expression;
+            KtTryExpression jetTryExpression = finallyBlockStackElement.expression;
             Label finallyStart = new Label();
             v.mark(finallyStart);
             finallyBlockStackElement.addGapLabel(finallyStart);
@@ -1852,8 +1852,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitReturnExpression(@NotNull JetReturnExpression expression, StackValue receiver) {
-        JetExpression returnedExpression = expression.getReturnedExpression();
+    public StackValue visitReturnExpression(@NotNull KtReturnExpression expression, StackValue receiver) {
+        KtExpression returnedExpression = expression.getReturnedExpression();
         CallableMemberDescriptor descriptor = getContext().getContextDescriptor();
         NonLocalReturnInfo nonLocalReturn = getNonLocalReturnInfo(descriptor, expression);
         boolean isNonLocalReturn = nonLocalReturn != null;
@@ -1898,7 +1898,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Nullable
-    private NonLocalReturnInfo getNonLocalReturnInfo(@NotNull CallableMemberDescriptor descriptor, @NotNull JetReturnExpression expression) {
+    private NonLocalReturnInfo getNonLocalReturnInfo(@NotNull CallableMemberDescriptor descriptor, @NotNull KtReturnExpression expression) {
         //call inside lambda
         if (isFunctionLiteral(descriptor) || isFunctionExpression(descriptor)) {
             if (expression.getLabelName() == null) {
@@ -1925,8 +1925,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         return null;
     }
 
-    public void returnExpression(JetExpression expr) {
-        boolean isBlockedNamedFunction = expr instanceof JetBlockExpression && expr.getParent() instanceof JetNamedFunction;
+    public void returnExpression(KtExpression expr) {
+        boolean isBlockedNamedFunction = expr instanceof KtBlockExpression && expr.getParent() instanceof KtNamedFunction;
 
         // If generating body for named block-bodied function, generate it as sequence of statements
         gen(expr, isBlockedNamedFunction ? Type.VOID_TYPE : returnType);
@@ -1944,17 +1944,17 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         }
     }
 
-    private static boolean endsWithReturn(JetElement bodyExpression) {
-        if (bodyExpression instanceof JetBlockExpression) {
-            List<JetExpression> statements = ((JetBlockExpression) bodyExpression).getStatements();
-            return statements.size() > 0 && statements.get(statements.size() - 1) instanceof JetReturnExpression;
+    private static boolean endsWithReturn(KtElement bodyExpression) {
+        if (bodyExpression instanceof KtBlockExpression) {
+            List<KtExpression> statements = ((KtBlockExpression) bodyExpression).getStatements();
+            return statements.size() > 0 && statements.get(statements.size() - 1) instanceof KtReturnExpression;
         }
 
-        return bodyExpression instanceof JetReturnExpression;
+        return bodyExpression instanceof KtReturnExpression;
     }
 
     @Override
-    public StackValue visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression, @NotNull StackValue receiver) {
+    public StackValue visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression, @NotNull StackValue receiver) {
         ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(expression, bindingContext);
 
         DeclarationDescriptor descriptor;
@@ -1998,7 +1998,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             Collection<ExpressionCodegenExtension> codegenExtensions = ExpressionCodegenExtension.Companion.getInstances(state.getProject());
             if (!codegenExtensions.isEmpty() && resolvedCall != null) {
                 ExpressionCodegenExtension.Context context = new ExpressionCodegenExtension.Context(typeMapper, v);
-                JetType returnType = propertyDescriptor.getReturnType();
+                KtType returnType = propertyDescriptor.getReturnType();
                 for (ExpressionCodegenExtension extension : codegenExtensions) {
                     if (returnType != null) {
                         StackValue value = extension.applyProperty(receiver, resolvedCall, context);
@@ -2008,9 +2008,9 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             }
 
             boolean directToField =
-                    (expression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER || isSyntheticField)
+                    (expression.getReferencedNameElementType() == KtTokens.FIELD_IDENTIFIER || isSyntheticField)
                     && contextKind() != OwnerKind.DEFAULT_IMPLS;
-            JetSuperExpression superExpression =
+            KtSuperExpression superExpression =
                     resolvedCall == null ? null : CallResolverUtilKt.getSuperCallExpression(resolvedCall.getCall());
             propertyDescriptor = context.accessibleDescriptor(propertyDescriptor, superExpression);
 
@@ -2103,7 +2103,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     private StackValue stackValueForLocal(DeclarationDescriptor descriptor, int index) {
         if (descriptor instanceof VariableDescriptor) {
             Type sharedVarType = typeMapper.getSharedVarType(descriptor);
-            JetType outType = ((VariableDescriptor) descriptor).getType();
+            KtType outType = ((VariableDescriptor) descriptor).getType();
             if (sharedVarType != null) {
                 return StackValue.shared(index, asmType(outType));
             }
@@ -2126,7 +2126,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Nullable
-    private static JetType getPropertyDelegateType(@NotNull PropertyDescriptor descriptor, @NotNull BindingContext bindingContext) {
+    private static KtType getPropertyDelegateType(@NotNull PropertyDescriptor descriptor, @NotNull BindingContext bindingContext) {
         PropertyGetterDescriptor getter = descriptor.getGetter();
         if (getter != null) {
             Call call = bindingContext.get(DELEGATED_PROPERTY_CALL, getter);
@@ -2139,7 +2139,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     public StackValue.Property intermediateValueForProperty(
             @NotNull PropertyDescriptor propertyDescriptor,
             boolean forceField,
-            @Nullable JetSuperExpression superExpression,
+            @Nullable KtSuperExpression superExpression,
             @NotNull StackValue receiver
     ) {
         return intermediateValueForProperty(propertyDescriptor, forceField, superExpression, false, receiver);
@@ -2148,7 +2148,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     public StackValue.Property intermediateValueForProperty(
             @NotNull PropertyDescriptor propertyDescriptor,
             boolean forceField,
-            @Nullable JetSuperExpression superExpression,
+            @Nullable KtSuperExpression superExpression,
             boolean skipAccessorsForPrivateFieldInOuterClass,
             StackValue receiver
     ) {
@@ -2164,7 +2164,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         boolean isSuper = superExpression != null;
         boolean isExtensionProperty = propertyDescriptor.getExtensionReceiverParameter() != null;
 
-        JetType delegateType = getPropertyDelegateType(propertyDescriptor, bindingContext);
+        KtType delegateType = getPropertyDelegateType(propertyDescriptor, bindingContext);
         boolean isDelegatedProperty = delegateType != null;
 
         CallableMethod callableGetter = null;
@@ -2263,7 +2263,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitCallExpression(@NotNull JetCallExpression expression, StackValue receiver) {
+    public StackValue visitCallExpression(@NotNull KtCallExpression expression, StackValue receiver) {
         ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCallWithAssert(expression, bindingContext);
         FunctionDescriptor descriptor = accessibleFunctionDescriptor(resolvedCall);
 
@@ -2272,7 +2272,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         }
 
         if (descriptor.getOriginal() instanceof SamConstructorDescriptor) {
-            JetExpression argumentExpression = bindingContext.get(SAM_CONSTRUCTOR_TO_ARGUMENT, expression);
+            KtExpression argumentExpression = bindingContext.get(SAM_CONSTRUCTOR_TO_ARGUMENT, expression);
             assert argumentExpression != null : "Argument expression is not saved for a SAM constructor: " + descriptor;
             return genSamInterfaceValue(argumentExpression, this);
         }
@@ -2282,19 +2282,19 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
     @Nullable
     private StackValue genSamInterfaceValue(
-            @NotNull JetExpression probablyParenthesizedExpression,
-            @NotNull final JetVisitor<StackValue, StackValue> visitor
+            @NotNull KtExpression probablyParenthesizedExpression,
+            @NotNull final KtVisitor<StackValue, StackValue> visitor
     ) {
-        final JetExpression expression = JetPsiUtil.deparenthesize(probablyParenthesizedExpression);
+        final KtExpression expression = KtPsiUtil.deparenthesize(probablyParenthesizedExpression);
         final SamType samType = bindingContext.get(SAM_VALUE, probablyParenthesizedExpression);
         if (samType == null || expression == null) return null;
 
-        if (expression instanceof JetFunctionLiteralExpression) {
-            return genClosure(((JetFunctionLiteralExpression) expression).getFunctionLiteral(), samType);
+        if (expression instanceof KtFunctionLiteralExpression) {
+            return genClosure(((KtFunctionLiteralExpression) expression).getFunctionLiteral(), samType);
         }
 
-        if (expression instanceof JetNamedFunction) {
-            return genClosure((JetNamedFunction) expression, samType);
+        if (expression instanceof KtNamedFunction) {
+            return genClosure((KtNamedFunction) expression, samType);
         }
 
         final Type asmType =
@@ -2362,7 +2362,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     @NotNull
     public StackValue invokeFunction(@NotNull Call call, @NotNull ResolvedCall<?> resolvedCall, @NotNull StackValue receiver) {
         FunctionDescriptor fd = accessibleFunctionDescriptor(resolvedCall);
-        JetSuperExpression superCallExpression = CallResolverUtilKt.getSuperCallExpression(call);
+        KtSuperExpression superCallExpression = CallResolverUtilKt.getSuperCallExpression(call);
         boolean superCall = superCallExpression != null;
 
         if (superCall && !isJvmInterface(fd.getContainingDeclaration())) {
@@ -2481,7 +2481,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     @NotNull
     protected CallGenerator getOrCreateCallGenerator(
             @NotNull CallableDescriptor descriptor,
-            @Nullable JetElement callElement,
+            @Nullable KtElement callElement,
             @Nullable ReifiedTypeParameterMappings reifiedTypeParameterMappings
     ) {
         if (callElement == null) return defaultCallGenerator;
@@ -2498,19 +2498,19 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @NotNull
-    public CallGenerator getOrCreateCallGenerator(@NotNull FunctionDescriptor descriptor, @Nullable JetNamedFunction function) {
+    public CallGenerator getOrCreateCallGenerator(@NotNull FunctionDescriptor descriptor, @Nullable KtNamedFunction function) {
         return getOrCreateCallGenerator(descriptor, function, null);
     }
 
     @NotNull
     private CallGenerator getOrCreateCallGenerator(@NotNull ResolvedCall<?> resolvedCall) {
-        Map<TypeParameterDescriptor, JetType> typeArguments = resolvedCall.getTypeArguments();
+        Map<TypeParameterDescriptor, KtType> typeArguments = resolvedCall.getTypeArguments();
         ReifiedTypeParameterMappings mappings = new ReifiedTypeParameterMappings();
-        for (Map.Entry<TypeParameterDescriptor, JetType> entry : typeArguments.entrySet()) {
+        for (Map.Entry<TypeParameterDescriptor, KtType> entry : typeArguments.entrySet()) {
             TypeParameterDescriptor key = entry.getKey();
             if (!key.isReified()) continue;
 
-            JetType type = entry.getValue();
+            KtType type = entry.getValue();
             TypeParameterDescriptor parameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(type);
             if (parameterDescriptor == null) {
                 // type is not generic
@@ -2667,7 +2667,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
 
-    public void genVarargs(@NotNull VarargValueArgument valueArgument, @NotNull JetType outType) {
+    public void genVarargs(@NotNull VarargValueArgument valueArgument, @NotNull KtType outType) {
         Type type = asmType(outType);
         assert type.getSort() == Type.ARRAY;
         Type elementType = correctElementType(type);
@@ -2751,7 +2751,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         }
     }
 
-    public int indexOfLocal(JetReferenceExpression lhs) {
+    public int indexOfLocal(KtReferenceExpression lhs) {
         DeclarationDescriptor declarationDescriptor = bindingContext.get(REFERENCE_TARGET, lhs);
         if (isVarCapturedInClosure(bindingContext, declarationDescriptor)) {
             return -1;
@@ -2760,8 +2760,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitClassLiteralExpression(@NotNull JetClassLiteralExpression expression, StackValue data) {
-        JetType type = bindingContext.getType(expression);
+    public StackValue visitClassLiteralExpression(@NotNull KtClassLiteralExpression expression, StackValue data) {
+        KtType type = bindingContext.getType(expression);
         assert type != null;
 
         assert state.getReflectionTypes().getKClass().getTypeConstructor().equals(type.getConstructor())
@@ -2771,7 +2771,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitCallableReferenceExpression(@NotNull JetCallableReferenceExpression expression, StackValue data) {
+    public StackValue visitCallableReferenceExpression(@NotNull KtCallableReferenceExpression expression, StackValue data) {
         ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCallWithAssert(expression.getCallableReference(), bindingContext);
         FunctionDescriptor functionDescriptor = bindingContext.get(FUNCTION, expression);
         if (functionDescriptor != null) {
@@ -2790,7 +2790,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
     @NotNull
     public StackValue generatePropertyReference(
-            @NotNull JetElement element,
+            @NotNull KtElement element,
             @NotNull VariableDescriptor variableDescriptor,
             @NotNull VariableDescriptor target,
             @NotNull ReceiverValue dispatchReceiver
@@ -2813,7 +2813,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @NotNull
-    public static StackValue generateClassLiteralReference(@NotNull final JetTypeMapper typeMapper, @NotNull final JetType type) {
+    public static StackValue generateClassLiteralReference(@NotNull final JetTypeMapper typeMapper, @NotNull final KtType type) {
         return StackValue.operation(K_CLASS_TYPE, new Function1<InstructionAdapter, Unit>() {
             @Override
             public Unit invoke(InstructionAdapter v) {
@@ -2839,29 +2839,29 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitDotQualifiedExpression(@NotNull JetDotQualifiedExpression expression, StackValue receiver) {
+    public StackValue visitDotQualifiedExpression(@NotNull KtDotQualifiedExpression expression, StackValue receiver) {
         StackValue receiverValue = StackValue.none(); //gen(expression.getReceiverExpression())
         return genQualified(receiverValue, expression.getSelectorExpression());
     }
 
-    private StackValue generateExpressionWithNullFallback(@NotNull JetExpression expression, @NotNull Label ifnull) {
-        JetExpression deparenthesized = JetPsiUtil.deparenthesize(expression);
+    private StackValue generateExpressionWithNullFallback(@NotNull KtExpression expression, @NotNull Label ifnull) {
+        KtExpression deparenthesized = KtPsiUtil.deparenthesize(expression);
         assert deparenthesized != null : "Unexpected empty expression";
 
         expression = deparenthesized;
         Type type = expressionType(expression);
 
-        if (expression instanceof JetSafeQualifiedExpression && !isPrimitive(type)) {
-            return StackValue.coercion(generateSafeQualifiedExpression((JetSafeQualifiedExpression) expression, ifnull), type);
+        if (expression instanceof KtSafeQualifiedExpression && !isPrimitive(type)) {
+            return StackValue.coercion(generateSafeQualifiedExpression((KtSafeQualifiedExpression) expression, ifnull), type);
         }
         else {
             return genLazy(expression, type);
         }
     }
 
-    private StackValue generateSafeQualifiedExpression(@NotNull JetSafeQualifiedExpression expression, @NotNull Label ifNull) {
-        JetExpression receiver = expression.getReceiverExpression();
-        JetExpression selector = expression.getSelectorExpression();
+    private StackValue generateSafeQualifiedExpression(@NotNull KtSafeQualifiedExpression expression, @NotNull Label ifNull) {
+        KtExpression receiver = expression.getReceiverExpression();
+        KtExpression selector = expression.getSelectorExpression();
 
         Type receiverType = expressionType(receiver);
         StackValue receiverValue = generateExpressionWithNullFallback(receiver, ifNull);
@@ -2872,7 +2872,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitSafeQualifiedExpression(@NotNull JetSafeQualifiedExpression expression, StackValue unused) {
+    public StackValue visitSafeQualifiedExpression(@NotNull KtSafeQualifiedExpression expression, StackValue unused) {
         Label ifnull = new Label();
         Type type = boxType(expressionType(expression));
 
@@ -2890,33 +2890,33 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitBinaryExpression(@NotNull JetBinaryExpression expression, @NotNull StackValue receiver) {
-        JetSimpleNameExpression reference = expression.getOperationReference();
+    public StackValue visitBinaryExpression(@NotNull KtBinaryExpression expression, @NotNull StackValue receiver) {
+        KtSimpleNameExpression reference = expression.getOperationReference();
         IElementType opToken = reference.getReferencedNameElementType();
-        if (opToken == JetTokens.EQ) {
+        if (opToken == KtTokens.EQ) {
             return generateAssignmentExpression(expression);
         }
-        else if (JetTokens.AUGMENTED_ASSIGNMENTS.contains(opToken)) {
+        else if (KtTokens.AUGMENTED_ASSIGNMENTS.contains(opToken)) {
             return generateAugmentedAssignment(expression);
         }
-        else if (opToken == JetTokens.ANDAND) {
+        else if (opToken == KtTokens.ANDAND) {
             return generateBooleanAnd(expression);
         }
-        else if (opToken == JetTokens.OROR) {
+        else if (opToken == KtTokens.OROR) {
             return generateBooleanOr(expression);
         }
-        else if (opToken == JetTokens.EQEQ || opToken == JetTokens.EXCLEQ ||
-                 opToken == JetTokens.EQEQEQ || opToken == JetTokens.EXCLEQEQEQ) {
+        else if (opToken == KtTokens.EQEQ || opToken == KtTokens.EXCLEQ ||
+                 opToken == KtTokens.EQEQEQ || opToken == KtTokens.EXCLEQEQEQ) {
             return generateEquals(expression.getLeft(), expression.getRight(), opToken);
         }
-        else if (opToken == JetTokens.LT || opToken == JetTokens.LTEQ ||
-                 opToken == JetTokens.GT || opToken == JetTokens.GTEQ) {
+        else if (opToken == KtTokens.LT || opToken == KtTokens.LTEQ ||
+                 opToken == KtTokens.GT || opToken == KtTokens.GTEQ) {
             return generateComparison(expression, receiver);
         }
-        else if (opToken == JetTokens.ELVIS) {
+        else if (opToken == KtTokens.ELVIS) {
             return generateElvis(expression);
         }
-        else if (opToken == JetTokens.IN_KEYWORD || opToken == JetTokens.NOT_IN) {
+        else if (opToken == KtTokens.IN_KEYWORD || opToken == KtTokens.NOT_IN) {
             return generateIn(StackValue.expression(expressionType(expression.getLeft()), expression.getLeft(), this),
                               expression.getRight(), reference);
         }
@@ -2932,8 +2932,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         }
     }
 
-    private StackValue generateIn(final StackValue leftValue, JetExpression rangeExpression, final JetSimpleNameExpression operationReference) {
-        final JetExpression deparenthesized = JetPsiUtil.deparenthesize(rangeExpression);
+    private StackValue generateIn(final StackValue leftValue, KtExpression rangeExpression, final KtSimpleNameExpression operationReference) {
+        final KtExpression deparenthesized = KtPsiUtil.deparenthesize(rangeExpression);
 
         assert deparenthesized != null : "For with empty range expression";
 
@@ -2941,7 +2941,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             @Override
             public Unit invoke(InstructionAdapter v) {
                 if (isIntRangeExpr(deparenthesized) && AsmUtil.isIntPrimitive(leftValue.type)) {
-                    genInIntRange(leftValue, (JetBinaryExpression) deparenthesized);
+                    genInIntRange(leftValue, (KtBinaryExpression) deparenthesized);
                 }
                 else {
                     ResolvedCall<? extends CallableDescriptor> resolvedCall = CallUtilKt
@@ -2949,7 +2949,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
                     StackValue result = invokeFunction(resolvedCall.getCall(), resolvedCall, StackValue.none());
                     result.put(result.type, v);
                 }
-                if (operationReference.getReferencedNameElementType() == JetTokens.NOT_IN) {
+                if (operationReference.getReferencedNameElementType() == KtTokens.NOT_IN) {
                     genInvertBoolean(v);
                 }
                 return null;
@@ -2957,7 +2957,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         });
     }
 
-    private void genInIntRange(StackValue leftValue, JetBinaryExpression rangeExpression) {
+    private void genInIntRange(StackValue leftValue, KtBinaryExpression rangeExpression) {
         v.iconst(1);
         // 1
         leftValue.put(Type.INT_TYPE, v);
@@ -2993,23 +2993,23 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         v.and(Type.INT_TYPE);
     }
 
-    private StackValue generateBooleanAnd(JetBinaryExpression expression) {
+    private StackValue generateBooleanAnd(KtBinaryExpression expression) {
         return StackValue.and(gen(expression.getLeft()), gen(expression.getRight()));
     }
 
-    private StackValue generateBooleanOr(JetBinaryExpression expression) {
+    private StackValue generateBooleanOr(KtBinaryExpression expression) {
         return StackValue.or(gen(expression.getLeft()), gen(expression.getRight()));
     }
 
-    private StackValue generateEquals(JetExpression left, JetExpression right, IElementType opToken) {
+    private StackValue generateEquals(KtExpression left, KtExpression right, IElementType opToken) {
         Type leftType = expressionType(left);
         Type rightType = expressionType(right);
 
-        if (JetPsiUtil.isNullConstant(left)) {
+        if (KtPsiUtil.isNullConstant(left)) {
             return genCmpWithNull(right, opToken);
         }
 
-        if (JetPsiUtil.isNullConstant(right)) {
+        if (KtPsiUtil.isNullConstant(right)) {
             return genCmpWithNull(left, opToken);
         }
 
@@ -3029,7 +3029,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         StackValue leftValue = genLazy(left, leftType);
         StackValue rightValue = genLazy(right, rightType);
 
-        if (opToken == JetTokens.EQEQEQ || opToken == JetTokens.EXCLEQEQEQ) {
+        if (opToken == KtTokens.EQEQEQ || opToken == KtTokens.EXCLEQEQEQ) {
             // TODO: always casting to the type of the left operand in case of primitives looks wrong
             Type operandType = isPrimitive(leftType) ? leftType : OBJECT_TYPE;
             return StackValue.cmp(opToken, operandType, leftValue, rightValue);
@@ -3038,21 +3038,21 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         return genEqualsForExpressionsOnStack(opToken, leftValue, rightValue);
     }
 
-    private boolean isIntZero(JetExpression expr, Type exprType) {
+    private boolean isIntZero(KtExpression expr, Type exprType) {
         ConstantValue<?> exprValue = getCompileTimeConstant(expr, bindingContext);
         return isIntPrimitive(exprType) && exprValue != null && Integer.valueOf(0).equals(exprValue.getValue());
     }
 
-    private StackValue genCmpWithZero(JetExpression exp, IElementType opToken) {
-        return StackValue.compareIntWithZero(gen(exp), (JetTokens.EQEQ == opToken || JetTokens.EQEQEQ == opToken) ? IFNE : IFEQ);
+    private StackValue genCmpWithZero(KtExpression exp, IElementType opToken) {
+        return StackValue.compareIntWithZero(gen(exp), (KtTokens.EQEQ == opToken || KtTokens.EQEQEQ == opToken) ? IFNE : IFEQ);
     }
 
-    private StackValue genCmpWithNull(JetExpression exp, IElementType opToken) {
-        return StackValue.compareWithNull(gen(exp), (JetTokens.EQEQ == opToken || JetTokens.EQEQEQ == opToken) ? IFNONNULL : IFNULL);
+    private StackValue genCmpWithNull(KtExpression exp, IElementType opToken) {
+        return StackValue.compareWithNull(gen(exp), (KtTokens.EQEQ == opToken || KtTokens.EQEQEQ == opToken) ? IFNONNULL : IFNULL);
     }
 
-    private StackValue generateElvis(@NotNull final JetBinaryExpression expression) {
-        JetExpression left = expression.getLeft();
+    private StackValue generateElvis(@NotNull final KtBinaryExpression expression) {
+        KtExpression left = expression.getLeft();
 
         final Type exprType = expressionType(expression);
         final Type leftType = expressionType(left);
@@ -3088,11 +3088,11 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         });
     }
 
-    private StackValue generateComparison(JetBinaryExpression expression, StackValue receiver) {
+    private StackValue generateComparison(KtBinaryExpression expression, StackValue receiver) {
         ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCallWithAssert(expression, bindingContext);
 
-        JetExpression left = expression.getLeft();
-        JetExpression right = expression.getRight();
+        KtExpression left = expression.getLeft();
+        KtExpression right = expression.getRight();
 
         Type type;
         StackValue leftValue;
@@ -3112,19 +3112,19 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         return StackValue.cmp(expression.getOperationToken(), type, leftValue, rightValue);
     }
 
-    private StackValue generateAssignmentExpression(JetBinaryExpression expression) {
+    private StackValue generateAssignmentExpression(KtBinaryExpression expression) {
         StackValue stackValue = gen(expression.getLeft());
-        JetExpression right = expression.getRight();
+        KtExpression right = expression.getRight();
         assert right != null : expression.getText();
         stackValue.store(gen(right), v);
         return StackValue.none();
     }
 
-    private StackValue generateAugmentedAssignment(JetBinaryExpression expression) {
+    private StackValue generateAugmentedAssignment(KtBinaryExpression expression) {
         ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCallWithAssert(expression, bindingContext);
         FunctionDescriptor descriptor = (FunctionDescriptor) resolvedCall.getResultingDescriptor();
         Callable callable = resolveToCallable(descriptor, false, resolvedCall);
-        JetExpression lhs = expression.getLeft();
+        KtExpression lhs = expression.getLeft();
         Type lhsType = expressionType(lhs);
 
         boolean keepReturnValue = Boolean.TRUE.equals(bindingContext.get(VARIABLE_REASSIGNMENT, expression))
@@ -3136,7 +3136,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     private void callAugAssignMethod(
-            @NotNull JetBinaryExpression expression,
+            @NotNull KtBinaryExpression expression,
             @NotNull ResolvedCall<?> resolvedCall,
             @NotNull Callable callable,
             @NotNull Type lhsType,
@@ -3156,12 +3156,12 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         }
     }
 
-    public void invokeAppend(JetExpression expr) {
-        if (expr instanceof JetBinaryExpression) {
-            JetBinaryExpression binaryExpression = (JetBinaryExpression) expr;
-            if (binaryExpression.getOperationToken() == JetTokens.PLUS) {
-                JetExpression left = binaryExpression.getLeft();
-                JetExpression right = binaryExpression.getRight();
+    public void invokeAppend(KtExpression expr) {
+        if (expr instanceof KtBinaryExpression) {
+            KtBinaryExpression binaryExpression = (KtBinaryExpression) expr;
+            if (binaryExpression.getOperationToken() == KtTokens.PLUS) {
+                KtExpression left = binaryExpression.getLeft();
+                KtExpression right = binaryExpression.getRight();
                 Type leftType = expressionType(left);
 
                 if (leftType.equals(JAVA_STRING_TYPE)) {
@@ -3177,22 +3177,22 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Nullable
-    private static JetSimpleNameExpression targetLabel(JetExpression expression) {
-        if (expression.getParent() instanceof JetLabeledExpression) {
-            return ((JetLabeledExpression) expression.getParent()).getTargetLabel();
+    private static KtSimpleNameExpression targetLabel(KtExpression expression) {
+        if (expression.getParent() instanceof KtLabeledExpression) {
+            return ((KtLabeledExpression) expression.getParent()).getTargetLabel();
         }
         return null;
     }
 
     @Override
     public StackValue visitLabeledExpression(
-            @NotNull JetLabeledExpression expression, StackValue receiver
+            @NotNull KtLabeledExpression expression, StackValue receiver
     ) {
         return genQualified(receiver, expression.getBaseExpression());
     }
 
     @Override
-    public StackValue visitPrefixExpression(@NotNull JetPrefixExpression expression, @NotNull StackValue receiver) {
+    public StackValue visitPrefixExpression(@NotNull KtPrefixExpression expression, @NotNull StackValue receiver) {
         DeclarationDescriptor originalOperation = bindingContext.get(REFERENCE_TARGET, expression.getOperationReference());
         ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCallWithAssert(expression, bindingContext);
         CallableDescriptor op = resolvedCall.getResultingDescriptor();
@@ -3210,8 +3210,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitPostfixExpression(@NotNull final JetPostfixExpression expression, StackValue receiver) {
-        if (expression.getOperationReference().getReferencedNameElementType() == JetTokens.EXCLEXCL) {
+    public StackValue visitPostfixExpression(@NotNull final KtPostfixExpression expression, StackValue receiver) {
+        if (expression.getOperationReference().getReferencedNameElementType() == KtTokens.EXCLEXCL) {
             final StackValue base = genQualified(receiver, expression.getBaseExpression());
             if (isPrimitive(base.type)) {
                 return base;
@@ -3258,11 +3258,11 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
         final boolean isPrimitiveNumberClassDescriptor = isPrimitiveNumberClassDescriptor(cls);
         if (isPrimitiveNumberClassDescriptor && AsmUtil.isPrimitive(asmBaseType)) {
-            JetExpression operand = expression.getBaseExpression();
+            KtExpression operand = expression.getBaseExpression();
             // Optimization for j = i++, when j and i are Int without any smart cast: we just work with primitive int
-            if (operand instanceof JetReferenceExpression && asmResultType == Type.INT_TYPE &&
+            if (operand instanceof KtReferenceExpression && asmResultType == Type.INT_TYPE &&
                 bindingContext.get(BindingContext.SMARTCAST, operand) == null) {
-                int index = indexOfLocal((JetReferenceExpression) operand);
+                int index = indexOfLocal((KtReferenceExpression) operand);
                 if (index >= 0) {
                     return StackValue.postIncrement(index, increment);
                 }
@@ -3298,8 +3298,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitProperty(@NotNull JetProperty property, StackValue receiver) {
-        JetExpression initializer = property.getInitializer();
+    public StackValue visitProperty(@NotNull KtProperty property, StackValue receiver) {
+        KtExpression initializer = property.getInitializer();
         if (initializer == null) {
             return StackValue.none();
         }
@@ -3308,11 +3308,11 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration, StackValue receiver) {
-        JetExpression initializer = multiDeclaration.getInitializer();
+    public StackValue visitMultiDeclaration(@NotNull KtMultiDeclaration multiDeclaration, StackValue receiver) {
+        KtExpression initializer = multiDeclaration.getInitializer();
         if (initializer == null) return StackValue.none();
 
-        JetType initializerType = bindingContext.getType(initializer);
+        KtType initializerType = bindingContext.getType(initializer);
         assert initializerType != null;
 
         Type initializerAsmType = asmType(initializerType);
@@ -3325,7 +3325,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         v.store(tempVarIndex, initializerAsmType);
         StackValue.Local local = StackValue.local(tempVarIndex, initializerAsmType);
 
-        for (JetMultiDeclarationEntry variableDeclaration : multiDeclaration.getEntries()) {
+        for (KtMultiDeclarationEntry variableDeclaration : multiDeclaration.getEntries()) {
             ResolvedCall<FunctionDescriptor> resolvedCall = bindingContext.get(COMPONENT_RESOLVED_CALL, variableDeclaration);
             assert resolvedCall != null : "Resolved call is null for " + variableDeclaration.getText();
             Call call = makeFakeCall(initializerAsReceiver);
@@ -3342,12 +3342,12 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     private void initializeLocalVariable(
-            @NotNull JetVariableDeclaration variableDeclaration,
+            @NotNull KtVariableDeclaration variableDeclaration,
             @NotNull StackValue initializer
     ) {
         VariableDescriptor variableDescriptor = bindingContext.get(VARIABLE, variableDeclaration);
 
-        if (JetPsiUtil.isScriptDeclaration(variableDeclaration)) {
+        if (KtPsiUtil.isScriptDeclaration(variableDeclaration)) {
             return;
         }
         int index = lookupLocalIndex(variableDescriptor);
@@ -3363,8 +3363,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
         StackValue storeTo;
         // SCRIPT: Variable at the top of the script is generated as field
-        if (JetPsiUtil.isScriptDeclaration(variableDeclaration)) {
-            JetScript scriptPsi = JetPsiUtil.getScript(variableDeclaration);
+        if (KtPsiUtil.isScriptDeclaration(variableDeclaration)) {
+            KtScript scriptPsi = KtPsiUtil.getScript(variableDeclaration);
             assert scriptPsi != null;
             Type scriptClassType = asmTypeForScriptPsi(bindingContext, scriptPsi);
             storeTo = StackValue.field(varType, scriptClassType, variableDeclaration.getName(), false, StackValue.LOCAL_0, variableDescriptor);
@@ -3380,7 +3380,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @NotNull
-    private StackValue generateNewCall(@NotNull JetCallExpression expression, @NotNull ResolvedCall<?> resolvedCall) {
+    private StackValue generateNewCall(@NotNull KtCallExpression expression, @NotNull ResolvedCall<?> resolvedCall) {
         Type type = expressionType(expression);
         if (type.getSort() == Type.ARRAY) {
             //noinspection ConstantConditions
@@ -3427,10 +3427,10 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         });
     }
 
-    public StackValue generateNewArray(@NotNull JetCallExpression expression, @NotNull final JetType arrayType) {
+    public StackValue generateNewArray(@NotNull KtCallExpression expression, @NotNull final KtType arrayType) {
         assert expression.getValueArguments().size() == 1 : "Size argument expected";
 
-        final JetExpression sizeExpression = expression.getValueArguments().get(0).getArgumentExpression();
+        final KtExpression sizeExpression = expression.getValueArguments().get(0).getArgumentExpression();
         Type type = typeMapper.mapType(arrayType);
 
         return StackValue.operation(type, new Function1<InstructionAdapter, Unit>() {
@@ -3443,9 +3443,9 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         });
     }
 
-    public void newArrayInstruction(@NotNull JetType arrayType) {
+    public void newArrayInstruction(@NotNull KtType arrayType) {
         if (KotlinBuiltIns.isArray(arrayType)) {
-            JetType elementJetType = arrayType.getArguments().get(0).getType();
+            KtType elementJetType = arrayType.getArguments().get(0).getType();
             putReifierMarkerIfTypeIsReifiedParameter(
                     elementJetType,
                     ReifiedTypeInliner.NEW_ARRAY_MARKER_METHOD_NAME
@@ -3459,11 +3459,11 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitArrayAccessExpression(@NotNull JetArrayAccessExpression expression, StackValue receiver) {
-        JetExpression array = expression.getArrayExpression();
-        JetType type = array != null ? bindingContext.getType(array) : null;
+    public StackValue visitArrayAccessExpression(@NotNull KtArrayAccessExpression expression, StackValue receiver) {
+        KtExpression array = expression.getArrayExpression();
+        KtType type = array != null ? bindingContext.getType(array) : null;
         Type arrayType = expressionType(array);
-        List<JetExpression> indices = expression.getIndexExpressions();
+        List<KtExpression> indices = expression.getIndexExpressions();
         FunctionDescriptor operationDescriptor = (FunctionDescriptor) bindingContext.get(REFERENCE_TARGET, expression);
         assert operationDescriptor != null;
         if (arrayType.getSort() == Type.ARRAY &&
@@ -3472,7 +3472,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             assert type != null;
             Type elementType;
             if (KotlinBuiltIns.isArray(type)) {
-                JetType jetElementType = type.getArguments().get(0).getType();
+                KtType jetElementType = type.getArguments().get(0).getType();
                 elementType = boxType(asmType(jetElementType));
             }
             else {
@@ -3504,7 +3504,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
     @NotNull
     private StackValue createCollectionElementReceiver(
-            @NotNull JetArrayAccessExpression expression,
+            @NotNull KtArrayAccessExpression expression,
             @NotNull StackValue receiver,
             @NotNull FunctionDescriptor operationDescriptor,
             boolean isGetter,
@@ -3534,14 +3534,14 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitThrowExpression(@NotNull JetThrowExpression expression, StackValue receiver) {
+    public StackValue visitThrowExpression(@NotNull KtThrowExpression expression, StackValue receiver) {
         gen(expression.getThrownExpression(), JAVA_THROWABLE_TYPE);
         v.athrow();
         return StackValue.none();
     }
 
     @Override
-    public StackValue visitThisExpression(@NotNull JetThisExpression expression, StackValue receiver) {
+    public StackValue visitThisExpression(@NotNull KtThisExpression expression, StackValue receiver) {
         DeclarationDescriptor descriptor = bindingContext.get(REFERENCE_TARGET, expression.getInstanceReference());
         if (descriptor instanceof ClassDescriptor) {
             //TODO rewrite with context.lookupInContext()
@@ -3554,24 +3554,24 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     @Override
-    public StackValue visitTryExpression(@NotNull JetTryExpression expression, StackValue receiver) {
+    public StackValue visitTryExpression(@NotNull KtTryExpression expression, StackValue receiver) {
         return generateTryExpression(expression, false);
     }
 
-    public StackValue generateTryExpression(final JetTryExpression expression, final boolean isStatement) {
+    public StackValue generateTryExpression(final KtTryExpression expression, final boolean isStatement) {
         /*
 The "returned" value of try expression with no finally is either the last expression in the try block or the last expression in the catch block
 (or blocks).
          */
 
-        JetType jetType = bindingContext.getType(expression);
+        KtType jetType = bindingContext.getType(expression);
         assert jetType != null;
         final Type expectedAsmType = isStatement ? Type.VOID_TYPE : asmType(jetType);
 
         return StackValue.operation(expectedAsmType, new Function1<InstructionAdapter, Unit>() {
             @Override
             public Unit invoke(InstructionAdapter v) {
-                JetFinallySection finallyBlock = expression.getFinallyBlock();
+                KtFinallySection finallyBlock = expression.getFinallyBlock();
                 FinallyBlockStackElement finallyBlockStackElement = null;
                 if (finallyBlock != null) {
                     finallyBlockStackElement = new FinallyBlockStackElement(expression);
@@ -3602,9 +3602,9 @@ The "returned" value of try expression with no finally is either the last expres
 
                 genFinallyBlockOrGoto(finallyBlockStackElement, end, null);
 
-                List<JetCatchClause> clauses = expression.getCatchClauses();
+                List<KtCatchClause> clauses = expression.getCatchClauses();
                 for (int i = 0, size = clauses.size(); i < size; i++) {
-                    JetCatchClause clause = clauses.get(i);
+                    KtCatchClause clause = clauses.get(i);
 
                     Label clauseStart = new Label();
                     v.mark(clauseStart);
@@ -3702,11 +3702,11 @@ The "returned" value of try expression with no finally is either the last expres
     }
 
     @Override
-    public StackValue visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS expression, StackValue receiver) {
-        JetExpression left = expression.getLeft();
+    public StackValue visitBinaryWithTypeRHSExpression(@NotNull KtBinaryExpressionWithTypeRHS expression, StackValue receiver) {
+        KtExpression left = expression.getLeft();
         final IElementType opToken = expression.getOperationReference().getReferencedNameElementType();
 
-        final JetType rightType = bindingContext.get(TYPE, expression.getRight());
+        final KtType rightType = bindingContext.get(TYPE, expression.getRight());
         assert rightType != null;
 
         final StackValue value = genQualified(receiver, left);
@@ -3720,7 +3720,7 @@ The "returned" value of try expression with no finally is either the last expres
                     StackValue.putUnitInstance(v);
                 }
 
-                if (opToken != JetTokens.AS_SAFE) {
+                if (opToken != KtTokens.AS_SAFE) {
                     if (!TypeUtils.isNullableType(rightType)) {
                         v.dup();
                         Label nonnull = new Label();
@@ -3740,23 +3740,23 @@ The "returned" value of try expression with no finally is either the last expres
                     v.mark(ok);
                 }
 
-                generateCheckCastInstruction(rightType, opToken == JetTokens.AS_SAFE);
+                generateCheckCastInstruction(rightType, opToken == KtTokens.AS_SAFE);
                 return Unit.INSTANCE$;
             }
         });
     }
 
     @Override
-    public StackValue visitIsExpression(@NotNull JetIsExpression expression, StackValue receiver) {
+    public StackValue visitIsExpression(@NotNull KtIsExpression expression, StackValue receiver) {
         StackValue match = StackValue.expression(OBJECT_TYPE, expression.getLeftHandSide(), this);
         return generateIsCheck(match, expression.getTypeReference(), expression.isNegated());
     }
 
-    private StackValue generateExpressionMatch(StackValue expressionToMatch, JetExpression patternExpression) {
+    private StackValue generateExpressionMatch(StackValue expressionToMatch, KtExpression patternExpression) {
         if (expressionToMatch != null) {
             Type subjectType = expressionToMatch.type;
             markStartLineNumber(patternExpression);
-            JetType condJetType = bindingContext.getType(patternExpression);
+            KtType condJetType = bindingContext.getType(patternExpression);
             Type condType;
             if (isNumberPrimitive(subjectType) || subjectType.getSort() == Type.BOOLEAN) {
                 assert condJetType != null;
@@ -3769,21 +3769,21 @@ The "returned" value of try expression with no finally is either the last expres
                 condType = OBJECT_TYPE;
             }
             StackValue condition = genLazy(patternExpression, condType);
-            return genEqualsForExpressionsOnStack(JetTokens.EQEQ, StackValue.coercion(expressionToMatch, subjectType), condition);
+            return genEqualsForExpressionsOnStack(KtTokens.EQEQ, StackValue.coercion(expressionToMatch, subjectType), condition);
         }
         else {
             return gen(patternExpression);
         }
     }
 
-    private StackValue generateIsCheck(StackValue expressionToMatch, JetTypeReference typeReference, boolean negated) {
-        JetType jetType = bindingContext.get(TYPE, typeReference);
+    private StackValue generateIsCheck(StackValue expressionToMatch, KtTypeReference typeReference, boolean negated) {
+        KtType jetType = bindingContext.get(TYPE, typeReference);
         markStartLineNumber(typeReference);
         StackValue value = generateInstanceOf(expressionToMatch, jetType, false);
         return negated ? StackValue.not(value) : value;
     }
 
-    private StackValue generateInstanceOf(final StackValue expressionToGen, final JetType jetType, final boolean leaveExpressionOnStack) {
+    private StackValue generateInstanceOf(final StackValue expressionToGen, final KtType jetType, final boolean leaveExpressionOnStack) {
         return StackValue.operation(Type.BOOLEAN_TYPE, new Function1<InstructionAdapter, Unit>() {
             @Override
             public Unit invoke(InstructionAdapter v) {
@@ -3812,14 +3812,14 @@ The "returned" value of try expression with no finally is either the last expres
         });
     }
 
-    private void generateInstanceOfInstruction(@NotNull JetType jetType) {
+    private void generateInstanceOfInstruction(@NotNull KtType jetType) {
         Type type = boxType(asmType(jetType));
         putReifierMarkerIfTypeIsReifiedParameter(jetType, ReifiedTypeInliner.INSTANCEOF_MARKER_METHOD_NAME);
         TypeIntrinsics.instanceOf(v, jetType, type);
     }
 
     @NotNull
-    private StackValue generateCheckCastInstruction(@NotNull JetType jetType, boolean safeAs) {
+    private StackValue generateCheckCastInstruction(@NotNull KtType jetType, boolean safeAs) {
         Type type = boxType(asmType(jetType));
         putReifierMarkerIfTypeIsReifiedParameter(jetType,
                                                  safeAs ? ReifiedTypeInliner.SAFE_CHECKCAST_MARKER_METHOD_NAME
@@ -3828,7 +3828,7 @@ The "returned" value of try expression with no finally is either the last expres
         return StackValue.onStack(type);
     }
 
-    public void putReifierMarkerIfTypeIsReifiedParameter(@NotNull JetType type, @NotNull String markerMethodName) {
+    public void putReifierMarkerIfTypeIsReifiedParameter(@NotNull KtType type, @NotNull String markerMethodName) {
         TypeParameterDescriptor typeParameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(type);
         if (typeParameterDescriptor != null && typeParameterDescriptor.isReified()) {
             if (typeParameterDescriptor.getContainingDeclaration() != context.getContextDescriptor()) {
@@ -3849,12 +3849,12 @@ The "returned" value of try expression with no finally is either the last expres
     }
 
     @Override
-    public StackValue visitWhenExpression(@NotNull JetWhenExpression expression, StackValue receiver) {
+    public StackValue visitWhenExpression(@NotNull KtWhenExpression expression, StackValue receiver) {
         return generateWhenExpression(expression, false);
     }
 
-    public StackValue generateWhenExpression(final JetWhenExpression expression, final boolean isStatement) {
-        final JetExpression expr = expression.getSubjectExpression();
+    public StackValue generateWhenExpression(final KtWhenExpression expression, final boolean isStatement) {
+        final KtExpression expr = expression.getSubjectExpression();
         final Type subjectType = expressionType(expr);
 
         final Type resultType = isStatement ? Type.VOID_TYPE : expressionType(expression);
@@ -3877,10 +3877,10 @@ The "returned" value of try expression with no finally is either the last expres
                 }
 
                 Label end = new Label();
-                boolean hasElse = JetPsiUtil.checkWhenExpressionHasSingleElse(expression);
+                boolean hasElse = KtPsiUtil.checkWhenExpressionHasSingleElse(expression);
 
                 Label nextCondition = null;
-                for (JetWhenEntry whenEntry : expression.getEntries()) {
+                for (KtWhenEntry whenEntry : expression.getEntries()) {
                     if (nextCondition != null) {
                         v.mark(nextCondition);
                     }
@@ -3888,7 +3888,7 @@ The "returned" value of try expression with no finally is either the last expres
                     FrameMap.Mark mark = myFrameMap.mark();
                     Label thisEntry = new Label();
                     if (!whenEntry.isElse()) {
-                        JetWhenCondition[] conditions = whenEntry.getConditions();
+                        KtWhenCondition[] conditions = whenEntry.getConditions();
                         for (int i = 0; i < conditions.length; i++) {
                             StackValue conditionValue = generateWhenCondition(subjectType, subjectLocal, conditions[i]);
                             BranchedValue.Companion.condJump(conditionValue, nextCondition, true, v);
@@ -3925,7 +3925,7 @@ The "returned" value of try expression with no finally is either the last expres
     }
 
     public void putUnitInstanceOntoStackForNonExhaustiveWhen(
-            @NotNull JetWhenExpression expression
+            @NotNull KtWhenExpression expression
     ) {
         if (Boolean.TRUE.equals(bindingContext.get(BindingContext.EXHAUSTIVE_WHEN, expression))) {
             // when() is supposed to be exhaustive
@@ -3937,20 +3937,20 @@ The "returned" value of try expression with no finally is either the last expres
         }
     }
 
-    private StackValue generateWhenCondition(Type subjectType, int subjectLocal, JetWhenCondition condition) {
-        if (condition instanceof JetWhenConditionInRange) {
-            JetWhenConditionInRange conditionInRange = (JetWhenConditionInRange) condition;
+    private StackValue generateWhenCondition(Type subjectType, int subjectLocal, KtWhenCondition condition) {
+        if (condition instanceof KtWhenConditionInRange) {
+            KtWhenConditionInRange conditionInRange = (KtWhenConditionInRange) condition;
             return generateIn(StackValue.local(subjectLocal, subjectType),
                               conditionInRange.getRangeExpression(),
                               conditionInRange.getOperationReference());
         }
         StackValue.Local match = subjectLocal == -1 ? null : StackValue.local(subjectLocal, subjectType);
-        if (condition instanceof JetWhenConditionIsPattern) {
-            JetWhenConditionIsPattern patternCondition = (JetWhenConditionIsPattern) condition;
+        if (condition instanceof KtWhenConditionIsPattern) {
+            KtWhenConditionIsPattern patternCondition = (KtWhenConditionIsPattern) condition;
             return generateIsCheck(match, patternCondition.getTypeReference(), patternCondition.isNegated());
         }
-        else if (condition instanceof JetWhenConditionWithExpression) {
-            JetExpression patternExpression = ((JetWhenConditionWithExpression) condition).getExpression();
+        else if (condition instanceof KtWhenConditionWithExpression) {
+            KtExpression patternExpression = ((KtWhenConditionWithExpression) condition).getExpression();
             return generateExpressionMatch(match, patternExpression);
         }
         else {
@@ -3958,11 +3958,11 @@ The "returned" value of try expression with no finally is either the last expres
         }
     }
 
-    private boolean isIntRangeExpr(JetExpression rangeExpression) {
-        if (rangeExpression instanceof JetBinaryExpression) {
-            JetBinaryExpression binaryExpression = (JetBinaryExpression) rangeExpression;
-            if (binaryExpression.getOperationReference().getReferencedNameElementType() == JetTokens.RANGE) {
-                JetType jetType = bindingContext.getType(rangeExpression);
+    private boolean isIntRangeExpr(KtExpression rangeExpression) {
+        if (rangeExpression instanceof KtBinaryExpression) {
+            KtBinaryExpression binaryExpression = (KtBinaryExpression) rangeExpression;
+            if (binaryExpression.getOperationReference().getReferencedNameElementType() == KtTokens.RANGE) {
+                KtType jetType = bindingContext.getType(rangeExpression);
                 assert jetType != null;
                 DeclarationDescriptor descriptor = jetType.getConstructor().getDeclarationDescriptor();
                 return DescriptorUtilsKt.getBuiltIns(descriptor).getIntegralRanges().contains(descriptor);
@@ -3972,7 +3972,7 @@ The "returned" value of try expression with no finally is either the last expres
     }
 
     private Call makeFakeCall(ReceiverValue initializerAsReceiver) {
-        JetSimpleNameExpression fake = JetPsiFactoryKt.JetPsiFactory(state.getProject()).createSimpleName("fake");
+        KtSimpleNameExpression fake = KtPsiFactoryKt.KtPsiFactory(state.getProject()).createSimpleName("fake");
         return CallMaker.makeCall(fake, initializerAsReceiver);
     }
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java
index 9527dd80023..6f3448f3fd2 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
 import org.jetbrains.kotlin.load.java.SpecialBuiltinMembers;
 import org.jetbrains.kotlin.load.kotlin.nativeDeclarations.NativeKt;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
@@ -57,7 +57,7 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.org.objectweb.asm.*;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 import org.jetbrains.org.objectweb.asm.commons.Method;
@@ -102,7 +102,7 @@ public class FunctionCodegen {
         this.memberCodegen = memberCodegen;
     }
 
-    public void gen(@NotNull JetNamedFunction function) {
+    public void gen(@NotNull KtNamedFunction function) {
         SimpleFunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, function);
         assert functionDescriptor != null : "No descriptor for function " + function.getText() + "\n" +
                                             "in " + function.getContainingFile().getVirtualFile();
@@ -119,7 +119,7 @@ public class FunctionCodegen {
     }
 
     public void generateOverloadsWithDefaultValues(
-            @Nullable JetNamedFunction function,
+            @Nullable KtNamedFunction function,
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull FunctionDescriptor delegateFunctionDescriptor
     ) {
@@ -650,7 +650,7 @@ public class FunctionCodegen {
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull OwnerKind kind,
             @NotNull DefaultParameterValueLoader loadStrategy,
-            @Nullable JetNamedFunction function
+            @Nullable KtNamedFunction function
     ) {
         DeclarationDescriptor contextClass = owner.getContextDescriptor().getContainingDeclaration();
 
@@ -704,7 +704,7 @@ public class FunctionCodegen {
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull MethodVisitor mv,
             @NotNull DefaultParameterValueLoader loadStrategy,
-            @Nullable JetNamedFunction function,
+            @Nullable KtNamedFunction function,
             @NotNull MemberCodegen<?> parentCodegen
     ) {
         GenerationState state = parentCodegen.state;
@@ -887,7 +887,7 @@ public class FunctionCodegen {
 
         iv.load(1, OBJECT_TYPE);
 
-        JetType jetType = descriptor.getValueParameters().get(0).getType();
+        KtType jetType = descriptor.getValueParameters().get(0).getType();
 
         // TODO: reuse logic from ExpressionCodegen
         if (jetType.isMarkedNullable()) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionGenerationStrategy.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionGenerationStrategy.java
index 2e668bd4a16..13f5551cb77 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionGenerationStrategy.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionGenerationStrategy.java
@@ -20,7 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.context.MethodContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
-import org.jetbrains.kotlin.psi.JetDeclarationWithBody;
+import org.jetbrains.kotlin.psi.KtDeclarationWithBody;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
 
@@ -34,12 +34,12 @@ public abstract class FunctionGenerationStrategy {
     );
 
     public static class FunctionDefault extends CodegenBased<CallableDescriptor> {
-        private final JetDeclarationWithBody declaration;
+        private final KtDeclarationWithBody declaration;
 
         public FunctionDefault(
                 @NotNull GenerationState state,
                 @NotNull CallableDescriptor descriptor,
-                @NotNull JetDeclarationWithBody declaration
+                @NotNull KtDeclarationWithBody declaration
         ) {
             super(state, descriptor);
             this.declaration = declaration;
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java
index 47e1a370f42..b89d4845125 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java
@@ -61,7 +61,7 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat
          every argument boils down to calling LOAD with the corresponding index
          */
 
-        JetCallExpression fakeExpression = constructFakeFunctionCall();
+        KtCallExpression fakeExpression = constructFakeFunctionCall();
         final List<? extends ValueArgument> fakeArguments = fakeExpression.getValueArguments();
 
         final ReceiverValue dispatchReceiver = computeAndSaveReceiver(signature, codegen, referencedFunction.getDispatchReceiverParameter());
@@ -128,7 +128,7 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat
     }
 
     @NotNull
-    private JetCallExpression constructFakeFunctionCall() {
+    private KtCallExpression constructFakeFunctionCall() {
         StringBuilder fakeFunctionCall = new StringBuilder("callableReferenceFakeCall(");
         for (Iterator<ValueParameterDescriptor> iterator = referencedFunction.getValueParameters().iterator(); iterator.hasNext(); ) {
             ValueParameterDescriptor descriptor = iterator.next();
@@ -138,7 +138,7 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat
             }
         }
         fakeFunctionCall.append(")");
-        return (JetCallExpression) JetPsiFactoryKt.JetPsiFactory(state.getProject()).createExpression(fakeFunctionCall.toString());
+        return (KtCallExpression) KtPsiFactoryKt.KtPsiFactory(state.getProject()).createExpression(fakeFunctionCall.toString());
     }
 
     private void computeAndSaveArguments(@NotNull List<? extends ValueArgument> fakeArguments, @NotNull ExpressionCodegen codegen) {
@@ -164,8 +164,8 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat
     ) {
         if (receiver == null) return NO_RECEIVER;
 
-        JetExpression receiverExpression = JetPsiFactoryKt
-                .JetPsiFactory(state.getProject()).createExpression("callableReferenceFakeReceiver");
+        KtExpression receiverExpression = KtPsiFactoryKt
+                .KtPsiFactory(state.getProject()).createExpression("callableReferenceFakeReceiver");
         codegen.tempVariables.put(receiverExpression, receiverParameterStackValue(signature));
         return new ExpressionReceiver(receiverExpression, receiver.getType());
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java
index 9b6041483be..e8ca703bfbd 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java
@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor;
@@ -66,8 +66,8 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver;
 import org.jetbrains.kotlin.serialization.DescriptorSerializer;
 import org.jetbrains.kotlin.serialization.ProtoBuf;
-import org.jetbrains.kotlin.types.JetType;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.KtType;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.org.objectweb.asm.*;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 import org.jetbrains.org.objectweb.asm.commons.Method;
@@ -91,7 +91,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     private static final String ENUM_VALUES_FIELD_NAME = "$VALUES";
     private Type superClassAsmType;
     @Nullable // null means java/lang/Object
-    private JetType superClassType;
+    private KtType superClassType;
     private final Type classAsmType;
     private final boolean isLocal;
 
@@ -101,7 +101,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             new ArrayList<Function2<ImplementationBodyCodegen, ClassBuilder, Unit>>();
 
     public ImplementationBodyCodegen(
-            @NotNull JetClassOrObject aClass,
+            @NotNull KtClassOrObject aClass,
             @NotNull ClassContext context,
             @NotNull ClassBuilder v,
             @NotNull GenerationState state,
@@ -126,12 +126,12 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         boolean isAnnotation = false;
         boolean isEnum = false;
 
-        if (myClass instanceof JetClass) {
-            JetClass jetClass = (JetClass) myClass;
-            if (jetClass.hasModifier(JetTokens.ABSTRACT_KEYWORD) || jetClass.isSealed()) {
+        if (myClass instanceof KtClass) {
+            KtClass ktClass = (KtClass) myClass;
+            if (ktClass.hasModifier(KtTokens.ABSTRACT_KEYWORD) || ktClass.isSealed()) {
                 isAbstract = true;
             }
-            if (jetClass.isInterface()) {
+            if (ktClass.isInterface()) {
                 isAbstract = true;
                 isInterface = true;
             }
@@ -140,7 +140,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                 isInterface = true;
                 isAnnotation = true;
             }
-            else if (jetClass.isEnum()) {
+            else if (ktClass.isEnum()) {
                 isAbstract = hasAbstractMembers(descriptor);
                 isEnum = true;
             }
@@ -149,11 +149,11 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                 isFinal = true;
             }
 
-            if (!jetClass.hasModifier(JetTokens.OPEN_KEYWORD) && !isAbstract) {
+            if (!ktClass.hasModifier(KtTokens.OPEN_KEYWORD) && !isAbstract) {
                 // Light-class mode: Do not make enum classes final since PsiClass corresponding to enum is expected to be inheritable from
-                isFinal = !(jetClass.isEnum() && state.getClassBuilderMode() == ClassBuilderMode.LIGHT_CLASSES);
+                isFinal = !(ktClass.isEnum() && state.getClassBuilderMode() == ClassBuilderMode.LIGHT_CLASSES);
             }
-            isStatic = !jetClass.isInner();
+            isStatic = !ktClass.isInner();
         }
         else {
             isStatic = isCompanionObject(descriptor);
@@ -195,9 +195,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             access |= ACC_DEPRECATED;
         }
         if (isEnum) {
-            for (JetDeclaration declaration : myClass.getDeclarations()) {
-                if (declaration instanceof JetEnumEntry) {
-                    if (enumEntryNeedSubclass(bindingContext, (JetEnumEntry) declaration)) {
+            for (KtDeclaration declaration : myClass.getDeclarations()) {
+                if (declaration instanceof KtEnumEntry) {
+                    if (enumEntryNeedSubclass(bindingContext, (KtEnumEntry) declaration)) {
                         access &= ~ACC_FINAL;
                     }
                 }
@@ -316,7 +316,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         LinkedHashSet<String> superInterfaces = new LinkedHashSet<String>();
         Set<String> kotlinMarkerInterfaces = new LinkedHashSet<String>();
 
-        for (JetType supertype : descriptor.getTypeConstructor().getSupertypes()) {
+        for (KtType supertype : descriptor.getTypeConstructor().getSupertypes()) {
             if (isJvmInterface(supertype.getConstructor().getDeclarationDescriptor())) {
                 sw.writeInterface();
                 Type jvmInterfaceType = typeMapper.mapSupertype(supertype, sw);
@@ -352,7 +352,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             return;
         }
 
-        for (JetType supertype : descriptor.getTypeConstructor().getSupertypes()) {
+        for (KtType supertype : descriptor.getTypeConstructor().getSupertypes()) {
             ClassifierDescriptor superClass = supertype.getConstructor().getDeclarationDescriptor();
             if (superClass != null && !isJvmInterface(superClass)) {
                 superClassAsmType = typeMapper.mapClass(superClass);
@@ -421,13 +421,13 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                 continue;
             }
 
-            JetType returnType = function.getReturnType();
+            KtType returnType = function.getReturnType();
             assert returnType != null : function.toString();
-            JetType paramType = function.getValueParameters().get(0).getType();
+            KtType paramType = function.getValueParameters().get(0).getType();
             if (KotlinBuiltIns.isArray(returnType) && KotlinBuiltIns.isArray(paramType)) {
-                JetType elementType = function.getTypeParameters().get(0).getDefaultType();
-                if (JetTypeChecker.DEFAULT.equalTypes(elementType, DescriptorUtilsKt.getBuiltIns(descriptor).getArrayElementType(returnType))
-                        && JetTypeChecker.DEFAULT.equalTypes(elementType, DescriptorUtilsKt
+                KtType elementType = function.getTypeParameters().get(0).getDefaultType();
+                if (KotlinTypeChecker.DEFAULT.equalTypes(elementType, DescriptorUtilsKt.getBuiltIns(descriptor).getArrayElementType(returnType))
+                    && KotlinTypeChecker.DEFAULT.equalTypes(elementType, DescriptorUtilsKt
                         .getBuiltIns(descriptor).getArrayElementType(paramType))) {
                     return true;
                 }
@@ -486,7 +486,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
     private class DataClassMethodGeneratorImpl extends DataClassMethodGenerator {
         DataClassMethodGeneratorImpl(
-                JetClassOrObject klass,
+                KtClassOrObject klass,
                 BindingContext bindingContext
         ) {
             super(klass, bindingContext);
@@ -532,7 +532,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                     iv.ifne(ne);
                 }
                 else {
-                    StackValue value = genEqualsForExpressionsOnStack(JetTokens.EQEQ, StackValue.onStack(asmType), StackValue.onStack(asmType));
+                    StackValue value = genEqualsForExpressionsOnStack(KtTokens.EQEQ, StackValue.onStack(asmType), StackValue.onStack(asmType));
                     value.put(Type.BOOLEAN_TYPE, iv);
                     iv.ifeq(ne);
                 }
@@ -689,7 +689,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         }
 
         @Override
-        public void generateCopyFunction(@NotNull final FunctionDescriptor function, @NotNull List<JetParameter> constructorParameters) {
+        public void generateCopyFunction(@NotNull final FunctionDescriptor function, @NotNull List<KtParameter> constructorParameters) {
             final Type thisDescriptorType = typeMapper.mapType(descriptor);
 
             functionCodegen.generateMethod(JvmDeclarationOriginKt.OtherOrigin(myClass, function), function, new FunctionGenerationStrategy() {
@@ -738,7 +738,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                         iv.getfield(classAsmType.getInternalName(), CAPTURED_THIS_FIELD, type.getDescriptor());
                     }
 
-                    JetType captureReceiver = closure.getCaptureReceiverType();
+                    KtType captureReceiver = closure.getCaptureReceiverType();
                     if (captureReceiver != null) {
                         iv.load(0, classAsmType);
                         Type type = typeMapper.mapType(captureReceiver);
@@ -865,7 +865,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             return;
         }
 
-        JetObjectDeclaration companionObject = CollectionsKt.firstOrNull(((JetClass) myClass).getCompanionObjects());
+        KtObjectDeclaration companionObject = CollectionsKt.firstOrNull(((KtClass) myClass).getCompanionObjects());
         assert companionObject != null : "Companion object not found: " + myClass.getText();
 
         StackValue.Field field = StackValue.singletonForCompanion(companionObjectDescriptor, typeMapper);
@@ -939,7 +939,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         ConstructorContext constructorContext = context.intoConstructor(constructorDescriptor);
 
-        JetPrimaryConstructor primaryConstructor = myClass.getPrimaryConstructor();
+        KtPrimaryConstructor primaryConstructor = myClass.getPrimaryConstructor();
         JvmDeclarationOrigin origin = JvmDeclarationOriginKt
                 .OtherOrigin(primaryConstructor != null ? primaryConstructor : myClass, constructorDescriptor);
         functionCodegen.generateMethod(origin, constructorDescriptor, constructorContext,
@@ -1004,15 +1004,15 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             }
         }
 
-        for (JetDelegationSpecifier specifier : myClass.getDelegationSpecifiers()) {
-            if (specifier instanceof JetDelegatorByExpressionSpecifier) {
-                genCallToDelegatorByExpressionSpecifier(iv, codegen, (JetDelegatorByExpressionSpecifier) specifier, fieldsInfo);
+        for (KtDelegationSpecifier specifier : myClass.getDelegationSpecifiers()) {
+            if (specifier instanceof KtDelegatorByExpressionSpecifier) {
+                genCallToDelegatorByExpressionSpecifier(iv, codegen, (KtDelegatorByExpressionSpecifier) specifier, fieldsInfo);
             }
         }
 
         int curParam = 0;
         List<ValueParameterDescriptor> parameters = constructorDescriptor.getValueParameters();
-        for (JetParameter parameter : getPrimaryConstructorParameters()) {
+        for (KtParameter parameter : getPrimaryConstructorParameters()) {
             if (parameter.hasValOrVar()) {
                 VariableDescriptor descriptor = parameters.get(curParam);
                 Type type = typeMapper.mapType(descriptor);
@@ -1060,8 +1060,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             generateInitializers(codegen);
         }
 
-        JetSecondaryConstructor constructor =
-                (JetSecondaryConstructor) DescriptorToSourceUtils.descriptorToDeclaration(constructorDescriptor);
+        KtSecondaryConstructor constructor =
+                (KtSecondaryConstructor) DescriptorToSourceUtils.descriptorToDeclaration(constructorDescriptor);
         assert constructor != null;
         if (constructor.hasBody()) {
             codegen.gen(constructor.getBodyExpression(), Type.VOID_TYPE);
@@ -1119,41 +1119,41 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                 return StackValue.field(type, classAsmType, name, false, StackValue.none());
             }
         }
-        private final Map<JetDelegatorByExpressionSpecifier, Field> fields = new HashMap<JetDelegatorByExpressionSpecifier, Field>();
+        private final Map<KtDelegatorByExpressionSpecifier, Field> fields = new HashMap<KtDelegatorByExpressionSpecifier, Field>();
 
         @NotNull
-        public Field getInfo(JetDelegatorByExpressionSpecifier specifier) {
+        public Field getInfo(KtDelegatorByExpressionSpecifier specifier) {
             return fields.get(specifier);
         }
 
-        private void addField(JetDelegatorByExpressionSpecifier specifier, PropertyDescriptor propertyDescriptor) {
+        private void addField(KtDelegatorByExpressionSpecifier specifier, PropertyDescriptor propertyDescriptor) {
             fields.put(specifier,
                        new Field(typeMapper.mapType(propertyDescriptor), propertyDescriptor.getName().asString(), false));
         }
 
-        private void addField(JetDelegatorByExpressionSpecifier specifier, Type type, String name) {
+        private void addField(KtDelegatorByExpressionSpecifier specifier, Type type, String name) {
             fields.put(specifier, new Field(type, name, true));
         }
     }
 
     @NotNull
-    private DelegationFieldsInfo getDelegationFieldsInfo(@NotNull List<JetDelegationSpecifier> delegationSpecifiers) {
+    private DelegationFieldsInfo getDelegationFieldsInfo(@NotNull List<KtDelegationSpecifier> delegationSpecifiers) {
         DelegationFieldsInfo result = new DelegationFieldsInfo();
         int n = 0;
-        for (JetDelegationSpecifier specifier : delegationSpecifiers) {
-            if (specifier instanceof JetDelegatorByExpressionSpecifier) {
-                JetExpression expression = ((JetDelegatorByExpressionSpecifier) specifier).getDelegateExpression();
+        for (KtDelegationSpecifier specifier : delegationSpecifiers) {
+            if (specifier instanceof KtDelegatorByExpressionSpecifier) {
+                KtExpression expression = ((KtDelegatorByExpressionSpecifier) specifier).getDelegateExpression();
                 PropertyDescriptor propertyDescriptor = CodegenUtil.getDelegatePropertyIfAny(expression, descriptor, bindingContext);
 
 
                 if (CodegenUtil.isFinalPropertyWithBackingField(propertyDescriptor, bindingContext)) {
-                    result.addField((JetDelegatorByExpressionSpecifier) specifier, propertyDescriptor);
+                    result.addField((KtDelegatorByExpressionSpecifier) specifier, propertyDescriptor);
                 }
                 else {
-                    JetType expressionType = expression != null ? bindingContext.getType(expression) : null;
+                    KtType expressionType = expression != null ? bindingContext.getType(expression) : null;
                     Type asmType =
                             expressionType != null ? typeMapper.mapType(expressionType) : typeMapper.mapType(getSuperClass(specifier));
-                    result.addField((JetDelegatorByExpressionSpecifier) specifier, asmType, "$delegate_" + n);
+                    result.addField((KtDelegatorByExpressionSpecifier) specifier, asmType, "$delegate_" + n);
                 }
                 n++;
             }
@@ -1162,17 +1162,17 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     }
 
     @NotNull
-    private ClassDescriptor getSuperClass(@NotNull JetDelegationSpecifier specifier) {
+    private ClassDescriptor getSuperClass(@NotNull KtDelegationSpecifier specifier) {
         return CodegenUtil.getSuperClassByDelegationSpecifier(specifier, bindingContext);
     }
 
     private void genCallToDelegatorByExpressionSpecifier(
             InstructionAdapter iv,
             ExpressionCodegen codegen,
-            JetDelegatorByExpressionSpecifier specifier,
+            KtDelegatorByExpressionSpecifier specifier,
             DelegationFieldsInfo fieldsInfo
     ) {
-        JetExpression expression = specifier.getDelegateExpression();
+        KtExpression expression = specifier.getDelegateExpression();
 
         DelegationFieldsInfo.Field fieldInfo = fieldsInfo.getInfo(specifier);
         if (fieldInfo.generateField) {
@@ -1184,14 +1184,14 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     private void lookupConstructorExpressionsInClosureIfPresent() {
         if (state.getClassBuilderMode() != ClassBuilderMode.FULL || descriptor.getConstructors().isEmpty()) return;
 
-        JetVisitorVoid visitor = new JetVisitorVoid() {
+        KtVisitorVoid visitor = new KtVisitorVoid() {
             @Override
-            public void visitJetElement(@NotNull JetElement e) {
+            public void visitJetElement(@NotNull KtElement e) {
                 e.acceptChildren(this);
             }
 
             @Override
-            public void visitSimpleNameExpression(@NotNull JetSimpleNameExpression expr) {
+            public void visitSimpleNameExpression(@NotNull KtSimpleNameExpression expr) {
                 DeclarationDescriptor descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, expr);
 
                 if (isLocalFunction(descriptor)) {
@@ -1234,7 +1234,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             }
 
             @Override
-            public void visitThisExpression(@NotNull JetThisExpression expression) {
+            public void visitThisExpression(@NotNull KtThisExpression expression) {
                 DeclarationDescriptor descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, expression.getInstanceReference());
                 assert descriptor instanceof CallableDescriptor ||
                        descriptor instanceof ClassDescriptor : "'This' reference target should be class or callable descriptor but was " + descriptor;
@@ -1251,27 +1251,27 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             }
         };
 
-        for (JetDeclaration declaration : myClass.getDeclarations()) {
-            if (declaration instanceof JetProperty) {
-                JetProperty property = (JetProperty) declaration;
-                JetExpression initializer = property.getInitializer();
+        for (KtDeclaration declaration : myClass.getDeclarations()) {
+            if (declaration instanceof KtProperty) {
+                KtProperty property = (KtProperty) declaration;
+                KtExpression initializer = property.getInitializer();
                 if (initializer != null) {
                     initializer.accept(visitor);
                 }
             }
-            else if (declaration instanceof JetClassInitializer) {
-                JetClassInitializer initializer = (JetClassInitializer) declaration;
+            else if (declaration instanceof KtClassInitializer) {
+                KtClassInitializer initializer = (KtClassInitializer) declaration;
                 initializer.accept(visitor);
             }
-            else if (declaration instanceof JetSecondaryConstructor) {
-                JetSecondaryConstructor constructor = (JetSecondaryConstructor) declaration;
+            else if (declaration instanceof KtSecondaryConstructor) {
+                KtSecondaryConstructor constructor = (KtSecondaryConstructor) declaration;
                 constructor.accept(visitor);
             }
         }
 
-        for (JetDelegationSpecifier specifier : myClass.getDelegationSpecifiers()) {
-            if (specifier instanceof JetDelegatorByExpressionSpecifier) {
-                JetExpression delegateExpression = ((JetDelegatorByExpressionSpecifier) specifier).getDelegateExpression();
+        for (KtDelegationSpecifier specifier : myClass.getDelegationSpecifiers()) {
+            if (specifier instanceof KtDelegatorByExpressionSpecifier) {
+                KtExpression delegateExpression = ((KtDelegatorByExpressionSpecifier) specifier).getDelegateExpression();
                 assert delegateExpression != null;
                 delegateExpression.accept(visitor);
             }
@@ -1286,7 +1286,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             ConstructorDescriptor primaryConstructor = descriptor.getUnsubstitutedPrimaryConstructor();
             if (primaryConstructor != null && !isAnonymousObject(descriptor)) {
                 ResolvedCall<ConstructorDescriptor> delegationCall = getDelegationConstructorCall(bindingContext, primaryConstructor);
-                JetValueArgumentList argumentList = delegationCall != null ? delegationCall.getCall().getValueArgumentList() : null;
+                KtValueArgumentList argumentList = delegationCall != null ? delegationCall.getCall().getValueArgumentList() : null;
                 if (argumentList != null) {
                     argumentList.accept(visitor);
                 }
@@ -1318,8 +1318,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
                         DeclarationDescriptor declarationInheritedFun = inheritedFun.getContainingDeclaration();
                         PsiElement classForInheritedFun = descriptorToDeclaration(declarationInheritedFun);
-                        if (classForInheritedFun instanceof JetDeclaration) {
-                            codegen.markLineNumber((JetElement) classForInheritedFun, false);
+                        if (classForInheritedFun instanceof KtDeclaration) {
+                            codegen.markLineNumber((KtElement) classForInheritedFun, false);
                         }
 
                         ClassDescriptor containingTrait = (ClassDescriptor) containingDeclaration;
@@ -1535,9 +1535,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     private void generateEnumEntries() {
         if (descriptor.getKind() != ClassKind.ENUM_CLASS) return;
 
-        List<JetEnumEntry> enumEntries = CollectionsKt.filterIsInstance(element.getDeclarations(), JetEnumEntry.class);
+        List<KtEnumEntry> enumEntries = CollectionsKt.filterIsInstance(element.getDeclarations(), KtEnumEntry.class);
 
-        for (JetEnumEntry enumEntry : enumEntries) {
+        for (KtEnumEntry enumEntry : enumEntries) {
             ClassDescriptor descriptor = getNotNull(bindingContext, BindingContext.CLASS, enumEntry);
             FieldVisitor fv = v.newField(JvmDeclarationOriginKt.OtherOrigin(enumEntry, descriptor), ACC_PUBLIC | ACC_ENUM | ACC_STATIC | ACC_FINAL,
                                          descriptor.getName().asString(), classAsmType.getDescriptor(), null, null);
@@ -1547,7 +1547,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         initializeEnumConstants(enumEntries);
     }
 
-    private void initializeEnumConstants(@NotNull List<JetEnumEntry> enumEntries) {
+    private void initializeEnumConstants(@NotNull List<KtEnumEntry> enumEntries) {
         if (state.getClassBuilderMode() != ClassBuilderMode.FULL) return;
 
         ExpressionCodegen codegen = createOrGetClInitCodegen();
@@ -1570,10 +1570,10 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         iv.putstatic(classAsmType.getInternalName(), ENUM_VALUES_FIELD_NAME, arrayAsmType.getDescriptor());
     }
 
-    private void initializeEnumConstant(@NotNull List<JetEnumEntry> enumEntries, int ordinal) {
+    private void initializeEnumConstant(@NotNull List<KtEnumEntry> enumEntries, int ordinal) {
         ExpressionCodegen codegen = createOrGetClInitCodegen();
         InstructionAdapter iv = codegen.v;
-        JetEnumEntry enumEntry = enumEntries.get(ordinal);
+        KtEnumEntry enumEntry = enumEntries.get(ordinal);
 
         iv.dup();
         iv.iconst(ordinal);
@@ -1587,7 +1587,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         iv.aconst(enumEntry.getName());
         iv.iconst(ordinal);
 
-        List<JetDelegationSpecifier> delegationSpecifiers = enumEntry.getDelegationSpecifiers();
+        List<KtDelegationSpecifier> delegationSpecifiers = enumEntry.getDelegationSpecifiers();
         if (delegationSpecifiers.size() == 1 && !enumEntryNeedSubclass(bindingContext, enumEntry)) {
             ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCallWithAssert(delegationSpecifiers.get(0), bindingContext);
 
@@ -1605,12 +1605,12 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     }
 
     private void generateDelegates(DelegationFieldsInfo delegationFieldsInfo) {
-        for (JetDelegationSpecifier specifier : myClass.getDelegationSpecifiers()) {
-            if (specifier instanceof JetDelegatorByExpressionSpecifier) {
-                DelegationFieldsInfo.Field field = delegationFieldsInfo.getInfo((JetDelegatorByExpressionSpecifier) specifier);
+        for (KtDelegationSpecifier specifier : myClass.getDelegationSpecifiers()) {
+            if (specifier instanceof KtDelegatorByExpressionSpecifier) {
+                DelegationFieldsInfo.Field field = delegationFieldsInfo.getInfo((KtDelegatorByExpressionSpecifier) specifier);
                 generateDelegateField(field);
-                JetExpression delegateExpression = ((JetDelegatorByExpressionSpecifier) specifier).getDelegateExpression();
-                JetType delegateExpressionType = delegateExpression != null ? bindingContext.getType(delegateExpression) : null;
+                KtExpression delegateExpression = ((KtDelegatorByExpressionSpecifier) specifier).getDelegateExpression();
+                KtType delegateExpressionType = delegateExpression != null ? bindingContext.getType(delegateExpression) : null;
                 generateDelegates(getSuperClass(specifier), delegateExpressionType, field);
             }
         }
@@ -1623,7 +1623,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                    fieldInfo.name, fieldInfo.type.getDescriptor(), /*TODO*/null, null);
     }
 
-    protected void generateDelegates(ClassDescriptor toTrait, JetType delegateExpressionType, DelegationFieldsInfo.Field field) {
+    protected void generateDelegates(ClassDescriptor toTrait, KtType delegateExpressionType, DelegationFieldsInfo.Field field) {
         for (Map.Entry<CallableMemberDescriptor, CallableDescriptor> entry : CodegenUtilKt.getDelegates(descriptor, toTrait, delegateExpressionType).entrySet()) {
             CallableMemberDescriptor callableMemberDescriptor = entry.getKey();
             CallableDescriptor delegateTo = entry.getValue();
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt
index 134f4696c74..bbe086b9a7f 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt
@@ -28,12 +28,12 @@ import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames.KOTLIN_INTERFACE_DEFAULT_IMPLS
 import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.DelegationToTraitImpl
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.org.objectweb.asm.Opcodes.ACC_FINAL
 import org.jetbrains.org.objectweb.asm.Opcodes.ACC_PUBLIC
 import org.jetbrains.org.objectweb.asm.Opcodes.ACC_STATIC
@@ -41,7 +41,7 @@ import org.jetbrains.org.objectweb.asm.Opcodes.V1_6
 import java.util.*
 
 public class InterfaceImplBodyCodegen(
-        aClass: JetClassOrObject,
+        aClass: KtClassOrObject,
         context: ClassContext,
         v: ClassBuilder,
         state: GenerationState,
@@ -63,7 +63,7 @@ public class InterfaceImplBodyCodegen(
                 descriptor, Name.identifier(JvmAbi.DEFAULT_IMPLS_CLASS_NAME),
                 Modality.FINAL, Collections.emptyList(), SourceElement.NO_SOURCE)
 
-        classDescriptorImpl.initialize(JetScope.Empty, emptySet(), null)
+        classDescriptorImpl.initialize(KtScope.Empty, emptySet(), null)
         return classDescriptorImpl
     }
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java
index 08badee2dbb..8ade6373421 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java
@@ -35,15 +35,15 @@ import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping;
 import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityUtilsKt;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetFunction;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtFunction;
 import org.jetbrains.kotlin.psi.codeFragmentUtil.CodeFragmentUtilKt;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.inline.InlineUtil;
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
 
 import java.io.File;
@@ -64,7 +64,7 @@ public class JvmCodegenUtil {
         return false;
     }
 
-    public static boolean isJvmInterface(JetType type) {
+    public static boolean isJvmInterface(KtType type) {
         return isJvmInterface(type.getConstructor().getDeclarationDescriptor());
     }
 
@@ -86,7 +86,7 @@ public class JvmCodegenUtil {
     }
 
     private static boolean isWithinSameFile(
-            @Nullable JetFile callerFile,
+            @Nullable KtFile callerFile,
             @NotNull CallableMemberDescriptor descriptor
     ) {
         DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration().getOriginal();
@@ -165,7 +165,7 @@ public class JvmCodegenUtil {
     }
 
     private static boolean isDebuggerContext(@NotNull MethodContext context) {
-        JetFile file = DescriptorToSourceUtils.getContainingFile(context.getContextDescriptor());
+        KtFile file = DescriptorToSourceUtils.getContainingFile(context.getContextDescriptor());
         return file != null && CodeFragmentUtilKt.getSuppressDiagnosticsInDebugMode(file);
     }
 
@@ -203,7 +203,7 @@ public class JvmCodegenUtil {
     public static boolean isArgumentWhichWillBeInlined(@NotNull BindingContext bindingContext, @NotNull DeclarationDescriptor descriptor) {
         PsiElement declaration = DescriptorToSourceUtils.descriptorToDeclaration(descriptor);
         return InlineUtil.canBeInlineArgument(declaration) &&
-               InlineUtil.isInlinedArgument((JetFunction) declaration, bindingContext, false);
+               InlineUtil.isInlinedArgument((KtFunction) declaration, bindingContext, false);
     }
 
     @NotNull
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java
index 58c8af520b3..570c398be69 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.resolve.TargetPlatformKt;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 
 import java.util.*;
@@ -72,11 +72,11 @@ public class JvmRuntimeTypes {
     }
 
     @NotNull
-    public Collection<JetType> getSupertypesForClosure(@NotNull FunctionDescriptor descriptor) {
+    public Collection<KtType> getSupertypesForClosure(@NotNull FunctionDescriptor descriptor) {
         ReceiverParameterDescriptor receiverParameter = descriptor.getExtensionReceiverParameter();
 
         //noinspection ConstantConditions
-        JetType functionType = DescriptorUtilsKt.getBuiltIns(descriptor).getFunctionType(
+        KtType functionType = DescriptorUtilsKt.getBuiltIns(descriptor).getFunctionType(
                 Annotations.Companion.getEMPTY(),
                 receiverParameter == null ? null : receiverParameter.getType(),
                 ExpressionTypingUtils.getValueParametersTypes(descriptor.getValueParameters()),
@@ -87,15 +87,15 @@ public class JvmRuntimeTypes {
     }
 
     @NotNull
-    public Collection<JetType> getSupertypesForFunctionReference(@NotNull FunctionDescriptor descriptor) {
+    public Collection<KtType> getSupertypesForFunctionReference(@NotNull FunctionDescriptor descriptor) {
         ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter();
         ReceiverParameterDescriptor dispatchReceiver = descriptor.getDispatchReceiverParameter();
 
-        JetType receiverType =
+        KtType receiverType =
                 extensionReceiver != null ? extensionReceiver.getType() : dispatchReceiver != null ? dispatchReceiver.getType() : null;
 
         //noinspection ConstantConditions
-        JetType functionType = DescriptorUtilsKt.getBuiltIns(descriptor).getFunctionType(
+        KtType functionType = DescriptorUtilsKt.getBuiltIns(descriptor).getFunctionType(
                 Annotations.Companion.getEMPTY(),
                 receiverType,
                 ExpressionTypingUtils.getValueParametersTypes(descriptor.getValueParameters()),
@@ -106,7 +106,7 @@ public class JvmRuntimeTypes {
     }
 
     @NotNull
-    public JetType getSupertypeForPropertyReference(@NotNull PropertyDescriptor descriptor) {
+    public KtType getSupertypeForPropertyReference(@NotNull PropertyDescriptor descriptor) {
         int arity = (descriptor.getExtensionReceiverParameter() != null ? 1 : 0) +
                     (descriptor.getDispatchReceiverParameter() != null ? 1 : 0);
         return (descriptor.isVar() ? mutablePropertyReferences : propertyReferences).get(arity).getDefaultType();
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/KotlinCodegenFacade.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/KotlinCodegenFacade.java
index 480f90a140b..19a45fbee0d 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/KotlinCodegenFacade.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/KotlinCodegenFacade.java
@@ -21,11 +21,10 @@ import com.intellij.util.containers.MultiMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassInfo;
-import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetScript;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtScript;
 import org.jetbrains.kotlin.resolve.ScriptNameUtil;
 import org.jetbrains.org.objectweb.asm.Type;
 
@@ -36,10 +35,10 @@ import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.registerClassN
 public class KotlinCodegenFacade {
 
     public static void prepareForCompilation(@NotNull GenerationState state) {
-        for (JetFile file : state.getFiles()) {
+        for (KtFile file : state.getFiles()) {
             if (file.isScript()) {
                 // SCRIPT: register class name for scripting from this file, move outside of this function
-                JetScript script = file.getScript();
+                KtScript script = file.getScript();
                 assert script != null;
 
                 FqName name = ScriptNameUtil.classNameForScript(script);
@@ -65,14 +64,14 @@ public class KotlinCodegenFacade {
     }
 
     public static void doGenerateFiles(
-            @NotNull Collection<JetFile> files,
+            @NotNull Collection<KtFile> files,
             @NotNull GenerationState state,
             @NotNull CompilationErrorHandler errorHandler
     ) {
-        MultiMap<FqName, JetFile> filesInPackages = new MultiMap<FqName, JetFile>();
-        MultiMap<FqName, JetFile> filesInMultifileClasses = new MultiMap<FqName, JetFile>();
+        MultiMap<FqName, KtFile> filesInPackages = new MultiMap<FqName, KtFile>();
+        MultiMap<FqName, KtFile> filesInMultifileClasses = new MultiMap<FqName, KtFile>();
 
-        for (JetFile file : files) {
+        for (KtFile file : files) {
             if (file == null) throw new IllegalArgumentException("A null file given for compilation");
 
             JvmFileClassInfo fileClassInfo = state.getFileClassesProvider().getFileClassInfo(file);
@@ -110,7 +109,7 @@ public class KotlinCodegenFacade {
     public static void generatePackage(
             @NotNull GenerationState state,
             @NotNull FqName packageFqName,
-            @NotNull Collection<JetFile> jetFiles,
+            @NotNull Collection<KtFile> jetFiles,
             @NotNull CompilationErrorHandler errorHandler
     ) {
         // We do not really generate package class, but use old package fqName to identify package in module-info.
@@ -122,7 +121,7 @@ public class KotlinCodegenFacade {
     private static void generateMultifileClass(
             @NotNull GenerationState state,
             @NotNull FqName multifileClassFqName,
-            @NotNull Collection<JetFile> files,
+            @NotNull Collection<KtFile> files,
             @NotNull CompilationErrorHandler handler
     ) {
         MultifileClassCodegen codegen = state.getFactory().forMultifileClass(multifileClassFqName, files);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java
index 05d64a03e3a..f462cc16d59 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java
@@ -51,7 +51,7 @@ import org.jetbrains.kotlin.resolve.source.KotlinSourceElementKt;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.storage.NotNullLazyValue;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.org.objectweb.asm.Label;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
 import org.jetbrains.org.objectweb.asm.Type;
@@ -72,7 +72,7 @@ import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.
 import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt.Synthetic;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
-public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclarationContainer*/> {
+public abstract class MemberCodegen<T extends KtElement/* TODO: & JetDeclarationContainer*/> {
     protected final GenerationState state;
     protected final T element;
     protected final FieldOwnerContext context;
@@ -179,10 +179,10 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
         v.done();
     }
 
-    public void genFunctionOrProperty(@NotNull JetDeclaration functionOrProperty) {
-        if (functionOrProperty instanceof JetNamedFunction) {
+    public void genFunctionOrProperty(@NotNull KtDeclaration functionOrProperty) {
+        if (functionOrProperty instanceof KtNamedFunction) {
             try {
-                functionCodegen.gen((JetNamedFunction) functionOrProperty);
+                functionCodegen.gen((KtNamedFunction) functionOrProperty);
             }
             catch (ProcessCanceledException e) {
                 throw e;
@@ -194,9 +194,9 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
                 throw new CompilationException("Failed to generate function " + functionOrProperty.getName(), e, functionOrProperty);
             }
         }
-        else if (functionOrProperty instanceof JetProperty) {
+        else if (functionOrProperty instanceof KtProperty) {
             try {
-                propertyCodegen.gen((JetProperty) functionOrProperty);
+                propertyCodegen.gen((KtProperty) functionOrProperty);
             }
             catch (ProcessCanceledException e) {
                 throw e;
@@ -215,7 +215,7 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
 
     public static void genClassOrObject(
             @NotNull CodegenContext parentContext,
-            @NotNull JetClassOrObject aClass,
+            @NotNull KtClassOrObject aClass,
             @NotNull GenerationState state,
             @Nullable MemberCodegen<?> parentCodegen
     ) {
@@ -242,7 +242,7 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
         }
     }
 
-    public void genClassOrObject(JetClassOrObject aClass) {
+    public void genClassOrObject(KtClassOrObject aClass) {
         genClassOrObject(context, aClass, state, this);
     }
 
@@ -367,14 +367,14 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
 
     protected void generateInitializers(@NotNull Function0<ExpressionCodegen> createCodegen) {
         NotNullLazyValue<ExpressionCodegen> codegen = LockBasedStorageManager.NO_LOCKS.createLazyValue(createCodegen);
-        for (JetDeclaration declaration : ((JetDeclarationContainer) element).getDeclarations()) {
-            if (declaration instanceof JetProperty) {
-                if (shouldInitializeProperty((JetProperty) declaration)) {
-                    initializeProperty(codegen.invoke(), (JetProperty) declaration);
+        for (KtDeclaration declaration : ((KtDeclarationContainer) element).getDeclarations()) {
+            if (declaration instanceof KtProperty) {
+                if (shouldInitializeProperty((KtProperty) declaration)) {
+                    initializeProperty(codegen.invoke(), (KtProperty) declaration);
                 }
             }
-            else if (declaration instanceof JetClassInitializer) {
-                JetExpression body = ((JetClassInitializer) declaration).getBody();
+            else if (declaration instanceof KtClassInitializer) {
+                KtExpression body = ((KtClassInitializer) declaration).getBody();
                 if (body != null) {
                     codegen.invoke().gen(body, Type.VOID_TYPE);
                 }
@@ -382,11 +382,11 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
         }
     }
 
-    private void initializeProperty(@NotNull ExpressionCodegen codegen, @NotNull JetProperty property) {
+    private void initializeProperty(@NotNull ExpressionCodegen codegen, @NotNull KtProperty property) {
         PropertyDescriptor propertyDescriptor = (PropertyDescriptor) bindingContext.get(VARIABLE, property);
         assert propertyDescriptor != null;
 
-        JetExpression initializer = property.getDelegateExpressionOrInitializer();
+        KtExpression initializer = property.getDelegateExpressionOrInitializer();
         assert initializer != null : "shouldInitializeProperty must return false if initializer is null";
 
         StackValue.Property propValue = codegen.intermediateValueForProperty(propertyDescriptor, true, null, true, StackValue.LOCAL_0);
@@ -394,7 +394,7 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
         propValue.store(codegen.gen(initializer), codegen.v);
     }
 
-    private boolean shouldInitializeProperty(@NotNull JetProperty property) {
+    private boolean shouldInitializeProperty(@NotNull KtProperty property) {
         if (!property.hasDelegateExpressionOrInitializer()) return false;
 
         PropertyDescriptor propertyDescriptor = (PropertyDescriptor) bindingContext.get(VARIABLE, property);
@@ -405,7 +405,7 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
             return false;
         }
 
-        JetExpression initializer = property.getInitializer();
+        KtExpression initializer = property.getInitializer();
 
         ConstantValue<?> initializerValue = computeInitializerValue(property, propertyDescriptor, initializer);
         // we must write constant values for fields in light classes,
@@ -413,16 +413,16 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
         if (initializerValue == null) return state.getClassBuilderMode() != ClassBuilderMode.LIGHT_CLASSES;
 
         //TODO: OPTIMIZATION: don't initialize static final fields
-        JetType jetType = getPropertyOrDelegateType(property, propertyDescriptor);
+        KtType jetType = getPropertyOrDelegateType(property, propertyDescriptor);
         Type type = typeMapper.mapType(jetType);
         return !skipDefaultValue(propertyDescriptor, initializerValue.getValue(), type);
     }
 
     @Nullable
     private ConstantValue<?> computeInitializerValue(
-            @NotNull JetProperty property,
+            @NotNull KtProperty property,
             @NotNull PropertyDescriptor propertyDescriptor,
-            @Nullable JetExpression initializer
+            @Nullable KtExpression initializer
     ) {
         if (property.isVar() && initializer != null) {
             BindingTrace tempTrace = TemporaryBindingTrace.create(state.getBindingTrace(), "property initializer");
@@ -432,10 +432,10 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
     }
 
     @NotNull
-    private JetType getPropertyOrDelegateType(@NotNull JetProperty property, @NotNull PropertyDescriptor descriptor) {
-        JetExpression delegateExpression = property.getDelegateExpression();
+    private KtType getPropertyOrDelegateType(@NotNull KtProperty property, @NotNull PropertyDescriptor descriptor) {
+        KtExpression delegateExpression = property.getDelegateExpression();
         if (delegateExpression != null) {
-            JetType delegateType = bindingContext.getType(delegateExpression);
+            KtType delegateType = bindingContext.getType(delegateExpression);
             assert delegateType != null : "Type of delegate expression should be recorded";
             return delegateType;
         }
@@ -488,10 +488,10 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
     }
 
     protected void generatePropertyMetadataArrayFieldIfNeeded(@NotNull Type thisAsmType) {
-        List<JetProperty> delegatedProperties = new ArrayList<JetProperty>();
-        for (JetDeclaration declaration : ((JetDeclarationContainer) element).getDeclarations()) {
-            if (declaration instanceof JetProperty) {
-                JetProperty property = (JetProperty) declaration;
+        List<KtProperty> delegatedProperties = new ArrayList<KtProperty>();
+        for (KtDeclaration declaration : ((KtDeclarationContainer) element).getDeclarations()) {
+            if (declaration instanceof KtProperty) {
+                KtProperty property = (KtProperty) declaration;
                 if (property.hasDelegate()) {
                     delegatedProperties.add(property);
                 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt
index 29d0e15fac6..128eb1961f0 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt
@@ -44,7 +44,7 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.MultifileClassPart
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.OtherOrigin
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPropertyDescriptor
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedSimpleFunctionDescriptor
@@ -55,7 +55,7 @@ import java.util.*
 
 public class MultifileClassCodegen(
         private val state: GenerationState,
-        public val files: Collection<JetFile>,
+        public val files: Collection<KtFile>,
         private val facadeFqName: FqName
 ) {
     private val facadeClassType = AsmUtil.asmTypeByFqNameWithoutInnerClasses(facadeFqName)
@@ -71,7 +71,7 @@ public class MultifileClassCodegen(
                 getDeserializedCallables(compiledPackageFragment)
 
     private fun getDeserializedCallables(compiledPackageFragment: PackageFragmentDescriptor) =
-            compiledPackageFragment.getMemberScope().getDescriptors(DescriptorKindFilter.CALLABLES, JetScope.ALL_NAME_FILTER).filterIsInstance<DeserializedCallableMemberDescriptor>()
+            compiledPackageFragment.getMemberScope().getDescriptors(DescriptorKindFilter.CALLABLES, KtScope.ALL_NAME_FILTER).filterIsInstance<DeserializedCallableMemberDescriptor>()
 
     public val packageParts = PackageParts(facadeFqName.parent().asString())
 
@@ -83,7 +83,7 @@ public class MultifileClassCodegen(
         val declarationOrigin = MultifileClass(originFile, actualPackageFragment, facadeFqName)
         val classBuilder = state.factory.newVisitor(declarationOrigin, facadeClassType, files)
 
-        val filesWithCallables = files.filter { it.declarations.any { it is JetNamedFunction || it is JetProperty } }
+        val filesWithCallables = files.filter { it.declarations.any { it is KtNamedFunction || it is KtProperty } }
 
         val singleSourceFile = if (previouslyCompiledCallables.isNotEmpty()) null else filesWithCallables.singleOrNull()
 
@@ -147,12 +147,12 @@ public class MultifileClassCodegen(
         writeKotlinMultifileFacadeAnnotationIfNeeded(partFqNames)
     }
 
-    public fun generateClassOrObject(classOrObject: JetClassOrObject, packagePartContext: FieldOwnerContext<PackageFragmentDescriptor>) {
+    public fun generateClassOrObject(classOrObject: KtClassOrObject, packagePartContext: FieldOwnerContext<PackageFragmentDescriptor>) {
         MemberCodegen.genClassOrObject(packagePartContext, classOrObject, state, null)
     }
 
     private fun generatePart(
-            file: JetFile,
+            file: KtFile,
             generateCallableMemberTasks: MutableMap<CallableMemberDescriptor, () -> Unit>,
             partFqNames: MutableList<FqName>
     ) {
@@ -165,15 +165,15 @@ public class MultifileClassCodegen(
         val partContext = state.rootContext.intoMultifileClassPart(packageFragment, facadeClassType, partType, file)
 
         for (declaration in file.declarations) {
-            if (declaration is JetProperty || declaration is JetNamedFunction) {
+            if (declaration is KtProperty || declaration is KtNamedFunction) {
                 generatePart = true
             }
-            else if (declaration is JetClassOrObject) {
+            else if (declaration is KtClassOrObject) {
                 if (state.generateDeclaredClassFilter.shouldGenerateClass(declaration)) {
                     generateClassOrObject(declaration, partContext)
                 }
             }
-            else if (declaration is JetScript) {
+            else if (declaration is KtScript) {
                 // SCRIPT: generate script code, should be separate execution branch
                 if (state.generateDeclaredClassFilter.shouldGenerateScript(declaration)) {
                     ScriptCodegen.createScriptCodegen(declaration, state, partContext).generate()
@@ -196,7 +196,7 @@ public class MultifileClassCodegen(
         val facadeContext = state.rootContext.intoMultifileClass(packageFragment, facadeClassType, partType)
         val memberCodegen = createCodegenForPartOfMultifileFacade(facadeContext)
         for (declaration in file.declarations) {
-            if (declaration is JetNamedFunction || declaration is JetProperty) {
+            if (declaration is KtNamedFunction || declaration is KtProperty) {
                 val descriptor = state.bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, declaration)
                 assert(descriptor is CallableMemberDescriptor) { "Expected callable member, was " + descriptor + " for " + declaration.text }
                 if (!Visibilities.isPrivate((descriptor as CallableMemberDescriptor).visibility)) {
@@ -273,8 +273,8 @@ public class MultifileClassCodegen(
         av.visitEnd()
     }
 
-    private fun createCodegenForPartOfMultifileFacade(facadeContext: FieldOwnerContext<*>): MemberCodegen<JetFile> =
-            object : MemberCodegen<JetFile>(state, null, facadeContext, null, classBuilder) {
+    private fun createCodegenForPartOfMultifileFacade(facadeContext: FieldOwnerContext<*>): MemberCodegen<KtFile> =
+            object : MemberCodegen<KtFile>(state, null, facadeContext, null, classBuilder) {
                 override fun generateDeclaration() = throw UnsupportedOperationException()
                 override fun generateBody() = throw UnsupportedOperationException()
                 override fun generateKotlinAnnotation() = throw UnsupportedOperationException()
@@ -287,7 +287,7 @@ public class MultifileClassCodegen(
     companion object {
         private val FACADE_CLASS_ATTRIBUTES = Opcodes.ACC_PUBLIC or Opcodes.ACC_FINAL
 
-        private fun getOnlyPackageFragment(packageFqName: FqName, files: Collection<JetFile>, bindingContext: BindingContext): PackageFragmentDescriptor? {
+        private fun getOnlyPackageFragment(packageFqName: FqName, files: Collection<KtFile>, bindingContext: BindingContext): PackageFragmentDescriptor? {
             val fragments = SmartList<PackageFragmentDescriptor>()
             for (file in files) {
                 val fragment = bindingContext.get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file)
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassPartCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassPartCodegen.kt
index a4b772cefc5..6bd48a76690 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassPartCodegen.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassPartCodegen.kt
@@ -22,9 +22,9 @@ import org.jetbrains.kotlin.codegen.serialization.JvmSerializerExtension
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.serialization.DescriptorSerializer
 import org.jetbrains.org.objectweb.asm.Opcodes
@@ -33,12 +33,12 @@ import java.util.*
 
 public class MultifileClassPartCodegen(
         v: ClassBuilder,
-        file: JetFile,
+        file: KtFile,
         private val filePartType: Type,
         private val multifileClassType: Type,
         partContext: FieldOwnerContext<*>,
         state: GenerationState
-) : MemberCodegen<JetFile>(state, null, partContext, file, v) {
+) : MemberCodegen<KtFile>(state, null, partContext, file, v) {
     override fun generate() {
         if (state.classBuilderMode == ClassBuilderMode.LIGHT_CLASSES) return
         super.generate()
@@ -58,7 +58,7 @@ public class MultifileClassPartCodegen(
 
     override fun generateBody() {
         for (declaration in element.declarations) {
-            if (declaration is JetNamedFunction || declaration is JetProperty) {
+            if (declaration is KtNamedFunction || declaration is KtProperty) {
                 genFunctionOrProperty(declaration)
             }
         }
@@ -72,11 +72,11 @@ public class MultifileClassPartCodegen(
         val members = ArrayList<DeclarationDescriptor>()
         for (declaration in element.declarations) {
             when (declaration) {
-                is JetNamedFunction -> {
+                is KtNamedFunction -> {
                     val functionDescriptor = bindingContext.get(BindingContext.FUNCTION, declaration)
                     members.add(functionDescriptor ?: throw AssertionError("Function ${declaration.name} is not bound in ${element.name}"))
                 }
-                is JetProperty -> {
+                is KtProperty -> {
                     val property = bindingContext.get(BindingContext.VARIABLE, declaration)
                     members.add(property ?: throw AssertionError("Property ${declaration.name} is not bound in ${element.name}"))
                 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MutableClassDescriptor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/MutableClassDescriptor.java
index 9bf5f18924f..ad7750481b0 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MutableClassDescriptor.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MutableClassDescriptor.java
@@ -24,9 +24,9 @@ import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorBase;
 import org.jetbrains.kotlin.descriptors.impl.ConstructorDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorImpl;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeConstructor;
 import org.jetbrains.kotlin.types.TypeConstructorImpl;
 import org.jetbrains.kotlin.types.TypeUtils;
@@ -41,7 +41,7 @@ public class MutableClassDescriptor extends ClassDescriptorBase implements Class
     private Visibility visibility;
     private TypeConstructor typeConstructor;
     private List<TypeParameterDescriptor> typeParameters;
-    private final Collection<JetType> supertypes = new ArrayList<JetType>();
+    private final Collection<KtType> supertypes = new ArrayList<KtType>();
 
     public MutableClassDescriptor(
             @NotNull DeclarationDescriptor containingDeclaration,
@@ -116,7 +116,7 @@ public class MutableClassDescriptor extends ClassDescriptorBase implements Class
         return typeConstructor;
     }
 
-    public void addSupertype(@NotNull JetType supertype) {
+    public void addSupertype(@NotNull KtType supertype) {
         assert !supertype.isError() : "Error types must be filtered out in DescriptorResolver";
         if (TypeUtils.getClassDescriptor(supertype) != null) {
             // See the Errors.SUPERTYPE_NOT_A_CLASS_OR_INTERFACE
@@ -160,14 +160,14 @@ public class MutableClassDescriptor extends ClassDescriptorBase implements Class
 
     @Override
     @NotNull
-    public JetScope getUnsubstitutedMemberScope() {
-        return JetScope.Empty.INSTANCE$; // used for getDefaultType
+    public KtScope getUnsubstitutedMemberScope() {
+        return KtScope.Empty.INSTANCE$; // used for getDefaultType
     }
 
     @NotNull
     @Override
-    public JetScope getStaticScope() {
-        return JetScope.Empty.INSTANCE$;
+    public KtScope getStaticScope() {
+        return KtScope.Empty.INSTANCE$;
     }
 
     @Override
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java
index b743e593623..9ddd394f816 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java
@@ -22,13 +22,10 @@ import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.util.SmartList;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.codegen.context.CodegenContext;
 import org.jetbrains.kotlin.codegen.context.PackageContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor;
-import org.jetbrains.kotlin.descriptors.Visibilities;
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils;
-import org.jetbrains.kotlin.fileClasses.FileClasses;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassInfo;
 import org.jetbrains.kotlin.load.kotlin.PackageParts;
 import org.jetbrains.kotlin.name.FqName;
@@ -42,13 +39,13 @@ import java.util.Collection;
 
 public class PackageCodegen {
     private final GenerationState state;
-    private final Collection<JetFile> files;
+    private final Collection<KtFile> files;
     private final PackageFragmentDescriptor packageFragment;
     private final PackageParts packageParts;
 
     public PackageCodegen(
             @NotNull GenerationState state,
-            @NotNull Collection<JetFile> files,
+            @NotNull Collection<KtFile> files,
             @NotNull FqName packageFqName
     ) {
         this.state = state;
@@ -58,7 +55,7 @@ public class PackageCodegen {
     }
 
     public void generate(@NotNull CompilationErrorHandler errorHandler) {
-        for (JetFile file : files) {
+        for (KtFile file : files) {
             ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
             try {
                 generateFile(file);
@@ -79,7 +76,7 @@ public class PackageCodegen {
     }
 
     @Nullable
-    private ClassBuilder generateFile(@NotNull JetFile file) {
+    private ClassBuilder generateFile(@NotNull KtFile file) {
         JvmFileClassInfo fileClassInfo = state.getFileClassesProvider().getFileClassInfo(file);
 
         if (fileClassInfo.getWithJvmMultifileClass()) {
@@ -91,18 +88,18 @@ public class PackageCodegen {
 
         boolean generatePackagePart = false;
 
-        for (JetDeclaration declaration : file.getDeclarations()) {
-            if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) {
+        for (KtDeclaration declaration : file.getDeclarations()) {
+            if (declaration instanceof KtProperty || declaration instanceof KtNamedFunction) {
                 generatePackagePart = true;
             }
-            else if (declaration instanceof JetClassOrObject) {
-                JetClassOrObject classOrObject = (JetClassOrObject) declaration;
+            else if (declaration instanceof KtClassOrObject) {
+                KtClassOrObject classOrObject = (KtClassOrObject) declaration;
                 if (state.getGenerateDeclaredClassFilter().shouldGenerateClass(classOrObject)) {
                     generateClassOrObject(classOrObject, packagePartContext);
                 }
             }
-            else if (declaration instanceof JetScript) {
-                JetScript script = (JetScript) declaration;
+            else if (declaration instanceof KtScript) {
+                KtScript script = (KtScript) declaration;
 
                 // SCRIPT: generate script code, should be separate execution branch
                 if (state.getGenerateDeclaredClassFilter().shouldGenerateScript(script)) {
@@ -126,7 +123,7 @@ public class PackageCodegen {
     @Nullable
     private PackageFragmentDescriptor getOnlyPackageFragment(@NotNull FqName expectedPackageFqName) {
         SmartList<PackageFragmentDescriptor> fragments = new SmartList<PackageFragmentDescriptor>();
-        for (JetFile file : files) {
+        for (KtFile file : files) {
             PackageFragmentDescriptor fragment = state.getBindingContext().get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file);
             assert fragment != null : "package fragment is null for " + file + "\n" + file.getText();
 
@@ -147,7 +144,7 @@ public class PackageCodegen {
         return fragments.get(0);
     }
 
-    public void generateClassOrObject(@NotNull JetClassOrObject classOrObject, @NotNull PackageContext packagePartContext) {
+    public void generateClassOrObject(@NotNull KtClassOrObject classOrObject, @NotNull PackageContext packagePartContext) {
         MemberCodegen.genClassOrObject(packagePartContext, classOrObject, state, null);
     }
 
@@ -155,7 +152,7 @@ public class PackageCodegen {
         return packageParts;
     }
 
-    public Collection<JetFile> getFiles() {
+    public Collection<KtFile> getFiles() {
         return files;
     }
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java
index 0b4419bfe8e..388651deedc 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java
@@ -46,12 +46,12 @@ import static org.jetbrains.kotlin.codegen.AsmUtil.writeAnnotationData;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.writeModuleName;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
-public class PackagePartCodegen extends MemberCodegen<JetFile> {
+public class PackagePartCodegen extends MemberCodegen<KtFile> {
     private final Type packagePartType;
 
     public PackagePartCodegen(
             @NotNull ClassBuilder v,
-            @NotNull JetFile file,
+            @NotNull KtFile file,
             @NotNull Type packagePartType,
             @NotNull FieldOwnerContext context,
             @NotNull GenerationState state
@@ -78,7 +78,7 @@ public class PackagePartCodegen extends MemberCodegen<JetFile> {
 
     private void generateAnnotationsForPartClass() {
         List<AnnotationDescriptor> fileAnnotationDescriptors = new ArrayList<AnnotationDescriptor>();
-        for (JetAnnotationEntry annotationEntry : element.getAnnotationEntries()) {
+        for (KtAnnotationEntry annotationEntry : element.getAnnotationEntries()) {
             AnnotationDescriptor annotationDescriptor = state.getBindingContext().get(BindingContext.ANNOTATION, annotationEntry);
             if (annotationDescriptor != null) {
                 fileAnnotationDescriptors.add(annotationDescriptor);
@@ -90,8 +90,8 @@ public class PackagePartCodegen extends MemberCodegen<JetFile> {
 
     @Override
     protected void generateBody() {
-        for (JetDeclaration declaration : element.getDeclarations()) {
-            if (declaration instanceof JetNamedFunction || declaration instanceof JetProperty) {
+        for (KtDeclaration declaration : element.getDeclarations()) {
+            if (declaration instanceof KtNamedFunction || declaration instanceof KtProperty) {
                 genFunctionOrProperty(declaration);
             }
         }
@@ -109,11 +109,11 @@ public class PackagePartCodegen extends MemberCodegen<JetFile> {
     @Override
     protected void generateKotlinAnnotation() {
         List<DeclarationDescriptor> members = new ArrayList<DeclarationDescriptor>();
-        for (JetDeclaration declaration : element.getDeclarations()) {
-            if (declaration instanceof JetNamedFunction) {
+        for (KtDeclaration declaration : element.getDeclarations()) {
+            if (declaration instanceof KtNamedFunction) {
                 SimpleFunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, declaration);
                 members.add(functionDescriptor);
-            } else if (declaration instanceof JetProperty) {
+            } else if (declaration instanceof KtProperty) {
                 VariableDescriptor property = bindingContext.get(BindingContext.VARIABLE, declaration);
                 members.add(property);
             }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PlatformStaticGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/PlatformStaticGenerator.kt
index 61143220ea2..b4282afde92 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PlatformStaticGenerator.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PlatformStaticGenerator.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.Synthetic
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
@@ -73,7 +73,7 @@ class PlatformStaticGenerator(
                 }
         )
 
-        if (originElement is JetNamedFunction) {
+        if (originElement is KtNamedFunction) {
             codegen.functionCodegen.generateOverloadsWithDefaultValues(originElement, staticFunctionDescriptor, descriptor)
         }
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java
index b28deb83c7c..59c079bb215 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java
@@ -44,7 +44,7 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPropertyDescriptor;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.org.objectweb.asm.FieldVisitor;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
 import org.jetbrains.org.objectweb.asm.Opcodes;
@@ -88,7 +88,7 @@ public class PropertyCodegen {
         this.kind = context.getContextKind();
     }
 
-    public void gen(@NotNull JetProperty property) {
+    public void gen(@NotNull KtProperty property) {
         VariableDescriptor variableDescriptor = bindingContext.get(BindingContext.VARIABLE, property);
         assert variableDescriptor instanceof PropertyDescriptor : "Property " + property.getText() + " should have a property descriptor: " + variableDescriptor;
 
@@ -102,10 +102,10 @@ public class PropertyCodegen {
     }
 
     private void gen(
-            @Nullable JetProperty declaration,
+            @Nullable KtProperty declaration,
             @NotNull PropertyDescriptor descriptor,
-            @Nullable JetPropertyAccessor getter,
-            @Nullable JetPropertyAccessor setter
+            @Nullable KtPropertyAccessor getter,
+            @Nullable KtPropertyAccessor setter
     ) {
         assert kind == OwnerKind.PACKAGE || kind == OwnerKind.IMPLEMENTATION || kind == OwnerKind.DEFAULT_IMPLS
                 : "Generating property with a wrong kind (" + kind + "): " + descriptor;
@@ -147,9 +147,9 @@ public class PropertyCodegen {
      * @see JvmCodegenUtil#couldUseDirectAccessToProperty
      */
     private boolean isAccessorNeeded(
-            @Nullable JetProperty declaration,
+            @Nullable KtProperty declaration,
             @NotNull PropertyDescriptor descriptor,
-            @Nullable JetPropertyAccessor accessor
+            @Nullable KtPropertyAccessor accessor
     ) {
         if (hasJvmFieldAnnotation(descriptor)) return false;
 
@@ -174,7 +174,7 @@ public class PropertyCodegen {
         return true;
     }
 
-    public void generatePrimaryConstructorProperty(JetParameter p, PropertyDescriptor descriptor) {
+    public void generatePrimaryConstructorProperty(KtParameter p, PropertyDescriptor descriptor) {
         AnnotationSplitter annotationSplitter = AnnotationSplitter.create(LockBasedStorageManager.NO_LOCKS,
                 descriptor.getAnnotations(), AnnotationSplitter.getTargetSet(true, descriptor.isVar(), hasBackingField(p, descriptor)));
 
@@ -192,7 +192,7 @@ public class PropertyCodegen {
         }
     }
 
-    public void generateConstructorPropertyAsMethodForAnnotationClass(JetParameter p, PropertyDescriptor descriptor) {
+    public void generateConstructorPropertyAsMethodForAnnotationClass(KtParameter p, PropertyDescriptor descriptor) {
         JvmMethodSignature signature = typeMapper.mapAnnotationParameterSignature(descriptor);
         String name = p.getName();
         if (name == null) return;
@@ -204,7 +204,7 @@ public class PropertyCodegen {
         );
 
         if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
-            JetExpression defaultValue = p.getDefaultValue();
+            KtExpression defaultValue = p.getDefaultValue();
             if (defaultValue != null) {
                 ConstantValue<?> constant = ExpressionCodegen.getCompileTimeConstant(defaultValue, bindingContext);
                 assert constant != null : "Default value for annotation parameter should be compile time value: " + defaultValue.getText();
@@ -216,14 +216,14 @@ public class PropertyCodegen {
         mv.visitEnd();
     }
 
-    private boolean hasBackingField(@NotNull JetNamedDeclaration p, @NotNull PropertyDescriptor descriptor) {
+    private boolean hasBackingField(@NotNull KtNamedDeclaration p, @NotNull PropertyDescriptor descriptor) {
         return !isJvmInterface(descriptor.getContainingDeclaration()) &&
                kind != OwnerKind.DEFAULT_IMPLS &&
                !Boolean.FALSE.equals(bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, descriptor));
     }
 
     private boolean generateBackingField(
-            @NotNull JetNamedDeclaration p,
+            @NotNull KtNamedDeclaration p,
             @NotNull PropertyDescriptor descriptor,
             @NotNull Annotations annotations
     ) {
@@ -231,8 +231,8 @@ public class PropertyCodegen {
             return false;
         }
 
-        if (p instanceof JetProperty && ((JetProperty) p).hasDelegate()) {
-            generatePropertyDelegateAccess((JetProperty) p, descriptor, annotations);
+        if (p instanceof KtProperty && ((KtProperty) p).hasDelegate()) {
+            generatePropertyDelegateAccess((KtProperty) p, descriptor, annotations);
         }
         else if (Boolean.TRUE.equals(bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, descriptor))) {
             generateBackingFieldAccess(p, descriptor, annotations);
@@ -272,10 +272,10 @@ public class PropertyCodegen {
     }
 
     private void generateBackingField(
-            JetNamedDeclaration element,
+            KtNamedDeclaration element,
             PropertyDescriptor propertyDescriptor,
             boolean isDelegate,
-            JetType jetType,
+            KtType jetType,
             Object defaultValue,
             Annotations annotations
     ) {
@@ -360,9 +360,9 @@ public class PropertyCodegen {
         AnnotationCodegen.forField(fv, typeMapper).genAnnotations(fieldAnnotated, type, AnnotationUseSiteTarget.FIELD);
     }
 
-    private void generatePropertyDelegateAccess(JetProperty p, PropertyDescriptor propertyDescriptor, Annotations annotations) {
-        JetExpression delegateExpression = p.getDelegateExpression();
-        JetType delegateType = delegateExpression != null ? bindingContext.getType(p.getDelegateExpression()) : null;
+    private void generatePropertyDelegateAccess(KtProperty p, PropertyDescriptor propertyDescriptor, Annotations annotations) {
+        KtExpression delegateExpression = p.getDelegateExpression();
+        KtType delegateType = delegateExpression != null ? bindingContext.getType(p.getDelegateExpression()) : null;
         if (delegateType == null) {
             // If delegate expression is unresolved reference
             delegateType = ErrorUtils.createErrorType("Delegate type");
@@ -371,7 +371,7 @@ public class PropertyCodegen {
         generateBackingField(p, propertyDescriptor, true, delegateType, null, annotations);
     }
 
-    private void generateBackingFieldAccess(JetNamedDeclaration p, PropertyDescriptor propertyDescriptor, Annotations annotations) {
+    private void generateBackingFieldAccess(KtNamedDeclaration p, PropertyDescriptor propertyDescriptor, Annotations annotations) {
         Object value = null;
 
         if (shouldWriteFieldInitializer(propertyDescriptor)) {
@@ -393,13 +393,13 @@ public class PropertyCodegen {
         return false;
     }
 
-    private void generateGetter(@Nullable JetNamedDeclaration p, @NotNull PropertyDescriptor descriptor, @Nullable JetPropertyAccessor getter) {
+    private void generateGetter(@Nullable KtNamedDeclaration p, @NotNull PropertyDescriptor descriptor, @Nullable KtPropertyAccessor getter) {
         generateAccessor(p, getter, descriptor.getGetter() != null
                                     ? descriptor.getGetter()
                                     : DescriptorFactory.createDefaultGetter(descriptor, Annotations.Companion.getEMPTY()));
     }
 
-    private void generateSetter(@Nullable JetNamedDeclaration p, @NotNull PropertyDescriptor descriptor, @Nullable JetPropertyAccessor setter) {
+    private void generateSetter(@Nullable KtNamedDeclaration p, @NotNull PropertyDescriptor descriptor, @Nullable KtPropertyAccessor setter) {
         if (!descriptor.isVar()) return;
 
         generateAccessor(p, setter, descriptor.getSetter() != null
@@ -408,8 +408,8 @@ public class PropertyCodegen {
     }
 
     private void generateAccessor(
-            @Nullable JetNamedDeclaration p,
-            @Nullable JetPropertyAccessor accessor,
+            @Nullable KtNamedDeclaration p,
+            @Nullable KtPropertyAccessor accessor,
             @NotNull PropertyAccessorDescriptor accessorDescriptor
     ) {
         if (context instanceof MultifileClassFacadeContext && Visibilities.isPrivate(accessorDescriptor.getVisibility())) {
@@ -418,8 +418,8 @@ public class PropertyCodegen {
 
         FunctionGenerationStrategy strategy;
         if (accessor == null || !accessor.hasBody()) {
-            if (p instanceof JetProperty && ((JetProperty) p).hasDelegate()) {
-                strategy = new DelegatedPropertyAccessorStrategy(state, accessorDescriptor, indexOfDelegatedProperty((JetProperty) p));
+            if (p instanceof KtProperty && ((KtProperty) p).hasDelegate()) {
+                strategy = new DelegatedPropertyAccessorStrategy(state, accessorDescriptor, indexOfDelegatedProperty((KtProperty) p));
             }
             else {
                 strategy = new DefaultPropertyAccessorStrategy(state, accessorDescriptor);
@@ -432,22 +432,22 @@ public class PropertyCodegen {
         functionCodegen.generateMethod(JvmDeclarationOriginKt.OtherOrigin(accessor != null ? accessor : p, accessorDescriptor), accessorDescriptor, strategy);
     }
 
-    public static int indexOfDelegatedProperty(@NotNull JetProperty property) {
+    public static int indexOfDelegatedProperty(@NotNull KtProperty property) {
         PsiElement parent = property.getParent();
-        JetDeclarationContainer container;
-        if (parent instanceof JetClassBody) {
-            container = ((JetClassOrObject) parent.getParent());
+        KtDeclarationContainer container;
+        if (parent instanceof KtClassBody) {
+            container = ((KtClassOrObject) parent.getParent());
         }
-        else if (parent instanceof JetFile) {
-            container = (JetFile) parent;
+        else if (parent instanceof KtFile) {
+            container = (KtFile) parent;
         }
         else {
             throw new UnsupportedOperationException("Unknown delegated property container: " + parent);
         }
 
         int index = 0;
-        for (JetDeclaration declaration : container.getDeclarations()) {
-            if (declaration instanceof JetProperty && ((JetProperty) declaration).hasDelegate()) {
+        for (KtDeclaration declaration : container.getDeclarations()) {
+            if (declaration instanceof KtProperty && ((KtProperty) declaration).hasDelegate()) {
                 if (declaration == property) {
                     return index;
                 }
@@ -471,8 +471,8 @@ public class PropertyCodegen {
             StackValue property = codegen.intermediateValueForProperty(propertyDescriptor, true, null, StackValue.LOCAL_0);
 
             PsiElement jetProperty = DescriptorToSourceUtils.descriptorToDeclaration(propertyDescriptor);
-            if (jetProperty instanceof JetProperty || jetProperty instanceof JetParameter) {
-                codegen.markLineNumber((JetElement) jetProperty, false);
+            if (jetProperty instanceof KtProperty || jetProperty instanceof KtParameter) {
+                codegen.markLineNumber((KtElement) jetProperty, false);
             }
 
             if (callableDescriptor instanceof PropertyGetterDescriptor) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt
index e11694ffa71..56038f0855e 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.resolve.DescriptorFactory
 import org.jetbrains.kotlin.resolve.PropertyImportedFromObject
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
@@ -47,12 +47,12 @@ public class PropertyReferenceCodegen(
         state: GenerationState,
         parentCodegen: MemberCodegen<*>,
         context: ClassContext,
-        expression: JetElement,
+        expression: KtElement,
         classBuilder: ClassBuilder,
         private val classDescriptor: ClassDescriptor,
         private val target: VariableDescriptor,
         dispatchReceiver: ReceiverValue
-) : MemberCodegen<JetElement>(state, parentCodegen, context, expression, classBuilder) {
+) : MemberCodegen<KtElement>(state, parentCodegen, context, expression, classBuilder) {
     private val asmType = typeMapper.mapClass(classDescriptor)
 
     private val dispatchReceiverType =
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/RangeCodegenUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/RangeCodegenUtil.java
index 8f17fcc17c9..6767405f458 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/RangeCodegenUtil.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/RangeCodegenUtil.java
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.name.FqNameUnsafe;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.List;
 
@@ -53,27 +53,27 @@ public class RangeCodegenUtil {
 
     private RangeCodegenUtil() {}
 
-    public static boolean isRange(JetType rangeType) {
+    public static boolean isRange(KtType rangeType) {
         return !rangeType.isMarkedNullable() && getPrimitiveRangeElementType(rangeType) != null;
     }
 
-    public static boolean isProgression(JetType rangeType) {
+    public static boolean isProgression(KtType rangeType) {
         return !rangeType.isMarkedNullable() && getPrimitiveProgressionElementType(rangeType) != null;
     }
 
     @Nullable
-    public static BinaryCall getRangeAsBinaryCall(@NotNull JetForExpression forExpression) {
+    public static BinaryCall getRangeAsBinaryCall(@NotNull KtForExpression forExpression) {
         // We are looking for rangeTo() calls
         // Other binary operations will succeed too, but will be filtered out later (by examining a resolvedCall)
-        JetExpression rangeExpression = forExpression.getLoopRange();
+        KtExpression rangeExpression = forExpression.getLoopRange();
         assert rangeExpression != null;
-        JetExpression loopRange = JetPsiUtil.deparenthesize(rangeExpression);
-        if (loopRange instanceof JetQualifiedExpression) {
+        KtExpression loopRange = KtPsiUtil.deparenthesize(rangeExpression);
+        if (loopRange instanceof KtQualifiedExpression) {
             // a.rangeTo(b)
-            JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) loopRange;
-            JetExpression selector = qualifiedExpression.getSelectorExpression();
-            if (selector instanceof JetCallExpression) {
-                JetCallExpression callExpression = (JetCallExpression) selector;
+            KtQualifiedExpression qualifiedExpression = (KtQualifiedExpression) loopRange;
+            KtExpression selector = qualifiedExpression.getSelectorExpression();
+            if (selector instanceof KtCallExpression) {
+                KtCallExpression callExpression = (KtCallExpression) selector;
                 List<? extends ValueArgument> arguments = callExpression.getValueArguments();
                 if (arguments.size() == 1) {
                     return new BinaryCall(qualifiedExpression.getReceiverExpression(), callExpression.getCalleeExpression(),
@@ -81,10 +81,10 @@ public class RangeCodegenUtil {
                 }
             }
         }
-        else if (loopRange instanceof JetBinaryExpression) {
+        else if (loopRange instanceof KtBinaryExpression) {
             // a rangeTo b
             // a .. b
-            JetBinaryExpression binaryExpression = (JetBinaryExpression) loopRange;
+            KtBinaryExpression binaryExpression = (KtBinaryExpression) loopRange;
             return new BinaryCall(binaryExpression.getLeft(), binaryExpression.getOperationReference(), binaryExpression.getRight());
 
         }
@@ -92,18 +92,18 @@ public class RangeCodegenUtil {
     }
 
     @Nullable
-    private static PrimitiveType getPrimitiveRangeElementType(JetType rangeType) {
+    private static PrimitiveType getPrimitiveRangeElementType(KtType rangeType) {
         return getPrimitiveRangeOrProgressionElementType(rangeType, RANGE_TO_ELEMENT_TYPE);
     }
 
     @Nullable
-    private static PrimitiveType getPrimitiveProgressionElementType(JetType rangeType) {
+    private static PrimitiveType getPrimitiveProgressionElementType(KtType rangeType) {
         return getPrimitiveRangeOrProgressionElementType(rangeType, PROGRESSION_TO_ELEMENT_TYPE);
     }
 
     @Nullable
     private static PrimitiveType getPrimitiveRangeOrProgressionElementType(
-            @NotNull JetType rangeOrProgression,
+            @NotNull KtType rangeOrProgression,
             @NotNull ImmutableMap<FqName, PrimitiveType> map
     ) {
         ClassifierDescriptor declarationDescriptor = rangeOrProgression.getConstructor().getDeclarationDescriptor();
@@ -133,11 +133,11 @@ public class RangeCodegenUtil {
     }
 
     public static class BinaryCall {
-        public final JetExpression left;
-        public final JetExpression op;
-        public final JetExpression right;
+        public final KtExpression left;
+        public final KtExpression op;
+        public final KtExpression right;
 
-        private BinaryCall(JetExpression left, JetExpression op, JetExpression right) {
+        private BinaryCall(KtExpression left, KtExpression op, KtExpression right) {
             this.left = left;
             this.op = op;
             this.right = right;
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/SamType.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/SamType.java
index cddc32ea9f0..69a9225e85d 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/SamType.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/SamType.java
@@ -21,22 +21,22 @@ import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor;
 import org.jetbrains.kotlin.load.java.sam.SingleAbstractMethodUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public class SamType {
-    public static SamType create(@NotNull JetType originalType) {
+    public static SamType create(@NotNull KtType originalType) {
         if (!SingleAbstractMethodUtils.isSamType(originalType)) return null;
         return new SamType(originalType);
     }
 
-    private final JetType type;
+    private final KtType type;
 
-    private SamType(@NotNull JetType type) {
+    private SamType(@NotNull KtType type) {
         this.type = type;
     }
 
     @NotNull
-    public JetType getType() {
+    public KtType getType() {
         return type;
     }
 
@@ -48,7 +48,7 @@ public class SamType {
     }
 
     @NotNull
-    public JetType getKotlinFunctionType() {
+    public KtType getKotlinFunctionType() {
         //noinspection ConstantConditions
         return getJavaClassDescriptor().getFunctionTypeForSamInterface();
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperClasses.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperClasses.java
index 7c68048087a..b79e81039fb 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperClasses.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperClasses.java
@@ -22,7 +22,7 @@ import com.intellij.openapi.util.Pair;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.org.objectweb.asm.Type;
 
 import java.util.Map;
@@ -30,14 +30,14 @@ import java.util.Map;
 public class SamWrapperClasses {
     private final GenerationState state;
 
-    private final Map<Pair<SamType, JetFile>, Type> samInterfaceToWrapperClass = Maps.newHashMap();
+    private final Map<Pair<SamType, KtFile>, Type> samInterfaceToWrapperClass = Maps.newHashMap();
 
     public SamWrapperClasses(@NotNull GenerationState state) {
         this.state = state;
     }
 
     @NotNull
-    public Type getSamWrapperClass(@NotNull final SamType samType, @NotNull final JetFile file, @NotNull final MemberCodegen<?> parentCodegen) {
+    public Type getSamWrapperClass(@NotNull final SamType samType, @NotNull final KtFile file, @NotNull final MemberCodegen<?> parentCodegen) {
         return ContainerUtil.getOrCreate(samInterfaceToWrapperClass, Pair.create(samType, file),
                                          new Factory<Type>() {
                                              @Override
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java
index 8e56a7c4e74..b39706028a0 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java
@@ -28,10 +28,10 @@ import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor;
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 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.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
 import org.jetbrains.org.objectweb.asm.Type;
@@ -58,13 +58,13 @@ public class SamWrapperCodegen {
         this.parentCodegen = parentCodegen;
     }
 
-    public Type genWrapper(@NotNull JetFile file) {
+    public Type genWrapper(@NotNull KtFile file) {
         // Name for generated class, in form of whatever$1
         FqName fqName = getWrapperName(file);
         Type asmType = asmTypeByFqNameWithoutInnerClasses(fqName);
 
         // e.g. (T, T) -> Int
-        JetType functionType = samType.getKotlinFunctionType();
+        KtType functionType = samType.getKotlinFunctionType();
 
         ClassDescriptor classDescriptor = new ClassDescriptorImpl(
                 samType.getJavaClassDescriptor().getContainingDeclaration(),
@@ -140,7 +140,7 @@ public class SamWrapperCodegen {
             Type functionType,
             ClassBuilder cv,
             SimpleFunctionDescriptor erasedInterfaceFunction,
-            JetType functionJetType
+            KtType functionJetType
     ) {
         // using root context to avoid creating ClassDescriptor and everything else
         FunctionCodegen codegen = new FunctionCodegen(state.getRootContext().intoClass(
@@ -168,7 +168,7 @@ public class SamWrapperCodegen {
     }
 
     @NotNull
-    private FqName getWrapperName(@NotNull JetFile containingFile) {
+    private FqName getWrapperName(@NotNull KtFile containingFile) {
         FqName fileClassFqName = JvmFileClassUtil.getFileClassInfoNoResolve(containingFile).getFileClassFqName();
         JavaClassDescriptor descriptor = samType.getJavaClassDescriptor();
         int hash = PackagePartClassUtils.getPathHashCode(containingFile.getVirtualFile()) * 31 +
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.java
index f1d77ea1756..8f3c911138b 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.java
@@ -45,10 +45,10 @@ import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
 // SCRIPT: script code generator
-public class ScriptCodegen extends MemberCodegen<JetScript> {
+public class ScriptCodegen extends MemberCodegen<KtScript> {
 
     public static ScriptCodegen createScriptCodegen(
-            @NotNull JetScript declaration,
+            @NotNull KtScript declaration,
             @NotNull GenerationState state,
             @NotNull CodegenContext parentContext
     ) {
@@ -72,12 +72,12 @@ public class ScriptCodegen extends MemberCodegen<JetScript> {
         return new ScriptCodegen(declaration, state, scriptContext, builder);
     }
 
-    private final JetScript scriptDeclaration;
+    private final KtScript scriptDeclaration;
     private final ScriptContext context;
     private final ScriptDescriptor scriptDescriptor;
 
     private ScriptCodegen(
-            @NotNull JetScript scriptDeclaration,
+            @NotNull KtScript scriptDeclaration,
             @NotNull GenerationState state,
             @NotNull ScriptContext context,
             @NotNull ClassBuilder builder
@@ -221,12 +221,12 @@ public class ScriptCodegen extends MemberCodegen<JetScript> {
     }
 
     private void genMembers() {
-        for (JetDeclaration declaration : scriptDeclaration.getDeclarations()) {
-            if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) {
+        for (KtDeclaration declaration : scriptDeclaration.getDeclarations()) {
+            if (declaration instanceof KtProperty || declaration instanceof KtNamedFunction) {
                 genFunctionOrProperty(declaration);
             }
-            else if (declaration instanceof JetClassOrObject) {
-                genClassOrObject((JetClassOrObject) declaration);
+            else if (declaration instanceof KtClassOrObject) {
+                genClassOrObject((KtClassOrObject) declaration);
             }
         }
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/SourceInfo.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/SourceInfo.kt
index 3f03f07b263..d86563e8456 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/SourceInfo.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/SourceInfo.kt
@@ -17,21 +17,21 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.backend.common.CodegenUtil
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedFunction
 
 data public class SourceInfo(val source: String, val pathOrCleanFQN: String, val linesInFile: Int) {
 
     companion object {
-        fun createInfo(element: JetElement?, internalClassName: String): SourceInfo {
+        fun createInfo(element: KtElement?, internalClassName: String): SourceInfo {
             assert(element != null) { "Couldn't create source mapper for null element " + internalClassName }
             val lineNumbers = CodegenUtil.getLineNumberForElement(element!!.getContainingFile(), true)
             assert(lineNumbers != null) { "Couldn't extract line count in " + element.getContainingFile() }
 
             //TODO hack condition for package parts cleaning
-            val isTopLevel = element is JetFile || (element is JetNamedFunction && element.getParent() is JetFile)
+            val isTopLevel = element is KtFile || (element is KtNamedFunction && element.getParent() is KtFile)
             val cleanedClassFqName = if (!isTopLevel) internalClassName else internalClassName.substringBefore('$')
 
             return SourceInfo(element.getContainingJetFile().getName(), cleanedClassFqName, lineNumbers!!)
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java
index 6c738ecc5e6..04da4b83393 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.resolve.ImportedFromObjectCallableDescriptor;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
@@ -266,7 +266,7 @@ public abstract class StackValue {
     }
 
     @NotNull
-    public static StackValue expression(Type type, JetExpression expression, ExpressionCodegen generator) {
+    public static StackValue expression(Type type, KtExpression expression, ExpressionCodegen generator) {
         return new Expression(type, expression, generator);
     }
 
@@ -1124,10 +1124,10 @@ public abstract class StackValue {
     }
 
     private static class Expression extends StackValue {
-        private final JetExpression expression;
+        private final KtExpression expression;
         private final ExpressionCodegen generator;
 
-        public Expression(Type type, JetExpression expression, ExpressionCodegen generator) {
+        public Expression(Type type, KtExpression expression, ExpressionCodegen generator) {
             super(type);
             this.expression = expression;
             this.generator = generator;
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/TailRecursionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/TailRecursionCodegen.java
index 5dd5a657e24..af0916dc09f 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/TailRecursionCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/TailRecursionCodegen.java
@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
 import org.jetbrains.kotlin.psi.ValueArgument;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.*;
@@ -104,9 +104,9 @@ public class TailRecursionCodegen {
             if (arg instanceof ExpressionValueArgument) {
                 ExpressionValueArgument ev = (ExpressionValueArgument) arg;
                 ValueArgument argument = ev.getValueArgument();
-                JetExpression argumentExpression = argument == null ? null : argument.getArgumentExpression();
+                KtExpression argumentExpression = argument == null ? null : argument.getArgumentExpression();
 
-                if (argumentExpression instanceof JetSimpleNameExpression) {
+                if (argumentExpression instanceof KtSimpleNameExpression) {
                     ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(argumentExpression, state.getBindingContext());
                     if (resolvedCall != null && resolvedCall.getResultingDescriptor().equals(parameterDescriptor.getOriginal())) {
                         // do nothing: we shouldn't store argument to itself again
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CalculatedClosure.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CalculatedClosure.java
index 988fe642c9b..dfd540142b9 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CalculatedClosure.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CalculatedClosure.java
@@ -21,10 +21,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.context.EnclosedValueDescriptor;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.descriptors.ConstructorDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.org.objectweb.asm.Type;
 
 import java.util.List;
@@ -35,7 +33,7 @@ public interface CalculatedClosure {
     ClassDescriptor getCaptureThis();
 
     @Nullable
-    JetType getCaptureReceiverType();
+    KtType getCaptureReceiverType();
 
     @NotNull
     Map<DeclarationDescriptor, EnclosedValueDescriptor> getCaptureVariables();
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java
index 9c14cc42571..c3aa03f4671 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java
@@ -49,19 +49,19 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.EnumValue;
 import org.jetbrains.kotlin.resolve.constants.NullValue;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.resolve.source.KotlinSourceElementKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.org.objectweb.asm.Type;
 
 import java.util.*;
 
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.*;
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
+import static org.jetbrains.kotlin.lexer.KtTokens.*;
 import static org.jetbrains.kotlin.name.SpecialNames.safeIdentifier;
 import static org.jetbrains.kotlin.resolve.BindingContext.*;
 
-class CodegenAnnotatingVisitor extends JetVisitorVoid {
+class CodegenAnnotatingVisitor extends KtVisitorVoid {
     private static final TokenSet BINARY_OPERATIONS = TokenSet.orSet(
             AUGMENTED_ASSIGNMENTS,
             TokenSet.create(PLUS, MINUS, MUL, DIV, PERC, RANGE, LT, GT, LTEQ, GTEQ, IDENTIFIER)
@@ -88,9 +88,9 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
 
     @NotNull
     private ClassDescriptor recordClassForCallable(
-            @NotNull JetElement element,
+            @NotNull KtElement element,
             @NotNull CallableDescriptor callableDescriptor,
-            @NotNull Collection<JetType> supertypes,
+            @NotNull Collection<KtType> supertypes,
             @NotNull String name
     ) {
         String simpleName = name.substring(name.lastIndexOf('/') + 1);
@@ -101,7 +101,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
                 supertypes,
                 KotlinSourceElementKt.toSourceElement(element)
         );
-        classDescriptor.initialize(JetScope.Empty.INSTANCE$, Collections.<ConstructorDescriptor>emptySet(), null);
+        classDescriptor.initialize(KtScope.Empty.INSTANCE$, Collections.<ConstructorDescriptor>emptySet(), null);
 
         bindingTrace.record(CLASS_FOR_CALLABLE, callableDescriptor, classDescriptor);
         return classDescriptor;
@@ -109,7 +109,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
 
     @NotNull
     @SuppressWarnings("ConstantConditions")
-    private DeclarationDescriptor correctContainerForLambda(@NotNull CallableDescriptor descriptor, @NotNull JetElement function) {
+    private DeclarationDescriptor correctContainerForLambda(@NotNull CallableDescriptor descriptor, @NotNull KtElement function) {
         DeclarationDescriptor container = descriptor.getContainingDeclaration();
 
         // In almost all cases the function's direct container is the correct container to consider in JVM back-end
@@ -126,9 +126,9 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
 
                 if (bindingContext.get(DECLARATION_TO_DESCRIPTOR, element) == container) return container;
 
-                if (element instanceof JetObjectDeclaration &&
-                    element.getParent() instanceof JetObjectLiteralExpression &&
-                    child instanceof JetDelegationSpecifierList) {
+                if (element instanceof KtObjectDeclaration &&
+                    element.getParent() instanceof KtObjectLiteralExpression &&
+                    child instanceof KtDelegationSpecifierList) {
                     // If we're passing an anonymous object's super call, it means "container" is ConstructorDescriptor of that object.
                     // To reach outer context, we should call getContainingDeclaration() twice
                     // TODO: this is probably not entirely correct, mostly because DECLARATION_TO_DESCRIPTOR can return null
@@ -153,13 +153,13 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Override
-    public void visitJetElement(@NotNull JetElement element) {
+    public void visitJetElement(@NotNull KtElement element) {
         super.visitJetElement(element);
         element.acceptChildren(this);
     }
 
     @Override
-    public void visitJetFile(@NotNull JetFile file) {
+    public void visitJetFile(@NotNull KtFile file) {
         if (file.isScript()) {
             // SCRIPT: should be replaced with VisitScript override
             //noinspection ConstantConditions
@@ -179,9 +179,9 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Override
-    public void visitEnumEntry(@NotNull JetEnumEntry enumEntry) {
+    public void visitEnumEntry(@NotNull KtEnumEntry enumEntry) {
         if (enumEntry.getDeclarations().isEmpty()) {
-            for (JetDelegationSpecifier specifier : enumEntry.getDelegationSpecifiers()) {
+            for (KtDelegationSpecifier specifier : enumEntry.getDelegationSpecifiers()) {
                 specifier.accept(this);
             }
             return;
@@ -196,7 +196,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Override
-    public void visitObjectDeclaration(@NotNull JetObjectDeclaration declaration) {
+    public void visitObjectDeclaration(@NotNull KtObjectDeclaration declaration) {
         if (!filter.shouldAnnotateClass(declaration)) return;
 
         ClassDescriptor classDescriptor = bindingContext.get(CLASS, declaration);
@@ -214,7 +214,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Override
-    public void visitClass(@NotNull JetClass klass) {
+    public void visitClass(@NotNull KtClass klass) {
         if (!filter.shouldAnnotateClass(klass)) return;
 
         ClassDescriptor classDescriptor = bindingContext.get(CLASS, klass);
@@ -239,8 +239,8 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Override
-    public void visitObjectLiteralExpression(@NotNull JetObjectLiteralExpression expression) {
-        JetObjectDeclaration object = expression.getObjectDeclaration();
+    public void visitObjectLiteralExpression(@NotNull KtObjectLiteralExpression expression) {
+        KtObjectDeclaration object = expression.getObjectDeclaration();
         ClassDescriptor classDescriptor = bindingContext.get(CLASS, object);
         if (classDescriptor == null) {
             // working around a problem with shallow analysis
@@ -251,14 +251,14 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         String name = inventAnonymousClassName();
         recordClosure(classDescriptor, name);
 
-        JetDelegationSpecifierList delegationSpecifierList = object.getDelegationSpecifierList();
+        KtDelegationSpecifierList delegationSpecifierList = object.getDelegationSpecifierList();
         if (delegationSpecifierList != null) {
             delegationSpecifierList.accept(this);
         }
 
         classStack.push(classDescriptor);
         nameStack.push(CodegenBinding.getAsmType(bindingContext, classDescriptor).getInternalName());
-        JetClassBody body = object.getBody();
+        KtClassBody body = object.getBody();
         if (body != null) {
             super.visitClassBody(body);
         }
@@ -267,15 +267,15 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Override
-    public void visitFunctionLiteralExpression(@NotNull JetFunctionLiteralExpression expression) {
-        JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
+    public void visitFunctionLiteralExpression(@NotNull KtFunctionLiteralExpression expression) {
+        KtFunctionLiteral functionLiteral = expression.getFunctionLiteral();
         FunctionDescriptor functionDescriptor =
                 (FunctionDescriptor) bindingContext.get(DECLARATION_TO_DESCRIPTOR, functionLiteral);
         // working around a problem with shallow analysis
         if (functionDescriptor == null) return;
 
         String name = inventAnonymousClassName();
-        Collection<JetType> supertypes = runtimeTypes.getSupertypesForClosure(functionDescriptor);
+        Collection<KtType> supertypes = runtimeTypes.getSupertypesForClosure(functionDescriptor);
         ClassDescriptor classDescriptor = recordClassForCallable(functionLiteral, functionDescriptor, supertypes, name);
         recordClosure(classDescriptor, name);
 
@@ -287,13 +287,13 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Override
-    public void visitCallableReferenceExpression(@NotNull JetCallableReferenceExpression expression) {
+    public void visitCallableReferenceExpression(@NotNull KtCallableReferenceExpression expression) {
         ResolvedCall<?> referencedFunction = CallUtilKt.getResolvedCall(expression.getCallableReference(), bindingContext);
         if (referencedFunction == null) return;
         CallableDescriptor target = referencedFunction.getResultingDescriptor();
 
         CallableDescriptor callableDescriptor;
-        Collection<JetType> supertypes;
+        Collection<KtType> supertypes;
 
         if (target instanceof FunctionDescriptor) {
             callableDescriptor = bindingContext.get(FUNCTION, expression);
@@ -328,7 +328,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Override
-    public void visitProperty(@NotNull JetProperty property) {
+    public void visitProperty(@NotNull KtProperty property) {
         DeclarationDescriptor descriptor = bindingContext.get(DECLARATION_TO_DESCRIPTOR, property);
         // working around a problem with shallow analysis
         if (descriptor == null) return;
@@ -341,11 +341,11 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
             nameStack.push(peekFromStack(nameStack) + '$' + safeIdentifier(property.getNameAsSafeName()).asString());
         }
 
-        JetPropertyDelegate delegate = property.getDelegate();
+        KtPropertyDelegate delegate = property.getDelegate();
         if (delegate != null && descriptor instanceof PropertyDescriptor) {
             PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
             String name = inventAnonymousClassName();
-            JetType supertype = runtimeTypes.getSupertypeForPropertyReference(propertyDescriptor);
+            KtType supertype = runtimeTypes.getSupertypeForPropertyReference(propertyDescriptor);
             ClassDescriptor classDescriptor = recordClassForCallable(delegate, propertyDescriptor, Collections.singleton(supertype), name);
             recordClosure(classDescriptor, name);
         }
@@ -355,7 +355,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Override
-    public void visitNamedFunction(@NotNull JetNamedFunction function) {
+    public void visitNamedFunction(@NotNull KtNamedFunction function) {
         FunctionDescriptor functionDescriptor = (FunctionDescriptor) bindingContext.get(DECLARATION_TO_DESCRIPTOR, function);
         // working around a problem with shallow analysis
         if (functionDescriptor == null) return;
@@ -368,7 +368,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         }
         else {
             String name = inventAnonymousClassName();
-            Collection<JetType> supertypes = runtimeTypes.getSupertypesForClosure(functionDescriptor);
+            Collection<KtType> supertypes = runtimeTypes.getSupertypesForClosure(functionDescriptor);
             ClassDescriptor classDescriptor = recordClassForCallable(function, functionDescriptor, supertypes, name);
             recordClosure(classDescriptor, name);
 
@@ -390,7 +390,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
             return peek + '$' + name;
         }
         else if (containingDeclaration instanceof PackageFragmentDescriptor) {
-            JetFile containingFile = DescriptorToSourceUtils.getContainingFile(descriptor);
+            KtFile containingFile = DescriptorToSourceUtils.getContainingFile(descriptor);
             assert containingFile != null : "File not found for " + descriptor;
             return FileClasses.getFileClassInternalName(fileClassesProvider, containingFile) + '$' + name;
         }
@@ -399,12 +399,12 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Override
-    public void visitCallExpression(@NotNull JetCallExpression expression) {
+    public void visitCallExpression(@NotNull KtCallExpression expression) {
         super.visitCallExpression(expression);
         checkSamCall(expression);
     }
 
-    private void checkSamCall(@NotNull JetCallElement expression) {
+    private void checkSamCall(@NotNull KtCallElement expression) {
         ResolvedCall<?> call = CallUtilKt.getResolvedCall(expression, bindingContext);
         if (call == null) return;
 
@@ -427,7 +427,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
             assert resolvedValueArgument instanceof ExpressionValueArgument : resolvedValueArgument;
             ValueArgument valueArgument = ((ExpressionValueArgument) resolvedValueArgument).getValueArgument();
             assert valueArgument != null;
-            JetExpression argumentExpression = valueArgument.getArgumentExpression();
+            KtExpression argumentExpression = valueArgument.getArgumentExpression();
             assert argumentExpression != null : valueArgument.asElement().getText();
 
             bindingTrace.record(CodegenBinding.SAM_VALUE, argumentExpression, samType);
@@ -435,12 +435,12 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Override
-    public void visitDelegationToSuperCallSpecifier(@NotNull JetDelegatorToSuperCall call) {
+    public void visitDelegationToSuperCallSpecifier(@NotNull KtDelegatorToSuperCall call) {
         super.visitDelegationToSuperCallSpecifier(call);
         checkSamCall(call);
     }
 
-    private void recordSamConstructorIfNeeded(@NotNull JetCallElement expression, @NotNull ResolvedCall<?> call) {
+    private void recordSamConstructorIfNeeded(@NotNull KtCallElement expression, @NotNull ResolvedCall<?> call) {
         CallableDescriptor callableDescriptor = call.getResultingDescriptor();
         if (!(callableDescriptor.getOriginal() instanceof SamConstructorDescriptor)) return;
 
@@ -452,7 +452,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         ValueArgument argument = ((ExpressionValueArgument) valueArgument).getValueArgument();
         if (argument == null) return;
 
-        JetExpression argumentExpression = argument.getArgumentExpression();
+        KtExpression argumentExpression = argument.getArgumentExpression();
         bindingTrace.record(SAM_CONSTRUCTOR_TO_ARGUMENT, expression, argumentExpression);
 
         //noinspection ConstantConditions
@@ -461,7 +461,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Override
-    public void visitBinaryExpression(@NotNull JetBinaryExpression expression) {
+    public void visitBinaryExpression(@NotNull KtBinaryExpression expression) {
         super.visitBinaryExpression(expression);
 
         DeclarationDescriptor operationDescriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, expression.getOperationReference());
@@ -483,7 +483,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Override
-    public void visitArrayAccessExpression(@NotNull JetArrayAccessExpression expression) {
+    public void visitArrayAccessExpression(@NotNull KtArrayAccessExpression expression) {
         super.visitArrayAccessExpression(expression);
 
         DeclarationDescriptor operationDescriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, expression);
@@ -493,7 +493,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         FunctionDescriptor original = SamCodegenUtil.getOriginalIfSamAdapter((FunctionDescriptor) operationDescriptor);
         if (original == null) return;
 
-        List<JetExpression> indexExpressions = expression.getIndexExpressions();
+        List<KtExpression> indexExpressions = expression.getIndexExpressions();
         List<ValueParameterDescriptor> parameters = original.getValueParameters();
         for (ValueParameterDescriptor valueParameter : parameters) {
             SamType samType = SamType.create(valueParameter.getType());
@@ -501,20 +501,20 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
 
             if (isSetter && valueParameter.getIndex() == parameters.size() - 1) {
                 PsiElement parent = expression.getParent();
-                if (parent instanceof JetBinaryExpression && ((JetBinaryExpression) parent).getOperationToken() == EQ) {
-                    JetExpression right = ((JetBinaryExpression) parent).getRight();
+                if (parent instanceof KtBinaryExpression && ((KtBinaryExpression) parent).getOperationToken() == EQ) {
+                    KtExpression right = ((KtBinaryExpression) parent).getRight();
                     bindingTrace.record(CodegenBinding.SAM_VALUE, right, samType);
                 }
             }
             else {
-                JetExpression indexExpression = indexExpressions.get(valueParameter.getIndex());
+                KtExpression indexExpression = indexExpressions.get(valueParameter.getIndex());
                 bindingTrace.record(CodegenBinding.SAM_VALUE, indexExpression, samType);
             }
         }
     }
 
     @Override
-    public void visitWhenExpression(@NotNull JetWhenExpression expression) {
+    public void visitWhenExpression(@NotNull KtWhenExpression expression) {
         super.visitWhenExpression(expression);
         if (!isWhenWithEnums(expression)) return;
 
@@ -530,7 +530,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         int fieldNumber = mappings.size();
 
         assert expression.getSubjectExpression() != null : "subject expression should be not null in a valid when by enums";
-        JetType type = bindingContext.getType(expression.getSubjectExpression());
+        KtType type = bindingContext.getType(expression.getSubjectExpression());
         assert type != null : "should not be null in a valid when by enums";
         ClassDescriptor classDescriptor = (ClassDescriptor) type.getConstructor().getDeclarationDescriptor();
         assert classDescriptor != null : "because it's enum";
@@ -549,7 +549,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         bindingTrace.record(MAPPING_FOR_WHEN_BY_ENUM, expression, mapping);
     }
 
-    private boolean isWhenWithEnums(@NotNull JetWhenExpression expression) {
+    private boolean isWhenWithEnums(@NotNull KtWhenExpression expression) {
         return WhenChecker.isWhenByEnum(expression, bindingContext) &&
                SwitchCodegenUtil.checkAllItemsAreConstantsSatisfying(
                        expression,
@@ -564,7 +564,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @NotNull
-    private String getCurrentTopLevelClassOrPackagePartInternalName(@NotNull JetFile file) {
+    private String getCurrentTopLevelClassOrPackagePartInternalName(@NotNull KtFile file) {
         ListIterator<ClassDescriptor> iterator = classStack.listIterator(classStack.size());
         while (iterator.hasPrevious()) {
             ClassDescriptor previous = iterator.previous();
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java
index 966601a20ea..38e45161acd 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.resolve.source.KotlinSourceElementKt;
 import org.jetbrains.kotlin.util.slicedMap.BasicWritableSlice;
 import org.jetbrains.kotlin.util.slicedMap.Slices;
@@ -58,11 +58,11 @@ public class CodegenBinding {
 
     public static final WritableSlice<ClassDescriptor, Collection<ClassDescriptor>> INNER_CLASSES = Slices.createSimpleSlice();
 
-    public static final WritableSlice<JetExpression, SamType> SAM_VALUE = Slices.createSimpleSlice();
+    public static final WritableSlice<KtExpression, SamType> SAM_VALUE = Slices.createSimpleSlice();
 
-    public static final WritableSlice<JetCallElement, JetExpression> SAM_CONSTRUCTOR_TO_ARGUMENT = Slices.createSimpleSlice();
+    public static final WritableSlice<KtCallElement, KtExpression> SAM_CONSTRUCTOR_TO_ARGUMENT = Slices.createSimpleSlice();
 
-    public static final WritableSlice<JetWhenExpression, WhenByEnumsMapping> MAPPING_FOR_WHEN_BY_ENUM = Slices.createSimpleSlice();
+    public static final WritableSlice<KtWhenExpression, WhenByEnumsMapping> MAPPING_FOR_WHEN_BY_ENUM = Slices.createSimpleSlice();
 
     public static final WritableSlice<String, List<WhenByEnumsMapping>> MAPPINGS_FOR_WHENS_BY_ENUM_IN_CLASS_FILE =
             Slices.createSimpleSlice();
@@ -76,12 +76,12 @@ public class CodegenBinding {
 
     public static void initTrace(@NotNull GenerationState state) {
         CodegenAnnotatingVisitor visitor = new CodegenAnnotatingVisitor(state);
-        for (JetFile file : allFilesInPackages(state.getBindingContext(), state.getFiles())) {
+        for (KtFile file : allFilesInPackages(state.getBindingContext(), state.getFiles())) {
             file.accept(visitor);
         }
     }
 
-    public static boolean enumEntryNeedSubclass(BindingContext bindingContext, JetEnumEntry enumEntry) {
+    public static boolean enumEntryNeedSubclass(BindingContext bindingContext, KtEnumEntry enumEntry) {
         return enumEntryNeedSubclass(bindingContext, bindingContext.get(CLASS, enumEntry));
     }
 
@@ -99,7 +99,7 @@ public class CodegenBinding {
 
     // SCRIPT: Generate asmType for script, move to ScriptingUtil
     @NotNull
-    public static Type asmTypeForScriptPsi(BindingContext bindingContext, @NotNull JetScript script) {
+    public static Type asmTypeForScriptPsi(BindingContext bindingContext, @NotNull KtScript script) {
         ScriptDescriptor scriptDescriptor = bindingContext.get(SCRIPT, script);
         if (scriptDescriptor == null) {
             throw new IllegalStateException("Script descriptor not found by PSI " + script);
@@ -117,9 +117,9 @@ public class CodegenBinding {
     }
 
     @NotNull
-    public static Type asmTypeForAnonymousClass(@NotNull BindingContext bindingContext, @NotNull JetElement expression) {
-        if (expression instanceof JetObjectLiteralExpression) {
-            expression = ((JetObjectLiteralExpression) expression).getObjectDeclaration();
+    public static Type asmTypeForAnonymousClass(@NotNull BindingContext bindingContext, @NotNull KtElement expression) {
+        if (expression instanceof KtObjectLiteralExpression) {
+            expression = ((KtObjectLiteralExpression) expression).getObjectDeclaration();
         }
 
         ClassDescriptor descriptor = bindingContext.get(CLASS, expression);
@@ -165,7 +165,7 @@ public class CodegenBinding {
             @NotNull Type asmType,
             @NotNull JvmFileClassesProvider fileClassesManager
     ) {
-        JetElement element = (JetElement) descriptorToDeclaration(classDescriptor);
+        KtElement element = (KtElement) descriptorToDeclaration(classDescriptor);
         assert element != null : "No source element for " + classDescriptor;
 
         MutableClosure closure = new MutableClosure(classDescriptor, enclosing);
@@ -201,7 +201,7 @@ public class CodegenBinding {
     // SCRIPT: register asmType for script, move to ScriptingUtil
     public static void registerClassNameForScript(
             @NotNull BindingTrace trace,
-            @NotNull JetScript script,
+            @NotNull KtScript script,
             @NotNull Type asmType,
             @NotNull JvmFileClassesProvider fileClassesManager
     ) {
@@ -215,7 +215,7 @@ public class CodegenBinding {
                 new ClassDescriptorImpl(descriptor, Name.special("<script-" + simpleName + ">"), Modality.FINAL,
                                         Collections.singleton(DescriptorUtilsKt.getBuiltIns(descriptor).getAnyType()),
                                         KotlinSourceElementKt.toSourceElement(script));
-        classDescriptor.initialize(JetScope.Empty.INSTANCE$, Collections.<ConstructorDescriptor>emptySet(), null);
+        classDescriptor.initialize(KtScope.Empty.INSTANCE$, Collections.<ConstructorDescriptor>emptySet(), null);
 
         recordClosure(trace, classDescriptor, null, asmType, fileClassesManager);
 
@@ -223,39 +223,39 @@ public class CodegenBinding {
     }
 
     @NotNull
-    private static Collection<JetFile> allFilesInPackages(BindingContext bindingContext, Collection<JetFile> files) {
+    private static Collection<KtFile> allFilesInPackages(BindingContext bindingContext, Collection<KtFile> files) {
         // todo: we use Set and add given files but ignoring other scripts because something non-clear kept in binding
         // for scripts especially in case of REPL
 
         // SCRIPT: collect fq names for files that are not scripts
         HashSet<FqName> names = new HashSet<FqName>();
-        for (JetFile file : files) {
+        for (KtFile file : files) {
             if (!file.isScript()) {
                 names.add(file.getPackageFqName());
             }
         }
 
-        HashSet<JetFile> answer = new HashSet<JetFile>();
+        HashSet<KtFile> answer = new HashSet<KtFile>();
         answer.addAll(files);
 
         for (FqName name : names) {
-            Collection<JetFile> jetFiles = bindingContext.get(PACKAGE_TO_FILES, name);
+            Collection<KtFile> jetFiles = bindingContext.get(PACKAGE_TO_FILES, name);
             if (jetFiles != null) {
                 answer.addAll(jetFiles);
             }
         }
 
-        List<JetFile> sortedAnswer = new ArrayList<JetFile>(answer);
-        Collections.sort(sortedAnswer, new Comparator<JetFile>() {
+        List<KtFile> sortedAnswer = new ArrayList<KtFile>(answer);
+        Collections.sort(sortedAnswer, new Comparator<KtFile>() {
             @NotNull
-            private String path(JetFile file) {
+            private String path(KtFile file) {
                 VirtualFile virtualFile = file.getVirtualFile();
                 assert virtualFile != null : "VirtualFile is null for JetFile: " + file.getName();
                 return virtualFile.getPath();
             }
 
             @Override
-            public int compare(@NotNull JetFile first, @NotNull JetFile second) {
+            public int compare(@NotNull KtFile first, @NotNull KtFile second) {
                 return path(first).compareTo(path(second));
             }
         });
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/MutableClosure.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/MutableClosure.java
index ae33343bdea..619781fb836 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/MutableClosure.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/MutableClosure.java
@@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.context.EnclosedValueDescriptor;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.org.objectweb.asm.Type;
 
 import java.util.*;
@@ -71,7 +71,7 @@ public final class MutableClosure implements CalculatedClosure {
     }
 
     @Override
-    public JetType getCaptureReceiverType() {
+    public KtType getCaptureReceiverType() {
         if (captureReceiver) {
             ReceiverParameterDescriptor parameter = getEnclosingReceiverDescriptor();
             assert parameter != null : "Receiver parameter should exist in " + enclosingFunWithReceiverDescriptor;
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/PsiCodegenPredictor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/PsiCodegenPredictor.java
index 43d1c38fb0c..4f89f38c3cc 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/PsiCodegenPredictor.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/PsiCodegenPredictor.java
@@ -40,8 +40,8 @@ public final class PsiCodegenPredictor {
             @NotNull JvmFileClassesProvider fileClassesManager
     ) {
         PsiElement element = descriptorToDeclaration(descriptor);
-        if (element instanceof JetDeclaration) {
-            String classNameFromPsi = getPredefinedJvmInternalName((JetDeclaration) element, fileClassesManager);
+        if (element instanceof KtDeclaration) {
+            String classNameFromPsi = getPredefinedJvmInternalName((KtDeclaration) element, fileClassesManager);
             assert classNameFromPsi == null || Type.getObjectType(classNameFromPsi).equals(nameFromDescriptors) :
                     String.format("Invalid algorithm for getting qualified name from psi! Predicted: %s, actual %s\n" +
                                   "Element: %s", classNameFromPsi, nameFromDescriptors, element.getText());
@@ -55,13 +55,13 @@ public final class PsiCodegenPredictor {
      */
     @Nullable
     public static String getPredefinedJvmInternalName(
-            @NotNull JetDeclaration declaration,
+            @NotNull KtDeclaration declaration,
             @NotNull JvmFileClassesProvider fileClassesProvider
     ) {
         // TODO: Method won't work for declarations inside companion objects
         // TODO: Method won't give correct class name for traits implementations
 
-        JetDeclaration parentDeclaration = JetStubbedPsiUtil.getContainingDeclaration(declaration);
+        KtDeclaration parentDeclaration = KtStubbedPsiUtil.getContainingDeclaration(declaration);
 
         String parentInternalName;
         if (parentDeclaration != null) {
@@ -71,30 +71,30 @@ public final class PsiCodegenPredictor {
             }
         }
         else {
-            JetFile containingFile = declaration.getContainingJetFile();
+            KtFile containingFile = declaration.getContainingJetFile();
 
-            if (declaration instanceof JetNamedFunction) {
-                Name name = ((JetNamedFunction) declaration).getNameAsName();
+            if (declaration instanceof KtNamedFunction) {
+                Name name = ((KtNamedFunction) declaration).getNameAsName();
                 return name == null ? null : FileClasses.getFileClassInternalName(fileClassesProvider, containingFile) + "$" + name.asString();
             }
 
             parentInternalName = AsmUtil.internalNameByFqNameWithoutInnerClasses(containingFile.getPackageFqName());
         }
 
-        if (!PsiTreeUtil.instanceOf(declaration, JetClass.class, JetObjectDeclaration.class, JetNamedFunction.class, JetProperty.class) ||
-                isEnumEntryWithoutBody(declaration)) {
+        if (!PsiTreeUtil.instanceOf(declaration, KtClass.class, KtObjectDeclaration.class, KtNamedFunction.class, KtProperty.class) ||
+            isEnumEntryWithoutBody(declaration)) {
             // Other subclasses are not valid for class name prediction.
             // For example JetFunctionLiteral
             return null;
         }
 
-        Name name = ((JetNamedDeclaration) declaration).getNameAsName();
+        Name name = ((KtNamedDeclaration) declaration).getNameAsName();
         if (name == null) {
             return null;
         }
 
-        if (declaration instanceof JetNamedFunction) {
-            if (!(parentDeclaration instanceof JetClass || parentDeclaration instanceof JetObjectDeclaration)) {
+        if (declaration instanceof KtNamedFunction) {
+            if (!(parentDeclaration instanceof KtClass || parentDeclaration instanceof KtObjectDeclaration)) {
                 // Can't generate predefined name for internal functions
                 return null;
             }
@@ -102,7 +102,7 @@ public final class PsiCodegenPredictor {
 
         // NOTE: looks like a bug - for class in getter of top level property class name will be $propertyName$ClassName but not
         // PackageClassName$propertyName$ClassName
-        if (declaration instanceof JetProperty) {
+        if (declaration instanceof KtProperty) {
             return parentInternalName + "$" + name.asString();
         }
 
@@ -113,11 +113,11 @@ public final class PsiCodegenPredictor {
         return parentInternalName + (parentDeclaration == null ? "/" : "$") + name.asString();
     }
 
-    private static boolean isEnumEntryWithoutBody(JetDeclaration declaration) {
-        if (!(declaration instanceof JetEnumEntry)) {
+    private static boolean isEnumEntryWithoutBody(KtDeclaration declaration) {
+        if (!(declaration instanceof KtEnumEntry)) {
             return false;
         }
-        JetClassBody body = ((JetEnumEntry) declaration).getBody();
+        KtClassBody body = ((KtEnumEntry) declaration).getBody();
         return body == null || body.getDeclarations().size() == 0;
     }
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/builtinSpecialBridges.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/builtinSpecialBridges.kt
index 8d90619eceb..25b0bbcc917 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/builtinSpecialBridges.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/builtinSpecialBridges.kt
@@ -22,10 +22,10 @@ import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature
 import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature.getSpecialSignatureInfo
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
 import org.jetbrains.kotlin.load.java.getOverriddenBuiltinWithDifferentJvmDescriptor
-import org.jetbrains.kotlin.psi.JetCallElement
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetPsiUtil
-import org.jetbrains.kotlin.psi.JetValueArgument
+import org.jetbrains.kotlin.psi.KtCallElement
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtPsiUtil
+import org.jetbrains.kotlin.psi.KtValueArgument
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -145,13 +145,13 @@ private fun needGenerateSpecialBridge(
 }
 
 public fun isValueArgumentForCallToMethodWithTypeCheckBarrier(
-        element: JetElement,
+        element: KtElement,
         bindingContext: BindingContext
 ): Boolean {
 
     val parentCall = element.getParentCall(bindingContext, strict = true) ?: return false
     val argumentExpression = parentCall.valueArguments.singleOrNull()?.getArgumentExpression() ?: return false
-    if (JetPsiUtil.deparenthesize(argumentExpression) !== element) return false
+    if (KtPsiUtil.deparenthesize(argumentExpression) !== element) return false
 
     val candidateDescriptor = parentCall.getResolvedCall(bindingContext)?.candidateDescriptor as CallableMemberDescriptor?
                                 ?: return false
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java
index aba2c4e7599..b4cf30d59c2 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java
@@ -24,13 +24,13 @@ import org.jetbrains.kotlin.codegen.binding.MutableClosure;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetSuperExpression;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtSuperExpression;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.storage.NullableLazyValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.org.objectweb.asm.Type;
 
 import java.util.*;
@@ -181,7 +181,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
     }
 
     @NotNull
-    public PackageContext intoPackagePart(@NotNull PackageFragmentDescriptor descriptor, Type packagePartType, @Nullable JetFile sourceFile) {
+    public PackageContext intoPackagePart(@NotNull PackageFragmentDescriptor descriptor, Type packagePartType, @Nullable KtFile sourceFile) {
         return new PackageContext(descriptor, this, packagePartType, sourceFile);
     }
 
@@ -190,7 +190,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
             @NotNull PackageFragmentDescriptor descriptor,
             @NotNull Type multifileClassType,
             @NotNull Type filePartType,
-            @NotNull JetFile sourceFile
+            @NotNull KtFile sourceFile
     ) {
         return new MultifileClassPartContext(descriptor, this, multifileClassType, filePartType, sourceFile);
     }
@@ -273,7 +273,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
     }
 
     @NotNull
-    public <D extends CallableMemberDescriptor> D getAccessor(@NotNull D descriptor, @Nullable JetSuperExpression superCallExpression) {
+    public <D extends CallableMemberDescriptor> D getAccessor(@NotNull D descriptor, @Nullable KtSuperExpression superCallExpression) {
         return getAccessor(descriptor, false, null, superCallExpression);
     }
 
@@ -282,8 +282,8 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
     public <D extends CallableMemberDescriptor> D getAccessor(
             @NotNull D possiblySubstitutedDescriptor,
             boolean isForBackingFieldInOuterClass,
-            @Nullable JetType delegateType,
-            @Nullable JetSuperExpression superCallExpression
+            @Nullable KtType delegateType,
+            @Nullable KtSuperExpression superCallExpression
     ) {
         if (accessors == null) {
             accessors = new LinkedHashMap<AccessorKey, AccessorForCallableDescriptor<?>>();
@@ -379,7 +379,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
     @NotNull
     public <D extends CallableMemberDescriptor> D accessibleDescriptor(
             @NotNull D descriptor,
-            @Nullable JetSuperExpression superCallExpression
+            @Nullable KtSuperExpression superCallExpression
     ) {
         DeclarationDescriptor enclosing = descriptor.getContainingDeclaration();
         if (!isInlineMethodContext() && (
@@ -417,7 +417,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
     @NotNull
     private <D extends CallableMemberDescriptor> D accessibleDescriptorIfNeeded(
             @NotNull D descriptor,
-            @Nullable JetSuperExpression superCallExpression
+            @Nullable KtSuperExpression superCallExpression
     ) {
         CallableMemberDescriptor unwrappedDescriptor = DescriptorUtils.unwrapFakeOverride(descriptor);
         int flag = getAccessFlags(unwrappedDescriptor);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/FacadePartWithSourceFile.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/FacadePartWithSourceFile.java
index 412799db0e6..531d3cf97a2 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/FacadePartWithSourceFile.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/FacadePartWithSourceFile.java
@@ -17,10 +17,10 @@
 package org.jetbrains.kotlin.codegen.context;
 
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 
 public interface FacadePartWithSourceFile {
 
     @Nullable
-    JetFile getSourceFile();
+    KtFile getSourceFile();
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/LocalLookup.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/LocalLookup.java
index 8f1413c69c4..8dbda7e6377 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/LocalLookup.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/LocalLookup.java
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.org.objectweb.asm.Type;
 
 import static org.jetbrains.kotlin.codegen.AsmUtil.CAPTURED_RECEIVER_FIELD;
@@ -139,7 +139,7 @@ public interface LocalLookup {
                     return null;
                 }
 
-                JetType receiverType = closure.getEnclosingReceiverDescriptor().getType();
+                KtType receiverType = closure.getEnclosingReceiverDescriptor().getType();
                 Type type = state.getTypeMapper().mapType(receiverType);
                 StackValue.StackValueWithSimpleReceiver innerValue = StackValue.field(type, classType, CAPTURED_RECEIVER_FIELD, false,
                                                                                       StackValue.LOCAL_0, d);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/MultifileClassPartContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/MultifileClassPartContext.java
index cac52194dcd..87ac6b61cb6 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/MultifileClassPartContext.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/MultifileClassPartContext.java
@@ -19,18 +19,18 @@ package org.jetbrains.kotlin.codegen.context;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.org.objectweb.asm.Type;
 
 public class MultifileClassPartContext extends MultifileClassContextBase implements DelegatingToPartContext, FacadePartWithSourceFile {
-    private final JetFile sourceFile;
+    private final KtFile sourceFile;
 
     public MultifileClassPartContext(
             PackageFragmentDescriptor descriptor,
             CodegenContext parent,
             Type multifileClassType,
             Type filePartType,
-            @NotNull JetFile sourceFile
+            @NotNull KtFile sourceFile
     ) {
         super(descriptor, parent, multifileClassType, filePartType);
         this.sourceFile = sourceFile;
@@ -44,7 +44,7 @@ public class MultifileClassPartContext extends MultifileClassContextBase impleme
 
     @NotNull
     @Override
-    public JetFile getSourceFile() {
+    public KtFile getSourceFile() {
         return sourceFile;
     }
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/PackageContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/PackageContext.java
index 710fe1faeb2..fa909492855 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/PackageContext.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/PackageContext.java
@@ -20,18 +20,18 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.OwnerKind;
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.org.objectweb.asm.Type;
 
 public class PackageContext extends FieldOwnerContext<PackageFragmentDescriptor> implements DelegatingToPartContext, FacadePartWithSourceFile {
     private final Type packagePartType;
-    @Nullable private JetFile sourceFile;
+    @Nullable private KtFile sourceFile;
 
     public PackageContext(
             @NotNull PackageFragmentDescriptor contextDescriptor,
             @NotNull CodegenContext parent,
             @Nullable Type packagePartType,
-            @Nullable JetFile sourceFile
+            @Nullable KtFile sourceFile
     ) {
         super(contextDescriptor, OwnerKind.PACKAGE, parent, null, null, null);
         this.packagePartType = packagePartType;
@@ -56,7 +56,7 @@ public class PackageContext extends FieldOwnerContext<PackageFragmentDescriptor>
 
     @Nullable
     @Override
-    public JetFile getSourceFile() {
+    public KtFile getSourceFile() {
         return sourceFile;
     }
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/extensions/ExpressionCodegenExtension.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/extensions/ExpressionCodegenExtension.kt
index ffb254ad6a6..0ae88696f99 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/extensions/ExpressionCodegenExtension.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/extensions/ExpressionCodegenExtension.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.codegen.StackValue
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.codegen.ClassBuilder
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.resolve.*
 
@@ -50,7 +50,7 @@ public interface ExpressionCodegenExtension {
     public fun generateClassSyntheticParts(
             classBuilder: ClassBuilder,
             state: GenerationState,
-            classOrObject: JetClassOrObject,
+            classOrObject: KtClassOrObject,
             descriptor: ClassDescriptor
     ) {}
 }
\ No newline at end of file
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java
index 26421fe9988..25292c6d41c 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java
@@ -73,7 +73,7 @@ public class InlineCodegen extends CallGenerator {
 
     private final SimpleFunctionDescriptor functionDescriptor;
     private final JvmMethodSignature jvmSignature;
-    private final JetElement callElement;
+    private final KtElement callElement;
     private final MethodContext context;
     private final ExpressionCodegen codegen;
 
@@ -94,7 +94,7 @@ public class InlineCodegen extends CallGenerator {
             @NotNull ExpressionCodegen codegen,
             @NotNull GenerationState state,
             @NotNull SimpleFunctionDescriptor functionDescriptor,
-            @NotNull JetElement callElement,
+            @NotNull KtElement callElement,
             @Nullable ReifiedTypeParameterMappings typeParameterMappings
     ) {
         assert InlineUtil.isInline(functionDescriptor) : "InlineCodegen could inline only inline function: " + functionDescriptor;
@@ -110,7 +110,7 @@ public class InlineCodegen extends CallGenerator {
         initialFrameSize = codegen.getFrameMap().getCurrentSize();
 
         PsiElement element = DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor);
-        context = (MethodContext) getContext(functionDescriptor, state, element != null ? (JetFile) element.getContainingFile() : null);
+        context = (MethodContext) getContext(functionDescriptor, state, element != null ? (KtFile) element.getContainingFile() : null);
         jvmSignature = typeMapper.mapSignature(functionDescriptor, context.getContextKind());
 
         // TODO: implement AS_FUNCTION inline strategy
@@ -205,10 +205,10 @@ public class InlineCodegen extends CallGenerator {
         else {
             PsiElement element = DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor);
 
-            if (element == null || !(element instanceof JetNamedFunction)) {
+            if (element == null || !(element instanceof KtNamedFunction)) {
                 throw new RuntimeException("Couldn't find declaration for function " + descriptorName(functionDescriptor));
             }
-            JetNamedFunction inliningFunction = (JetNamedFunction) element;
+            KtNamedFunction inliningFunction = (KtNamedFunction) element;
 
             MethodNode node = new MethodNode(InlineCodegenUtil.API,
                                            getMethodAsmFlags(functionDescriptor, context.getContextKind()) | (callDefault ? Opcodes.ACC_STATIC : 0),
@@ -305,7 +305,7 @@ public class InlineCodegen extends CallGenerator {
     }
 
     private SMAPAndMethodNode generateLambdaBody(LambdaInfo info) {
-        JetExpression declaration = info.getFunctionWithBodyOrCallableReference();
+        KtExpression declaration = info.getFunctionWithBodyOrCallableReference();
         FunctionDescriptor descriptor = info.getFunctionDescriptor();
 
         MethodContext parentContext = codegen.getContext();
@@ -327,7 +327,7 @@ public class InlineCodegen extends CallGenerator {
             @NotNull MethodVisitor adapter,
             @NotNull FunctionDescriptor descriptor,
             @NotNull MethodContext context,
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             @NotNull JvmMethodSignature jvmMethodSignature,
             boolean isLambda
     ) {
@@ -338,14 +338,14 @@ public class InlineCodegen extends CallGenerator {
                                                : typeMapper.mapOwner(descriptor).getInternalName());
 
         FunctionGenerationStrategy strategy =
-                expression instanceof JetCallableReferenceExpression ?
+                expression instanceof KtCallableReferenceExpression ?
                 new FunctionReferenceGenerationStrategy(
                         state,
                         descriptor,
-                        CallUtilKt.getResolvedCallWithAssert(((JetCallableReferenceExpression) expression).getCallableReference(),
+                        CallUtilKt.getResolvedCallWithAssert(((KtCallableReferenceExpression) expression).getCallableReference(),
                                                              codegen.getBindingContext()
                         )) :
-                new FunctionGenerationStrategy.FunctionDefault(state, descriptor, (JetDeclarationWithBody) expression);
+                new FunctionGenerationStrategy.FunctionDefault(state, descriptor, (KtDeclarationWithBody) expression);
 
         FunctionCodegen.generateMethodBody(
                 adapter, descriptor, context, jvmMethodSignature,
@@ -358,7 +358,7 @@ public class InlineCodegen extends CallGenerator {
     }
 
     private static SMAP createSMAPWithDefaultMapping(
-            @NotNull JetExpression declaration,
+            @NotNull KtExpression declaration,
             @NotNull List<FileMapping> mappings
     ) {
         PsiFile containingFile = declaration.getContainingFile();
@@ -373,7 +373,7 @@ public class InlineCodegen extends CallGenerator {
         private final MemberCodegen delegate;
         @NotNull private final String className;
 
-        public FakeMemberCodegen(@NotNull MemberCodegen wrapped, @NotNull JetElement declaration, @NotNull FieldOwnerContext codegenContext, @NotNull String className) {
+        public FakeMemberCodegen(@NotNull MemberCodegen wrapped, @NotNull KtElement declaration, @NotNull FieldOwnerContext codegenContext, @NotNull String className) {
             super(wrapped, declaration, codegenContext);
             delegate = wrapped;
             this.className = className;
@@ -535,21 +535,21 @@ public class InlineCodegen extends CallGenerator {
     }
 
     /*lambda or callable reference*/
-    public static boolean isInliningParameter(JetExpression expression, ValueParameterDescriptor valueParameterDescriptor) {
+    public static boolean isInliningParameter(KtExpression expression, ValueParameterDescriptor valueParameterDescriptor) {
         //TODO deparenthisise typed
-        JetExpression deparenthesized = JetPsiUtil.deparenthesize(expression);
+        KtExpression deparenthesized = KtPsiUtil.deparenthesize(expression);
         return InlineUtil.isInlineLambdaParameter(valueParameterDescriptor) &&
                isInlinableParameterExpression(deparenthesized);
     }
 
-    protected static boolean isInlinableParameterExpression(JetExpression deparenthesized) {
-        return deparenthesized instanceof JetFunctionLiteralExpression ||
-               deparenthesized instanceof JetNamedFunction ||
-               deparenthesized instanceof JetCallableReferenceExpression;
+    protected static boolean isInlinableParameterExpression(KtExpression deparenthesized) {
+        return deparenthesized instanceof KtFunctionLiteralExpression ||
+               deparenthesized instanceof KtNamedFunction ||
+               deparenthesized instanceof KtCallableReferenceExpression;
     }
 
-    public void rememberClosure(JetExpression expression, Type type, int parameterIndex) {
-        JetExpression lambda = JetPsiUtil.deparenthesize(expression);
+    public void rememberClosure(KtExpression expression, Type type, int parameterIndex) {
+        KtExpression lambda = KtPsiUtil.deparenthesize(expression);
         assert isInlinableParameterExpression(lambda) : "Couldn't find inline expression in " + expression.getText();
 
         LambdaInfo info = new LambdaInfo(lambda, typeMapper);
@@ -587,7 +587,7 @@ public class InlineCodegen extends CallGenerator {
         activeLambda = null;
     }
 
-    public static CodegenContext getContext(@NotNull DeclarationDescriptor descriptor, @NotNull GenerationState state, @Nullable JetFile sourceFile) {
+    public static CodegenContext getContext(@NotNull DeclarationDescriptor descriptor, @NotNull GenerationState state, @Nullable KtFile sourceFile) {
         if (descriptor instanceof PackageFragmentDescriptor) {
             return new PackageContext((PackageFragmentDescriptor) descriptor, state.getRootContext(), null, sourceFile);
         }
@@ -624,7 +624,7 @@ public class InlineCodegen extends CallGenerator {
     @Override
     public void genValueAndPut(
             @NotNull ValueParameterDescriptor valueParameterDescriptor,
-            @NotNull JetExpression argumentExpression,
+            @NotNull KtExpression argumentExpression,
             @NotNull Type parameterType,
             int parameterIndex
     ) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java
index 572290afe81..c115d3c39b9 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java
@@ -37,17 +37,13 @@ import org.jetbrains.kotlin.fileClasses.FileClasses;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.kotlin.JvmVirtualFileFinder;
-import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.name.ClassId;
 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.DescriptorToSourceUtils;
-import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes;
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
-import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
 import org.jetbrains.org.objectweb.asm.*;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
@@ -60,9 +56,6 @@ import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.util.ListIterator;
 
-import static org.jetbrains.kotlin.resolve.DescriptorUtils.getFqName;
-import static org.jetbrains.kotlin.resolve.DescriptorUtils.isInterface;
-
 public class InlineCodegenUtil {
     public static final boolean GENERATE_SMAP = true;
     public static final int API = Opcodes.ASM5;
@@ -185,7 +178,7 @@ public class InlineCodegenUtil {
             if (file == null) {
                 implementationOwnerType = CodegenContextUtil.getImplementationOwnerClassType(codegenContext);
             } else {
-                implementationOwnerType = FileClasses.getFileClassType(fileClassesProvider, (JetFile) file);
+                implementationOwnerType = FileClasses.getFileClassType(fileClassesProvider, (KtFile) file);
             }
 
             if (implementationOwnerType == null) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java
index 91cc92f1967..06a44169673 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java
@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.codegen.context.EnclosedValueDescriptor;
 import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetFunctionLiteralExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtFunctionLiteralExpression;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
@@ -41,7 +41,7 @@ import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.*;
 
 public class LambdaInfo implements CapturedParamOwner, LabelOwner {
 
-    public final JetExpression expression;
+    public final KtExpression expression;
 
     private final JetTypeMapper typeMapper;
 
@@ -60,9 +60,9 @@ public class LambdaInfo implements CapturedParamOwner, LabelOwner {
 
     private final Type closureClassType;
 
-    LambdaInfo(@NotNull JetExpression expr, @NotNull JetTypeMapper typeMapper) {
-        this.expression = expr instanceof JetFunctionLiteralExpression ?
-                          ((JetFunctionLiteralExpression) expr).getFunctionLiteral() : expr;
+    LambdaInfo(@NotNull KtExpression expr, @NotNull JetTypeMapper typeMapper) {
+        this.expression = expr instanceof KtFunctionLiteralExpression ?
+                          ((KtFunctionLiteralExpression) expr).getFunctionLiteral() : expr;
 
         this.typeMapper = typeMapper;
         BindingContext bindingContext = typeMapper.getBindingContext();
@@ -91,7 +91,7 @@ public class LambdaInfo implements CapturedParamOwner, LabelOwner {
         return functionDescriptor;
     }
 
-    public JetExpression getFunctionWithBodyOrCallableReference() {
+    public KtExpression getFunctionWithBodyOrCallableReference() {
         return expression;
     }
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ReifiedTypeInliner.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ReifiedTypeInliner.kt
index 221035d4acd..16d0bc33e98 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ReifiedTypeInliner.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ReifiedTypeInliner.kt
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.codegen.context.MethodContext
 import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods
 import org.jetbrains.kotlin.codegen.intrinsics.TypeIntrinsics
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.org.objectweb.asm.MethodVisitor
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
@@ -159,14 +159,14 @@ public class ReifiedTypeInliner(private val parametersMapping: ReifiedTypeParame
     private fun processNewArray(insn: MethodInsnNode, parameter: Type) =
             processNextTypeInsn(insn, parameter, Opcodes.ANEWARRAY)
 
-    private fun processCheckcast(insn: MethodInsnNode, instructions: InsnList, jetType: JetType, asmType: Type, safe: Boolean) =
+    private fun processCheckcast(insn: MethodInsnNode, instructions: InsnList, jetType: KtType, asmType: Type, safe: Boolean) =
             rewriteNextTypeInsn(insn, Opcodes.CHECKCAST) { instanceofInsn: AbstractInsnNode ->
                 if (instanceofInsn !is TypeInsnNode) return false
                 TypeIntrinsics.checkcast(instanceofInsn, instructions, jetType, asmType, safe)
                 return true
             }
 
-    private fun processInstanceof(insn: MethodInsnNode, instructions: InsnList, jetType: JetType, asmType: Type) =
+    private fun processInstanceof(insn: MethodInsnNode, instructions: InsnList, jetType: KtType, asmType: Type) =
             rewriteNextTypeInsn(insn, Opcodes.INSTANCEOF) { instanceofInsn: AbstractInsnNode ->
                 if (instanceofInsn !is TypeInsnNode) return false
                 TypeIntrinsics.instanceOf(instanceofInsn, instructions, jetType, asmType)
@@ -213,7 +213,7 @@ public class ReifiedTypeInliner(private val parametersMapping: ReifiedTypeParame
 public class ReifiedTypeParameterMappings() {
     private val mappingsByName = hashMapOf<String, ReifiedTypeParameterMapping>()
 
-    public fun addParameterMappingToType(name: String, type: JetType, asmType: Type, signature: String) {
+    public fun addParameterMappingToType(name: String, type: KtType, asmType: Type, signature: String) {
         mappingsByName[name] =  ReifiedTypeParameterMapping(name, type, asmType, newName = null, signature = signature)
     }
 
@@ -227,7 +227,7 @@ public class ReifiedTypeParameterMappings() {
 }
 
 public class ReifiedTypeParameterMapping(
-        val name: String, val type: JetType?, val asmType: Type?, val newName: String?, val signature: String?
+        val name: String, val type: KtType?, val asmType: Type?, val newName: String?, val signature: String?
 )
 
 public class ReifiedTypeParametersUsages {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RootInliningContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RootInliningContext.java
index b75f9f8aa67..f3e62022047 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RootInliningContext.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RootInliningContext.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.codegen.inline;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.context.CodegenContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.psi.JetElement;
+import org.jetbrains.kotlin.psi.KtElement;
 
 import java.util.Collections;
 import java.util.Map;
@@ -27,14 +27,14 @@ import java.util.Map;
 public class RootInliningContext extends InliningContext {
     public final CodegenContext startContext;
     private final String classNameToInline;
-    public final JetElement callElement;
+    public final KtElement callElement;
 
     public RootInliningContext(
             @NotNull Map<Integer, LambdaInfo> map,
             @NotNull GenerationState state,
             @NotNull NameGenerator nameGenerator,
             @NotNull CodegenContext startContext,
-            @NotNull JetElement callElement,
+            @NotNull KtElement callElement,
             @NotNull String classNameToInline,
             @NotNull ReifiedTypeInliner inliner
     ) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/Concat.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/Concat.kt
index 6f46ccd7aa6..182c6c5cd02 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/Concat.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/Concat.kt
@@ -23,9 +23,9 @@ import org.jetbrains.kotlin.codegen.Callable
 import org.jetbrains.kotlin.codegen.CallableMethod
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.JAVA_STRING_TYPE
@@ -38,10 +38,10 @@ public class Concat : IntrinsicMethod() {
             v: InstructionAdapter,
             returnType: Type,
             element: PsiElement?,
-            arguments: List<JetExpression>,
+            arguments: List<KtExpression>,
             receiver: StackValue
     ): Type {
-        if (element is JetBinaryExpression && element.getOperationReference().getReferencedNameElementType() == JetTokens.PLUS) {
+        if (element is KtBinaryExpression && element.getOperationReference().getReferencedNameElementType() == KtTokens.PLUS) {
             // LHS + RHS
             genStringBuilderConstructor(v)
             codegen.invokeAppend(element.getLeft())
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IdentityEquals.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IdentityEquals.kt
index 6d54fe1cb44..7fed3f13b64 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IdentityEquals.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IdentityEquals.kt
@@ -20,9 +20,9 @@ import org.jetbrains.kotlin.codegen.Callable
 import org.jetbrains.kotlin.codegen.CallableMethod
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetCallExpression
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtCallExpression
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE
 
@@ -37,16 +37,16 @@ public class IdentityEquals : IntrinsicMethod() {
                     val element = resolvedCall.getCall().getCallElement()
                     val left: StackValue
                     val right: StackValue
-                    if (element is JetCallExpression) {
+                    if (element is KtCallExpression) {
                         left = StackValue.receiver(resolvedCall, receiver, codegen, this)
                         right = codegen.gen(resolvedCall.getValueArgumentsByIndex()!!.single().getArguments().single().getArgumentExpression())
                     }
                     else {
-                        element as JetBinaryExpression
+                        element as KtBinaryExpression
                         left = codegen.gen(element.getLeft())
                         right = codegen.gen(element.getRight())
                     }
-                    return StackValue.cmp(JetTokens.EQEQEQ, OBJECT_TYPE, left, right)
+                    return StackValue.cmp(KtTokens.EQEQEQ, OBJECT_TYPE, left, right)
                 }
             }
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/Increment.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/Increment.kt
index 018b4a0a39b..566f640de35 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/Increment.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/Increment.kt
@@ -19,14 +19,14 @@ package org.jetbrains.kotlin.codegen.intrinsics
 import org.jetbrains.kotlin.codegen.AsmUtil.genIncrement
 import org.jetbrains.kotlin.codegen.Callable
 import org.jetbrains.kotlin.codegen.CallableMethod
-import org.jetbrains.kotlin.psi.JetPrefixExpression
+import org.jetbrains.kotlin.psi.KtPrefixExpression
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 
 public class Increment(private val myDelta: Int) : IntrinsicMethod() {
     override fun toCallable(method: CallableMethod, isSuper: Boolean, resolvedCall: ResolvedCall<*>): Callable =
             createIntrinsicCallable(method) {
                 val jetExpression = resolvedCall.getCall().getCalleeExpression()
-                assert(jetExpression !is JetPrefixExpression) { "There should be postfix increment ${jetExpression!!.getText()}" }
+                assert(jetExpression !is KtPrefixExpression) { "There should be postfix increment ${jetExpression!!.getText()}" }
                 genIncrement(returnType, myDelta, it)
             }
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/KClassJavaProperty.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/KClassJavaProperty.kt
index dfd43fbf695..85874db0e71 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/KClassJavaProperty.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/KClassJavaProperty.kt
@@ -21,11 +21,11 @@ import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue
 import org.jetbrains.kotlin.codegen.inline.ReifiedTypeInliner
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.psi.JetClassLiteralExpression
+import org.jetbrains.kotlin.psi.KtClassLiteralExpression
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 
@@ -57,14 +57,14 @@ public class KClassJavaProperty : IntrinsicPropertyGetter() {
         }
     }
 
-    private fun isReifiedTypeParameter(type: JetType): Boolean {
+    private fun isReifiedTypeParameter(type: KtType): Boolean {
         val typeDescriptor = type.constructor.declarationDescriptor
         return typeDescriptor is TypeParameterDescriptor && typeDescriptor.isReified
     }
 
     private fun isWithClassLiteralArgument(resolvedCall: ResolvedCall<*>): Boolean {
         val extensionReceiver = resolvedCall.extensionReceiver
-        return extensionReceiver is ExpressionReceiver && extensionReceiver.expression is JetClassLiteralExpression
+        return extensionReceiver is ExpressionReceiver && extensionReceiver.expression is KtClassLiteralExpression
     }
 
     private fun coerceToJavaLangClass(iv: InstructionAdapter, returnType: Type) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/Not.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/Not.kt
index 570be840505..b6812e9ab60 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/Not.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/Not.kt
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.codegen.Callable
 import org.jetbrains.kotlin.codegen.CallableMethod
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue
-import org.jetbrains.kotlin.psi.JetPrefixExpression
+import org.jetbrains.kotlin.psi.KtPrefixExpression
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 
 public class Not : IntrinsicMethod() {
@@ -33,7 +33,7 @@ public class Not : IntrinsicMethod() {
                 ): StackValue {
                     val element = resolvedCall.getCall().getCallElement()
                     val stackValue =
-                            if (element is JetPrefixExpression) {
+                            if (element is KtPrefixExpression) {
                                 codegen.gen(element.getBaseExpression())
                             }
                             else {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/TypeIntrinsics.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/TypeIntrinsics.kt
index b70cadea1cb..47e84639cb3 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/TypeIntrinsics.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/TypeIntrinsics.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.codegen.intrinsics
 
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
@@ -26,7 +26,7 @@ import org.jetbrains.org.objectweb.asm.tree.*
 import kotlin.text.Regex
 
 public object TypeIntrinsics {
-    public @JvmStatic fun instanceOf(v: InstructionAdapter, jetType: JetType, boxedAsmType: Type) {
+    public @JvmStatic fun instanceOf(v: InstructionAdapter, jetType: KtType, boxedAsmType: Type) {
         val functionTypeArity = getFunctionTypeArity(jetType)
         if (functionTypeArity >= 0) {
             v.iconst(functionTypeArity)
@@ -57,7 +57,7 @@ public object TypeIntrinsics {
                 LdcInsnNode(Integer(value))
             }
 
-    public @JvmStatic fun instanceOf(instanceofInsn: TypeInsnNode, instructions: InsnList, jetType: JetType, asmType: Type) {
+    public @JvmStatic fun instanceOf(instanceofInsn: TypeInsnNode, instructions: InsnList, jetType: KtType, asmType: Type) {
         val functionTypeArity = getFunctionTypeArity(jetType)
         if (functionTypeArity >= 0) {
             instructions.insertBefore(instanceofInsn, iconstNode(functionTypeArity))
@@ -78,7 +78,7 @@ public object TypeIntrinsics {
         instanceofInsn.desc = asmType.internalName
     }
 
-    public @JvmStatic fun checkcast(v: InstructionAdapter, jetType: JetType, asmType: Type, safe: Boolean) {
+    public @JvmStatic fun checkcast(v: InstructionAdapter, jetType: KtType, asmType: Type, safe: Boolean) {
         if (safe) {
             v.checkcast(asmType)
             return
@@ -106,7 +106,7 @@ public object TypeIntrinsics {
         v.checkcast(asmType)
     }
 
-    public @JvmStatic fun checkcast(checkcastInsn: TypeInsnNode, instructions: InsnList, jetType: JetType, asmType: Type, safe: Boolean) {
+    public @JvmStatic fun checkcast(checkcastInsn: TypeInsnNode, instructions: InsnList, jetType: KtType, asmType: Type, safe: Boolean) {
         if (safe) {
             checkcastInsn.desc = asmType.internalName
             return
@@ -159,7 +159,7 @@ public object TypeIntrinsics {
     private val IS_MUTABLE_COLLECTION_METHOD_DESCRIPTOR =
             Type.getMethodDescriptor(Type.BOOLEAN_TYPE, Type.getObjectType("java/lang/Object"))
 
-    private fun getClassFqName(jetType: JetType): String? {
+    private fun getClassFqName(jetType: KtType): String? {
         val classDescriptor = TypeUtils.getClassDescriptor(jetType) ?: return null
         return DescriptorUtils.getFqName(classDescriptor).asString()
     }
@@ -169,7 +169,7 @@ public object TypeIntrinsics {
     /**
      * @return function type arity (non-negative), or -1 if the given type is not a function type
      */
-    private fun getFunctionTypeArity(jetType: JetType): Int {
+    private fun getFunctionTypeArity(jetType: KtType): Int {
         val classFqName = getClassFqName(jetType) ?: return -1
         val match = KOTLIN_FUNCTION_INTERFACE_REGEX.match(classFqName) ?: return -1
         return Integer.valueOf(match.groups[1]!!.value)
@@ -182,7 +182,7 @@ public object TypeIntrinsics {
         invokestatic(INTRINSICS_CLASS, methodName, methodDescriptor, false)
     }
 
-    private fun getIsMutableCollectionMethodName(jetType: JetType): String? =
+    private fun getIsMutableCollectionMethodName(jetType: KtType): String? =
             IS_MUTABLE_COLLECTION_METHOD_NAME[getClassFqName(jetType)]
 
     private val CHECKCAST_METHOD_NAME = hashMapOf(
@@ -196,7 +196,7 @@ public object TypeIntrinsics {
             "kotlin.MutableMap.MutableEntry" to "asMutableMapEntry"
     )
 
-    private fun getAsMutableCollectionMethodName(jetType: JetType): String? {
+    private fun getAsMutableCollectionMethodName(jetType: KtType): String? {
         val classDescriptor = TypeUtils.getClassDescriptor(jetType) ?: return null
         val classFqName = DescriptorUtils.getFqName(classDescriptor).asString()
         return CHECKCAST_METHOD_NAME[classFqName]
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.java
index ef050346d9e..bb20af8aabc 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.java
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.serialization.SerializerExtension;
 import org.jetbrains.kotlin.serialization.StringTable;
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf;
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.org.objectweb.asm.commons.Method;
 
@@ -70,7 +70,7 @@ public class JvmSerializerExtension extends SerializerExtension {
     }
 
     @Override
-    public void serializeType(@NotNull JetType type, @NotNull ProtoBuf.Type.Builder proto) {
+    public void serializeType(@NotNull KtType type, @NotNull ProtoBuf.Type.Builder proto) {
         // TODO: don't store type annotations in our binary metadata on Java 8, use *TypeAnnotations attributes instead
         for (AnnotationDescriptor annotation : type.getAnnotations()) {
             proto.addExtension(JvmProtoBuf.typeAnnotation, annotationSerializer.serializeAnnotation(annotation));
@@ -200,7 +200,7 @@ public class JvmSerializerExtension extends SerializerExtension {
 
             sb.append(")");
 
-            JetType returnType = descriptor.getReturnType();
+            KtType returnType = descriptor.getReturnType();
             String returnTypeDesc = returnType == null ? "V" : mapTypeDefault(returnType);
             if (returnTypeDesc == null) return true;
             sb.append(returnTypeDesc);
@@ -213,7 +213,7 @@ public class JvmSerializerExtension extends SerializerExtension {
         }
 
         @Nullable
-        private String mapTypeDefault(@NotNull JetType type) {
+        private String mapTypeDefault(@NotNull KtType type) {
             ClassifierDescriptor classifier = type.getConstructor().getDeclarationDescriptor();
             if (!(classifier instanceof ClassDescriptor)) return null;
             ClassId classId = classId((ClassDescriptor) classifier);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt
index 63cef67adaa..d7264c1af6a 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.idea.MainFunctionDetector
 import org.jetbrains.kotlin.load.java.descriptors.SamAdapterDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.getParentJavaStaticClassScope
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.*
@@ -71,7 +71,7 @@ class BuilderFactoryForDuplicateSignatureDiagnostics(
                 var element = origin.element
 
                 // TODO Remove this code after dropping package facades
-                if (element is JetNamedFunction && mainFunctionDetector.isMain(element) && !element.isInsideJvmMultifileClassFile()) return
+                if (element is KtNamedFunction && mainFunctionDetector.isMain(element) && !element.isInsideJvmMultifileClassFile()) return
 
                 if (element == null || origin.originKind in EXTERNAL_SOURCES_KINDS) {
                     element = data.classOrigin.element
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt
index 9f5cda47f2c..3b2d2db6df3 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt
@@ -32,9 +32,9 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
 import org.jetbrains.kotlin.modules.TargetId
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetScript
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtScript
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
@@ -45,7 +45,7 @@ public class GenerationState @JvmOverloads constructor(
         builderFactory: ClassBuilderFactory,
         public val module: ModuleDescriptor,
         bindingContext: BindingContext,
-        public val files: List<JetFile>,
+        public val files: List<KtFile>,
         disableCallAssertions: Boolean = true,
         disableParamAssertions: Boolean = true,
         public val generateDeclaredClassFilter: GenerationState.GenerateClassFilter = GenerationState.GenerateClassFilter.GENERATE_ALL,
@@ -66,20 +66,20 @@ public class GenerationState @JvmOverloads constructor(
         public val progress: Progress = Progress.DEAF
 ) {
     public abstract class GenerateClassFilter {
-        public abstract fun shouldAnnotateClass(classOrObject: JetClassOrObject): Boolean
-        public abstract fun shouldGenerateClass(classOrObject: JetClassOrObject): Boolean
-        public abstract fun shouldGeneratePackagePart(jetFile: JetFile): Boolean
-        public abstract fun shouldGenerateScript(script: JetScript): Boolean
+        public abstract fun shouldAnnotateClass(classOrObject: KtClassOrObject): Boolean
+        public abstract fun shouldGenerateClass(classOrObject: KtClassOrObject): Boolean
+        public abstract fun shouldGeneratePackagePart(jetFile: KtFile): Boolean
+        public abstract fun shouldGenerateScript(script: KtScript): Boolean
 
         companion object {
             public val GENERATE_ALL: GenerateClassFilter = object : GenerateClassFilter() {
-                override fun shouldAnnotateClass(classOrObject: JetClassOrObject): Boolean = true
+                override fun shouldAnnotateClass(classOrObject: KtClassOrObject): Boolean = true
 
-                override fun shouldGenerateClass(classOrObject: JetClassOrObject): Boolean = true
+                override fun shouldGenerateClass(classOrObject: KtClassOrObject): Boolean = true
 
-                override fun shouldGenerateScript(script: JetScript): Boolean = true
+                override fun shouldGenerateScript(script: KtScript): Boolean = true
 
-                override fun shouldGeneratePackagePart(jetFile: JetFile): Boolean = true
+                override fun shouldGeneratePackagePart(jetFile: KtFile): Boolean = true
             }
         }
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java
index 747088f3657..008091d18e8 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java
@@ -42,15 +42,14 @@ import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature.
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor;
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor;
 import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaPackageScope;
-import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackageFragmentProvider;
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache;
 import org.jetbrains.kotlin.name.*;
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetFunctionLiteral;
-import org.jetbrains.kotlin.psi.JetFunctionLiteralExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtFunctionLiteral;
+import org.jetbrains.kotlin.psi.KtFunctionLiteralExpression;
 import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument;
@@ -64,7 +63,7 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
 import org.jetbrains.kotlin.resolve.scopes.AbstractScopeAdapter;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.serialization.deserialization.DeserializedType;
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor;
 import org.jetbrains.kotlin.types.*;
@@ -182,7 +181,7 @@ public class JetTypeMapper {
         if (isAccessor) {
             descriptor = ((AccessorForCallableDescriptor) descriptor).getCalleeDescriptor();
         }
-        JetFile file = DescriptorToSourceUtils.getContainingFile(descriptor);
+        KtFile file = DescriptorToSourceUtils.getContainingFile(descriptor);
         if (file != null) {
             Visibility visibility = descriptor.getVisibility();
             if (!publicFacade ||
@@ -307,7 +306,7 @@ public class JetTypeMapper {
 
         String facadeSimpleName;
 
-        JetScope scope = packageFragmentDescriptor.getMemberScope();
+        KtScope scope = packageFragmentDescriptor.getMemberScope();
         if (scope instanceof AbstractScopeAdapter) {
             scope = ((AbstractScopeAdapter) scope).getActualScope();
         }
@@ -343,7 +342,7 @@ public class JetTypeMapper {
 
     @NotNull
     private Type mapReturnType(@NotNull CallableDescriptor descriptor, @Nullable BothSignatureWriter sw) {
-        JetType returnType = descriptor.getReturnType();
+        KtType returnType = descriptor.getReturnType();
         assert returnType != null : "Function has no return type: " + descriptor;
 
         if (descriptor instanceof ConstructorDescriptor) {
@@ -371,17 +370,17 @@ public class JetTypeMapper {
     }
 
     @NotNull
-    private Type mapType(@NotNull JetType jetType, @NotNull JetTypeMapperMode mode) {
+    private Type mapType(@NotNull KtType jetType, @NotNull JetTypeMapperMode mode) {
         return mapType(jetType, null, mode);
     }
 
     @NotNull
-    public Type mapSupertype(@NotNull JetType jetType, @Nullable BothSignatureWriter signatureVisitor) {
+    public Type mapSupertype(@NotNull KtType jetType, @Nullable BothSignatureWriter signatureVisitor) {
         return mapType(jetType, signatureVisitor, JetTypeMapperMode.SUPER_TYPE);
     }
 
     @NotNull
-    public Type mapTypeParameter(@NotNull JetType jetType, @Nullable BothSignatureWriter signatureVisitor) {
+    public Type mapTypeParameter(@NotNull KtType jetType, @Nullable BothSignatureWriter signatureVisitor) {
         return mapType(jetType, signatureVisitor, JetTypeMapperMode.TYPE_PARAMETER);
     }
 
@@ -391,7 +390,7 @@ public class JetTypeMapper {
     }
 
     @NotNull
-    public Type mapType(@NotNull JetType jetType) {
+    public Type mapType(@NotNull KtType jetType) {
         return mapType(jetType, null, JetTypeMapperMode.VALUE);
     }
 
@@ -416,13 +415,13 @@ public class JetTypeMapper {
     }
 
     @NotNull
-    private Type mapType(@NotNull JetType jetType, @Nullable BothSignatureWriter signatureVisitor, @NotNull JetTypeMapperMode mode) {
+    private Type mapType(@NotNull KtType jetType, @Nullable BothSignatureWriter signatureVisitor, @NotNull JetTypeMapperMode mode) {
         return mapType(jetType, signatureVisitor, mode, Variance.INVARIANT);
     }
 
     @NotNull
     private Type mapType(
-            @NotNull JetType jetType,
+            @NotNull KtType jetType,
             @Nullable BothSignatureWriter signatureVisitor,
             @NotNull JetTypeMapperMode kind,
             @NotNull Variance howThisTypeIsUsed
@@ -451,7 +450,7 @@ public class JetTypeMapper {
         TypeConstructor constructor = jetType.getConstructor();
         DeclarationDescriptor descriptor = constructor.getDeclarationDescriptor();
         if (constructor instanceof IntersectionTypeConstructor) {
-            jetType = CommonSupertypes.commonSupertype(new ArrayList<JetType>(constructor.getSupertypes()));
+            jetType = CommonSupertypes.commonSupertype(new ArrayList<KtType>(constructor.getSupertypes()));
         }
 
         if (descriptor == null) {
@@ -474,7 +473,7 @@ public class JetTypeMapper {
                 throw new UnsupportedOperationException("arrays must have one type argument");
             }
             TypeProjection memberProjection = jetType.getArguments().get(0);
-            JetType memberType = memberProjection.getType();
+            KtType memberType = memberProjection.getType();
 
             Type arrayElementType;
             if (memberProjection.getProjectionKind() == Variance.IN_VARIANCE) {
@@ -521,7 +520,7 @@ public class JetTypeMapper {
     }
 
     @Nullable
-    private static Type mapBuiltinType(@NotNull JetType type) {
+    private static Type mapBuiltinType(@NotNull KtType type) {
         DeclarationDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
         if (!(descriptor instanceof ClassDescriptor)) return null;
 
@@ -584,7 +583,7 @@ public class JetTypeMapper {
     }
 
     @NotNull
-    private static String generateErrorMessageForErrorType(@NotNull JetType type, @NotNull DeclarationDescriptor descriptor) {
+    private static String generateErrorMessageForErrorType(@NotNull KtType type, @NotNull DeclarationDescriptor descriptor) {
         PsiElement declarationElement = DescriptorToSourceUtils.descriptorToDeclaration(descriptor);
 
         if (declarationElement == null) {
@@ -617,7 +616,7 @@ public class JetTypeMapper {
     private void writeGenericType(
             BothSignatureWriter signatureVisitor,
             Type asmType,
-            JetType jetType,
+            KtType jetType,
             Variance howThisTypeIsUsed,
             boolean projectionsAllowed
     ) {
@@ -654,7 +653,7 @@ public class JetTypeMapper {
         }
     }
 
-    private static boolean hasNothingInArguments(JetType jetType) {
+    private static boolean hasNothingInArguments(KtType jetType) {
         boolean hasNothingInArguments = CollectionsKt.any(jetType.getArguments(), new Function1<TypeProjection, Boolean>() {
             @Override
             public Boolean invoke(TypeProjection projection) {
@@ -692,7 +691,7 @@ public class JetTypeMapper {
     }
 
     private Type mapKnownAsmType(
-            JetType jetType,
+            KtType jetType,
             Type asmType,
             @Nullable BothSignatureWriter signatureVisitor,
             @NotNull Variance howThisTypeIsUsed
@@ -701,7 +700,7 @@ public class JetTypeMapper {
     }
 
     private Type mapKnownAsmType(
-            JetType jetType,
+            KtType jetType,
             Type asmType,
             @Nullable BothSignatureWriter signatureVisitor,
             @NotNull Variance howThisTypeIsUsed,
@@ -887,10 +886,10 @@ public class JetTypeMapper {
         }
         else if (isFunctionLiteral(descriptor)) {
             PsiElement element = DescriptorToSourceUtils.getSourceFromDescriptor(descriptor);
-            if (element instanceof JetFunctionLiteral) {
+            if (element instanceof KtFunctionLiteral) {
                 PsiElement expression = element.getParent();
-                if (expression instanceof JetFunctionLiteralExpression) {
-                    SamType samType = bindingContext.get(SAM_VALUE, (JetExpression) expression);
+                if (expression instanceof KtFunctionLiteralExpression) {
+                    SamType samType = bindingContext.get(SAM_VALUE, (KtExpression) expression);
                     if (samType != null) {
                         return samType.getAbstractMethod().getName().asString();
                     }
@@ -1093,7 +1092,7 @@ public class JetTypeMapper {
     }
 
     @Nullable
-    public String mapFieldSignature(@NotNull JetType backingFieldType) {
+    public String mapFieldSignature(@NotNull KtType backingFieldType) {
         BothSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.TYPE);
         mapType(backingFieldType, sw, JetTypeMapperMode.VALUE);
         return sw.makeJavaGenericSignature();
@@ -1144,7 +1143,7 @@ public class JetTypeMapper {
         {
             sw.writeClassBound();
 
-            for (JetType jetType : typeParameterDescriptor.getUpperBounds()) {
+            for (KtType jetType : typeParameterDescriptor.getUpperBounds()) {
                 if (jetType.getConstructor().getDeclarationDescriptor() instanceof ClassDescriptor) {
                     if (!isJvmInterface(jetType)) {
                         mapType(jetType, sw, JetTypeMapperMode.TYPE_PARAMETER);
@@ -1160,7 +1159,7 @@ public class JetTypeMapper {
         }
         sw.writeClassBoundEnd();
 
-        for (JetType jetType : typeParameterDescriptor.getUpperBounds()) {
+        for (KtType jetType : typeParameterDescriptor.getUpperBounds()) {
             ClassifierDescriptor classifier = jetType.getConstructor().getDeclarationDescriptor();
             if (classifier instanceof ClassDescriptor) {
                 if (isJvmInterface(jetType)) {
@@ -1180,11 +1179,11 @@ public class JetTypeMapper {
         }
     }
 
-    private void writeParameter(@NotNull BothSignatureWriter sw, @NotNull JetType type) {
+    private void writeParameter(@NotNull BothSignatureWriter sw, @NotNull KtType type) {
         writeParameter(sw, JvmMethodParameterKind.VALUE, type);
     }
 
-    private void writeParameter(@NotNull BothSignatureWriter sw, @NotNull JvmMethodParameterKind kind, @NotNull JetType type) {
+    private void writeParameter(@NotNull BothSignatureWriter sw, @NotNull JvmMethodParameterKind kind, @NotNull KtType type) {
         sw.writeParameterType(kind);
         mapType(type, sw, JetTypeMapperMode.VALUE);
         sw.writeParameterTypeEnd();
@@ -1204,7 +1203,7 @@ public class JetTypeMapper {
             writeParameter(sw, JvmMethodParameterKind.OUTER, captureThis.getDefaultType());
         }
 
-        JetType captureReceiverType = closure != null ? closure.getCaptureReceiverType() : null;
+        KtType captureReceiverType = closure != null ? closure.getCaptureReceiverType() : null;
         if (captureReceiverType != null) {
             writeParameter(sw, JvmMethodParameterKind.RECEIVER, captureReceiverType);
         }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/EnumSwitchCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/EnumSwitchCodegen.java
index 7eab364b1f8..2f14a55dc3f 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/EnumSwitchCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/EnumSwitchCodegen.java
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.codegen.when;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.ExpressionCodegen;
-import org.jetbrains.kotlin.psi.JetWhenExpression;
+import org.jetbrains.kotlin.psi.KtWhenExpression;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.EnumValue;
 import org.jetbrains.org.objectweb.asm.Label;
@@ -28,7 +28,7 @@ public class EnumSwitchCodegen extends SwitchCodegen {
     private final WhenByEnumsMapping mapping;
 
     public EnumSwitchCodegen(
-            @NotNull JetWhenExpression expression,
+            @NotNull KtWhenExpression expression,
             boolean isStatement,
             @NotNull ExpressionCodegen codegen,
             @NotNull WhenByEnumsMapping mapping
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/IntegralConstantsSwitchCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/IntegralConstantsSwitchCodegen.java
index 8915ac68485..5bd1048872c 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/IntegralConstantsSwitchCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/IntegralConstantsSwitchCodegen.java
@@ -18,13 +18,13 @@ package org.jetbrains.kotlin.codegen.when;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.ExpressionCodegen;
-import org.jetbrains.kotlin.psi.JetWhenExpression;
+import org.jetbrains.kotlin.psi.KtWhenExpression;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.org.objectweb.asm.Label;
 
 public class IntegralConstantsSwitchCodegen extends SwitchCodegen {
     public IntegralConstantsSwitchCodegen(
-            @NotNull JetWhenExpression expression,
+            @NotNull KtWhenExpression expression,
             boolean isStatement,
             @NotNull ExpressionCodegen codegen
     ) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingClassesForWhenByEnumCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingClassesForWhenByEnumCodegen.java
index e967e4c1d11..f2296af82be 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingClassesForWhenByEnumCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingClassesForWhenByEnumCodegen.java
@@ -20,7 +20,7 @@ import com.intellij.util.ArrayUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.ClassBuilder;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.constants.EnumValue;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
@@ -42,7 +42,7 @@ public class MappingClassesForWhenByEnumCodegen {
         this.state = state;
     }
 
-    public void generate(@NotNull List<WhenByEnumsMapping> mappings, @NotNull Type mappingsClass, @NotNull JetFile srcFile) {
+    public void generate(@NotNull List<WhenByEnumsMapping> mappings, @NotNull Type mappingsClass, @NotNull KtFile srcFile) {
         ClassBuilder cb = state.getFactory().newVisitor(JvmDeclarationOrigin.NO_ORIGIN, mappingsClass, srcFile);
         cb.defineClass(
                 srcFile,
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingsClassesForWhenByEnum.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingsClassesForWhenByEnum.java
index 8b0ca48865e..857a21322e9 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingsClassesForWhenByEnum.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingsClassesForWhenByEnum.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.codegen.when;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.psi.JetWhenExpression;
+import org.jetbrains.kotlin.psi.KtWhenExpression;
 import org.jetbrains.org.objectweb.asm.Type;
 
 import java.util.HashSet;
@@ -36,7 +36,7 @@ public class MappingsClassesForWhenByEnum {
         this.mappingsCodegen = new MappingClassesForWhenByEnumCodegen(state);
     }
 
-    public void generateMappingsClassForExpression(@NotNull JetWhenExpression expression) {
+    public void generateMappingsClassForExpression(@NotNull KtWhenExpression expression) {
         WhenByEnumsMapping mapping = state.getBindingContext().get(CodegenBinding.MAPPING_FOR_WHEN_BY_ENUM, expression);
 
         assert mapping != null : "mapping class should not be requested for non enum when";
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/StringSwitchCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/StringSwitchCodegen.java
index e689eefdaa7..3e9c5caa99c 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/StringSwitchCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/StringSwitchCodegen.java
@@ -20,7 +20,7 @@ import com.google.common.collect.Maps;
 import com.intellij.openapi.util.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.ExpressionCodegen;
-import org.jetbrains.kotlin.psi.JetWhenExpression;
+import org.jetbrains.kotlin.psi.KtWhenExpression;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.StringValue;
 import org.jetbrains.org.objectweb.asm.Label;
@@ -38,7 +38,7 @@ public class StringSwitchCodegen extends SwitchCodegen {
     private int tempVarIndex;
 
     public StringSwitchCodegen(
-            @NotNull JetWhenExpression expression,
+            @NotNull KtWhenExpression expression,
             boolean isStatement,
             @NotNull ExpressionCodegen codegen
     ) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegen.java
index 026107f6297..3ea541c9250 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegen.java
@@ -19,12 +19,12 @@ package org.jetbrains.kotlin.codegen.when;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.ExpressionCodegen;
 import org.jetbrains.kotlin.codegen.FrameMap;
-import org.jetbrains.kotlin.psi.JetWhenEntry;
-import org.jetbrains.kotlin.psi.JetWhenExpression;
+import org.jetbrains.kotlin.psi.KtWhenEntry;
+import org.jetbrains.kotlin.psi.KtWhenExpression;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.NullValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.org.objectweb.asm.Label;
 import org.jetbrains.org.objectweb.asm.Type;
@@ -33,7 +33,7 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 import java.util.*;
 
 abstract public class SwitchCodegen {
-    protected final JetWhenExpression expression;
+    protected final KtWhenExpression expression;
     protected final boolean isStatement;
     protected final ExpressionCodegen codegen;
     protected final BindingContext bindingContext;
@@ -48,7 +48,7 @@ abstract public class SwitchCodegen {
     protected Label defaultLabel;
 
     public SwitchCodegen(
-            @NotNull JetWhenExpression expression, boolean isStatement,
+            @NotNull KtWhenExpression expression, boolean isStatement,
             @NotNull ExpressionCodegen codegen
     ) {
         this.expression = expression;
@@ -93,7 +93,7 @@ abstract public class SwitchCodegen {
      * Behaviour may be changed by overriding processConstant
      */
     private void prepareConfiguration() {
-        for (JetWhenEntry entry : expression.getEntries()) {
+        for (KtWhenEntry entry : expression.getEntries()) {
             Label entryLabel = new Label();
 
             for (ConstantValue<?> constant : SwitchCodegenUtil.getConstantsFromEntry(entry, bindingContext)) {
@@ -131,7 +131,7 @@ abstract public class SwitchCodegen {
 
     protected void generateNullCheckIfNeeded() {
         assert expression.getSubjectExpression() != null : "subject expression can't be null";
-        JetType subjectJetType = bindingContext.getType(expression.getSubjectExpression());
+        KtType subjectJetType = bindingContext.getType(expression.getSubjectExpression());
 
         assert subjectJetType != null : "subject type can't be null (i.e. void)";
 
@@ -151,9 +151,9 @@ abstract public class SwitchCodegen {
         }
     }
 
-    private int findNullEntryIndex(@NotNull JetWhenExpression expression) {
+    private int findNullEntryIndex(@NotNull KtWhenExpression expression) {
         int entryIndex = 0;
-        for (JetWhenEntry entry : expression.getEntries()) {
+        for (KtWhenEntry entry : expression.getEntries()) {
             for (ConstantValue<?> constant : SwitchCodegenUtil.getConstantsFromEntry(entry, bindingContext)) {
                 if (constant instanceof NullValue) {
                     return entryIndex;
@@ -214,7 +214,7 @@ abstract public class SwitchCodegen {
     protected void generateEntries() {
         // resolving entries' entryLabels and generating entries' code
         Iterator<Label> entryLabelsIterator = entryLabels.iterator();
-        for (JetWhenEntry entry : expression.getEntries()) {
+        for (KtWhenEntry entry : expression.getEntries()) {
             v.visitLabel(entryLabelsIterator.next());
 
             FrameMap.Mark mark = codegen.myFrameMap.mark();
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenUtil.java
index 9e2a7db30d8..232ffe39ced 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenUtil.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenUtil.java
@@ -34,18 +34,18 @@ import java.util.List;
 
 public class SwitchCodegenUtil {
     public static boolean checkAllItemsAreConstantsSatisfying(
-            @NotNull JetWhenExpression expression,
+            @NotNull KtWhenExpression expression,
             @NotNull BindingContext bindingContext,
             Function1<ConstantValue<?>, Boolean> predicate
     ) {
-        for (JetWhenEntry entry : expression.getEntries()) {
-            for (JetWhenCondition condition : entry.getConditions()) {
-                if (!(condition instanceof JetWhenConditionWithExpression)) {
+        for (KtWhenEntry entry : expression.getEntries()) {
+            for (KtWhenCondition condition : entry.getConditions()) {
+                if (!(condition instanceof KtWhenConditionWithExpression)) {
                     return false;
                 }
 
                 // ensure that expression is constant
-                JetExpression patternExpression = ((JetWhenConditionWithExpression) condition).getExpression();
+                KtExpression patternExpression = ((KtWhenConditionWithExpression) condition).getExpression();
 
                 if (patternExpression == null) return false;
 
@@ -61,12 +61,12 @@ public class SwitchCodegenUtil {
 
     @NotNull
     public static Iterable<ConstantValue<?>> getAllConstants(
-            @NotNull JetWhenExpression expression,
+            @NotNull KtWhenExpression expression,
             @NotNull BindingContext bindingContext
     ) {
         List<ConstantValue<?>> result = new ArrayList<ConstantValue<?>>();
 
-        for (JetWhenEntry entry : expression.getEntries()) {
+        for (KtWhenEntry entry : expression.getEntries()) {
             addConstantsFromEntry(result, entry, bindingContext);
         }
 
@@ -75,13 +75,13 @@ public class SwitchCodegenUtil {
 
     private static void addConstantsFromEntry(
             @NotNull List<ConstantValue<?>> result,
-            @NotNull JetWhenEntry entry,
+            @NotNull KtWhenEntry entry,
             @NotNull BindingContext bindingContext
     ) {
-        for (JetWhenCondition condition : entry.getConditions()) {
-            if (!(condition instanceof JetWhenConditionWithExpression)) continue;
+        for (KtWhenCondition condition : entry.getConditions()) {
+            if (!(condition instanceof KtWhenConditionWithExpression)) continue;
 
-            JetExpression patternExpression = ((JetWhenConditionWithExpression) condition).getExpression();
+            KtExpression patternExpression = ((KtWhenConditionWithExpression) condition).getExpression();
 
             assert patternExpression != null : "expression in when should not be null";
             result.add(ExpressionCodegen.getCompileTimeConstant(patternExpression, bindingContext));
@@ -90,7 +90,7 @@ public class SwitchCodegenUtil {
 
     @NotNull
     public static Iterable<ConstantValue<?>> getConstantsFromEntry(
-            @NotNull JetWhenEntry entry,
+            @NotNull KtWhenEntry entry,
             @NotNull BindingContext bindingContext
     ) {
         List<ConstantValue<?>> result = new ArrayList<ConstantValue<?>>();
@@ -100,7 +100,7 @@ public class SwitchCodegenUtil {
 
     @Nullable
     public static SwitchCodegen buildAppropriateSwitchCodegenIfPossible(
-            @NotNull JetWhenExpression expression,
+            @NotNull KtWhenExpression expression,
             boolean isStatement,
             @NotNull ExpressionCodegen codegen
     ) {
@@ -129,7 +129,7 @@ public class SwitchCodegenUtil {
     }
 
     private static boolean isThereConstantEntriesButNulls(
-            @NotNull JetWhenExpression expression,
+            @NotNull KtWhenExpression expression,
             @NotNull BindingContext bindingContext
     ) {
         for (ConstantValue<?> constant : getAllConstants(expression, bindingContext)) {
@@ -140,7 +140,7 @@ public class SwitchCodegenUtil {
     }
 
     private static boolean isIntegralConstantsSwitch(
-            @NotNull JetWhenExpression expression,
+            @NotNull KtWhenExpression expression,
             @NotNull Type subjectType,
             @NotNull BindingContext bindingContext
     ) {
@@ -161,7 +161,7 @@ public class SwitchCodegenUtil {
     }
 
     private static boolean isStringConstantsSwitch(
-            @NotNull JetWhenExpression expression,
+            @NotNull KtWhenExpression expression,
             @NotNull Type subjectType,
             @NotNull BindingContext bindingContext
     ) {
diff --git a/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt b/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt
index 8a4d7441f37..f13123f6092 100644
--- a/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt
+++ b/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.resolve.constants.NullValue
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.serialization.*
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 public class BuiltInsSerializerExtension : SerializerExtension() {
     private val stringTable = StringTableImpl()
@@ -75,7 +75,7 @@ public class BuiltInsSerializerExtension : SerializerExtension() {
         }
     }
 
-    override fun serializeType(type: JetType, proto: ProtoBuf.Type.Builder) {
+    override fun serializeType(type: KtType, proto: ProtoBuf.Type.Builder) {
         for (annotation in type.annotations) {
             proto.addExtension(BuiltInsProtoBuf.typeAnnotation, annotationSerializer.serializeAnnotation(annotation))
         }
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/common/CompilerPluginContext.java b/compiler/cli/src/org/jetbrains/kotlin/cli/common/CompilerPluginContext.java
index 4a417f6e1c2..d27f9464742 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/common/CompilerPluginContext.java
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/common/CompilerPluginContext.java
@@ -18,14 +18,14 @@ package org.jetbrains.kotlin.cli.common;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 
 import java.util.List;
 
 /**
  * Represents the context of available state in which a {@link CompilerPlugin} runs such as
- * the {@link Project}, the {@link BindingContext} and the underlying {@link JetFile} files.
+ * the {@link Project}, the {@link BindingContext} and the underlying {@link KtFile} files.
  */
 public class CompilerPluginContext {
     @NotNull
@@ -34,9 +34,9 @@ public class CompilerPluginContext {
     @NotNull
     private final BindingContext context;
     @NotNull
-    private final List<JetFile> files;
+    private final List<KtFile> files;
 
-    public CompilerPluginContext(Project project, BindingContext context, List<JetFile> files) {
+    public CompilerPluginContext(Project project, BindingContext context, List<KtFile> files) {
         this.project = project;
         this.context = context;
         this.files = files;
@@ -48,7 +48,7 @@ public class CompilerPluginContext {
     }
 
     @NotNull
-    public List<JetFile> getFiles() {
+    public List<KtFile> getFiles() {
         return files;
     }
 
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/AnalyzerWithCompilerReport.java b/compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/AnalyzerWithCompilerReport.java
index 9531deb6b37..f41a5e0df6b 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/AnalyzerWithCompilerReport.java
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/AnalyzerWithCompilerReport.java
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.load.java.JavaBindingContext;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.components.TraceBasedErrorReporter;
 import org.jetbrains.kotlin.load.java.components.TraceBasedErrorReporter.AbiVersionErrorData;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.AnalyzingUtils;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
@@ -195,8 +195,8 @@ public final class AnalyzerWithCompilerReport {
         return reportDiagnostics(diagnostics, new DefaultDiagnosticReporter(messageCollector), false);
     }
 
-    private void reportSyntaxErrors(@NotNull Collection<JetFile> files) {
-        for (JetFile file : files) {
+    private void reportSyntaxErrors(@NotNull Collection<KtFile> files) {
+        for (KtFile file : files) {
             reportSyntaxErrors(file, messageCollector);
         }
     }
@@ -262,7 +262,7 @@ public final class AnalyzerWithCompilerReport {
         return messageCollector.anyReported(CompilerMessageSeverity.ERROR);
     }
 
-    public void analyzeAndReport(@NotNull Collection<JetFile> files, @NotNull Function0<AnalysisResult> analyzer) {
+    public void analyzeAndReport(@NotNull Collection<KtFile> files, @NotNull Function0<AnalysisResult> analyzer) {
         analysisResult = analyzer.invoke();
         reportSyntaxErrors(files);
         List<AbiVersionErrorData> abiVersionErrors = getAbiVersionErrors();
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java b/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java
index 4147daab9fe..86c84ac2f2f 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java
@@ -54,7 +54,7 @@ import org.jetbrains.kotlin.js.config.LibrarySourcesConfig;
 import org.jetbrains.kotlin.js.facade.K2JSTranslator;
 import org.jetbrains.kotlin.js.facade.MainCallParameters;
 import org.jetbrains.kotlin.js.facade.TranslationResult;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.utils.PathUtil;
 
 import java.io.File;
@@ -105,7 +105,7 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
                 KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES);
 
         Project project = environmentForJS.getProject();
-        List<JetFile> sourcesFiles = environmentForJS.getSourceFiles();
+        List<KtFile> sourcesFiles = environmentForJS.getSourceFiles();
 
         if (arguments.outputFile == null) {
             messageSeverityCollector.report(CompilerMessageSeverity.ERROR, "Specify output file via -output", CompilerMessageLocation.NO_LOCATION);
@@ -210,10 +210,10 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
         return OK;
     }
 
-    private static void reportCompiledSourcesList(@NotNull MessageCollector messageCollector, @NotNull List<JetFile> sourceFiles) {
-        Iterable<String> fileNames = ContainerUtil.map(sourceFiles, new Function<JetFile, String>() {
+    private static void reportCompiledSourcesList(@NotNull MessageCollector messageCollector, @NotNull List<KtFile> sourceFiles) {
+        Iterable<String> fileNames = ContainerUtil.map(sourceFiles, new Function<KtFile, String>() {
             @Override
-            public String fun(@Nullable JetFile file) {
+            public String fun(@Nullable KtFile file) {
                 assert file != null;
                 VirtualFile virtualFile = file.getVirtualFile();
                 if (virtualFile != null) {
@@ -227,7 +227,7 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
     }
 
     private static AnalyzerWithCompilerReport analyzeAndReportErrors(@NotNull MessageCollector messageCollector,
-            @NotNull final List<JetFile> sources, @NotNull final Config config) {
+            @NotNull final List<KtFile> sources, @NotNull final Config config) {
         AnalyzerWithCompilerReport analyzerWithCompilerReport = new AnalyzerWithCompilerReport(messageCollector);
         analyzerWithCompilerReport.analyzeAndReport(sources, new Function0<AnalysisResult>() {
             @Override
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.kt
index 052e8f79fc8..7c3d6e74462 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.kt
@@ -36,15 +36,15 @@ import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetPsiUtil
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtPsiUtil
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
 import org.jetbrains.kotlin.resolve.lazy.ResolveSessionUtils
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice
 import org.jetbrains.kotlin.utils.emptyOrSingletonList
@@ -79,11 +79,11 @@ public class CliLightClassGenerationSupport(project: Project) : LightClassGenera
         trace.setKotlinCodeAnalyzer(codeAnalyzer)
     }
 
-    override fun getContextForPackage(files: Collection<JetFile>): LightClassConstructionContext {
+    override fun getContextForPackage(files: Collection<KtFile>): LightClassConstructionContext {
         return getContext()
     }
 
-    override fun getContextForClassOrObject(classOrObject: JetClassOrObject): LightClassConstructionContext {
+    override fun getContextForClassOrObject(classOrObject: KtClassOrObject): LightClassConstructionContext {
         return getContext()
     }
 
@@ -91,29 +91,29 @@ public class CliLightClassGenerationSupport(project: Project) : LightClassGenera
         return LightClassConstructionContext(bindingContext, module)
     }
 
-    override fun findClassOrObjectDeclarations(fqName: FqName, searchScope: GlobalSearchScope): Collection<JetClassOrObject> {
+    override fun findClassOrObjectDeclarations(fqName: FqName, searchScope: GlobalSearchScope): Collection<KtClassOrObject> {
         return ResolveSessionUtils.getClassDescriptorsByFqName(module, fqName).map {
             val element = DescriptorToSourceUtils.getSourceFromDescriptor(it)
-            if (element is JetClassOrObject && PsiSearchScopeUtil.isInScope(searchScope, element)) {
+            if (element is KtClassOrObject && PsiSearchScopeUtil.isInScope(searchScope, element)) {
                 element
             }
             else null
         }.filterNotNull()
     }
 
-    override fun findFilesForPackage(fqName: FqName, searchScope: GlobalSearchScope): Collection<JetFile> {
+    override fun findFilesForPackage(fqName: FqName, searchScope: GlobalSearchScope): Collection<KtFile> {
         return bindingContext.get(BindingContext.PACKAGE_TO_FILES, fqName)?.filter {
             PsiSearchScopeUtil.isInScope(searchScope, it)
         } ?: emptyList()
     }
 
     override fun findClassOrObjectDeclarationsInPackage(
-            packageFqName: FqName, searchScope: GlobalSearchScope): Collection<JetClassOrObject> {
+            packageFqName: FqName, searchScope: GlobalSearchScope): Collection<KtClassOrObject> {
         val files = findFilesForPackage(packageFqName, searchScope)
-        val result = SmartList<JetClassOrObject>()
+        val result = SmartList<KtClassOrObject>()
         for (file in files) {
             for (declaration in file.declarations) {
-                if (declaration is JetClassOrObject) {
+                if (declaration is KtClassOrObject) {
                     result.add(declaration)
                 }
             }
@@ -127,7 +127,7 @@ public class CliLightClassGenerationSupport(project: Project) : LightClassGenera
 
     override fun getSubPackages(fqn: FqName, scope: GlobalSearchScope): Collection<FqName> {
         val packageView = module.getPackage(fqn)
-        val members = packageView.memberScope.getDescriptors(DescriptorKindFilter.PACKAGES, JetScope.ALL_NAME_FILTER)
+        val members = packageView.memberScope.getDescriptors(DescriptorKindFilter.PACKAGES, KtScope.ALL_NAME_FILTER)
         return ContainerUtil.mapNotNull(members, object : Function<DeclarationDescriptor, FqName> {
             override fun `fun`(member: DeclarationDescriptor): FqName? {
                 if (member is PackageViewDescriptor) {
@@ -138,11 +138,11 @@ public class CliLightClassGenerationSupport(project: Project) : LightClassGenera
         })
     }
 
-    override fun getPsiClass(classOrObject: JetClassOrObject): PsiClass? {
+    override fun getPsiClass(classOrObject: KtClassOrObject): PsiClass? {
         return KotlinLightClassForExplicitDeclaration.create(psiManager, classOrObject)
     }
 
-    override fun resolveClassToDescriptor(classOrObject: JetClassOrObject): ClassDescriptor? {
+    override fun resolveClassToDescriptor(classOrObject: KtClassOrObject): ClassDescriptor? {
         return bindingContext.get(BindingContext.CLASS, classOrObject)
     }
 
@@ -154,7 +154,7 @@ public class CliLightClassGenerationSupport(project: Project) : LightClassGenera
                 KotlinLightClassForFacade.createForFacade(psiManager, facadeFqName, scope, filesForFacade))
     }
 
-    override fun findFilesForFacade(facadeFqName: FqName, scope: GlobalSearchScope): Collection<JetFile> {
+    override fun findFilesForFacade(facadeFqName: FqName, scope: GlobalSearchScope): Collection<KtFile> {
         if (facadeFqName.isRoot) return emptyList()
 
         return PackagePartClassUtils.getFilesWithCallables(findFilesForPackage(facadeFqName.parent(), scope)).filter {
@@ -162,7 +162,7 @@ public class CliLightClassGenerationSupport(project: Project) : LightClassGenera
         }
     }
 
-    override fun getContextForFacade(files: Collection<JetFile>): LightClassConstructionContext {
+    override fun getContextForFacade(files: Collection<KtFile>): LightClassConstructionContext {
         return getContext()
     }
 
@@ -200,8 +200,8 @@ public class CliLightClassGenerationSupport(project: Project) : LightClassGenera
 
             if (value == null) {
                 if (BindingContext.FUNCTION === slice || BindingContext.VARIABLE === slice) {
-                    if (key is JetDeclaration) {
-                        if (!JetPsiUtil.isLocal(key)) {
+                    if (key is KtDeclaration) {
+                        if (!KtPsiUtil.isLocal(key)) {
                             kotlinCodeAnalyzer!!.resolveToDescriptor(key)
                             return super.get<K, V>(slice, key)
                         }
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CommandLineScriptUtils.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CommandLineScriptUtils.java
index bfcd3dbaabc..790ce1c326b 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CommandLineScriptUtils.java
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CommandLineScriptUtils.java
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.AnalyzerScriptParameter;
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collections;
 import java.util.List;
@@ -35,7 +35,7 @@ public class CommandLineScriptUtils {
 
     public static List<AnalyzerScriptParameter> scriptParameters() {
         KotlinBuiltIns builtIns = JvmPlatform.INSTANCE$.getBuiltIns();
-        JetType arrayOfStrings = builtIns.getArrayType(INVARIANT, builtIns.getStringType());
+        KtType arrayOfStrings = builtIns.getArrayType(INVARIANT, builtIns.getStringType());
         AnalyzerScriptParameter argsParameter = new AnalyzerScriptParameter(ARGS_NAME, arrayOfStrings);
         return Collections.singletonList(argsParameter);
     }
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CompileEnvironmentUtil.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CompileEnvironmentUtil.java
index 6e890cdf256..50bbdfe8429 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CompileEnvironmentUtil.java
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CompileEnvironmentUtil.java
@@ -37,9 +37,9 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
 import org.jetbrains.kotlin.cli.common.modules.ModuleScriptData;
 import org.jetbrains.kotlin.cli.common.modules.ModuleXmlParser;
 import org.jetbrains.kotlin.codegen.ClassFileFactory;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
 import org.jetbrains.kotlin.utils.PathUtil;
 
@@ -137,7 +137,7 @@ public class CompileEnvironmentUtil {
     }
 
     @NotNull
-    public static List<JetFile> getJetFiles(
+    public static List<KtFile> getJetFiles(
             @NotNull final Project project,
             @NotNull Collection<String> sourceRoots,
             @NotNull Function1<String, Unit> reportError
@@ -145,7 +145,7 @@ public class CompileEnvironmentUtil {
         final VirtualFileSystem localFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL);
 
         final Set<VirtualFile> processedFiles = Sets.newHashSet();
-        final List<JetFile> result = Lists.newArrayList();
+        final List<KtFile> result = Lists.newArrayList();
 
         for (String sourceRootPath : sourceRoots) {
             if (sourceRootPath == null) {
@@ -157,7 +157,7 @@ public class CompileEnvironmentUtil {
                 reportError.invoke("Source file or directory not found: " + sourceRootPath);
                 continue;
             }
-            if (!vFile.isDirectory() && vFile.getFileType() != JetFileType.INSTANCE) {
+            if (!vFile.isDirectory() && vFile.getFileType() != KotlinFileType.INSTANCE) {
                 reportError.invoke("Source entry is not a Kotlin file: " + sourceRootPath);
                 continue;
             }
@@ -170,8 +170,8 @@ public class CompileEnvironmentUtil {
                         if (virtualFile != null && !processedFiles.contains(virtualFile)) {
                             processedFiles.add(virtualFile);
                             PsiFile psiFile = PsiManager.getInstance(project).findFile(virtualFile);
-                            if (psiFile instanceof JetFile) {
-                                result.add((JetFile) psiFile);
+                            if (psiFile instanceof KtFile) {
+                                result.add((KtFile) psiFile);
                             }
                         }
                     }
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt
index e940ba2e616..e9e43f81662 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt
@@ -70,13 +70,13 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.kotlinSourceRoots
 import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
 import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.load.kotlin.JvmVirtualFileFinderFactory
 import org.jetbrains.kotlin.load.kotlin.KotlinBinaryClassCache
 import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager
 import org.jetbrains.kotlin.parsing.JetParserDefinition
 import org.jetbrains.kotlin.parsing.JetScriptDefinitionProvider
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
@@ -97,7 +97,7 @@ public class KotlinCoreEnvironment private constructor(
             registerProjectExtensionPoints(Extensions.getArea(getProject()))
         }
     }
-    private val sourceFiles = ArrayList<JetFile>()
+    private val sourceFiles = ArrayList<KtFile>()
     private val javaRoots = ArrayList<JavaRoot>()
 
     public val configuration: CompilerConfiguration = configuration.copy().let {
@@ -122,8 +122,8 @@ public class KotlinCoreEnvironment private constructor(
             message ->
             report(ERROR, message)
         }))
-        sourceFiles.sortedWith(object : Comparator<JetFile> {
-            override fun compare(o1: JetFile, o2: JetFile): Int {
+        sourceFiles.sortedWith(object : Comparator<KtFile> {
+            override fun compare(o1: KtFile, o2: KtFile): Int {
                 return o1.getVirtualFile().getPath().compareTo(o2.getVirtualFile().getPath(), ignoreCase = true)
             }
         })
@@ -154,7 +154,7 @@ public class KotlinCoreEnvironment private constructor(
 
     public val sourceLinesOfCode: Int by lazy { countLinesOfCode(sourceFiles) }
 
-    public fun countLinesOfCode(sourceFiles: List<JetFile>): Int  =
+    public fun countLinesOfCode(sourceFiles: List<KtFile>): Int  =
             sourceFiles.sumBy {
                 val text = it.getText()
                 StringUtil.getLineBreakCount(it.getText()) + (if (StringUtil.endsWithLineBreak(text)) 0 else 1)
@@ -219,7 +219,7 @@ public class KotlinCoreEnvironment private constructor(
         return uniqueSourceRoots
     }
 
-    public fun getSourceFiles(): List<JetFile> = sourceFiles
+    public fun getSourceFiles(): List<KtFile> = sourceFiles
 
     private fun report(severity: CompilerMessageSeverity, message: String) {
         val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
@@ -351,8 +351,8 @@ public class KotlinCoreEnvironment private constructor(
         @JvmStatic
         public fun registerApplicationServices(applicationEnvironment: JavaCoreApplicationEnvironment) {
             with(applicationEnvironment) {
-                registerFileType(JetFileType.INSTANCE, "kt")
-                registerFileType(JetFileType.INSTANCE, JetParserDefinition.STD_SCRIPT_SUFFIX)
+                registerFileType(KotlinFileType.INSTANCE, "kt")
+                registerFileType(KotlinFileType.INSTANCE, JetParserDefinition.STD_SCRIPT_SUFFIX)
                 registerParserDefinition(JetParserDefinition())
                 getApplication().registerService(javaClass<KotlinBinaryClassCache>(), KotlinBinaryClassCache())
                 getApplication().registerService(javaClass<JavaClassSupers>(), javaClass<JavaClassSupersImpl>())
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java
index fba4c2d468f..8e495f0145a 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java
@@ -47,7 +47,6 @@ import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil;
 import org.jetbrains.kotlin.idea.MainFunctionDetector;
 import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager;
-import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache;
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents;
 import org.jetbrains.kotlin.modules.Module;
@@ -57,7 +56,7 @@ import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.parsing.JetScriptDefinition;
 import org.jetbrains.kotlin.parsing.JetScriptDefinitionProvider;
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.AnalyzerScriptParameter;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.BindingTraceContext;
@@ -142,7 +141,7 @@ public class KotlinToJVMBytecodeCompiler {
 
         for (Module module : chunk) {
             ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
-            List<JetFile> jetFiles = CompileEnvironmentUtil.getJetFiles(
+            List<KtFile> jetFiles = CompileEnvironmentUtil.getJetFiles(
                     environment.getProject(), getAbsolutePaths(directory, module), new Function1<String, Unit>() {
                         @Override
                         public Unit invoke(String s) {
@@ -196,10 +195,10 @@ public class KotlinToJVMBytecodeCompiler {
     }
 
     @Nullable
-    private static FqName findMainClass(@NotNull GenerationState generationState, @NotNull List<JetFile> files) {
+    private static FqName findMainClass(@NotNull GenerationState generationState, @NotNull List<KtFile> files) {
         MainFunctionDetector mainFunctionDetector = new MainFunctionDetector(generationState.getBindingContext());
         FqName mainClass = null;
-        for (JetFile file : files) {
+        for (KtFile file : files) {
             if (mainFunctionDetector.hasMain(file.getDeclarations())) {
                 if (mainClass != null) {
                     // more than one main
@@ -357,7 +356,7 @@ public class KotlinToJVMBytecodeCompiler {
     private static GenerationState generate(
             @NotNull KotlinCoreEnvironment environment,
             @NotNull AnalysisResult result,
-            @NotNull List<JetFile> sourceFiles,
+            @NotNull List<KtFile> sourceFiles,
             @Nullable Module module,
             File outputDirectory,
             String moduleName
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java
index 692b05dff5a..133beb4e131 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java
@@ -58,8 +58,8 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.parsing.JetParserDefinition;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetScript;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtScript;
 import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
@@ -68,8 +68,8 @@ import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
 import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo;
 import org.jetbrains.kotlin.resolve.lazy.declarations.*;
-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.jetbrains.kotlin.utils.ExceptionUtilsKt;
 import org.jetbrains.org.objectweb.asm.Type;
 
@@ -93,7 +93,7 @@ public class ReplInterpreter {
     private int lineNumber = 0;
 
     @Nullable
-    private JetScope lastLineScope;
+    private KtScope lastLineScope;
     private final List<EarlierLine> earlierLines = Lists.newArrayList();
     private final List<String> previousIncompleteLines = Lists.newArrayList();
     private final ReplClassLoader classLoader;
@@ -130,8 +130,8 @@ public class ReplInterpreter {
         FileScopeProvider.AdditionalScopes scopeProvider = new FileScopeProvider.AdditionalScopes() {
             @NotNull
             @Override
-            public List<JetScope> getScopes() {
-                return lastLineScope != null ? new SmartList<JetScope>(lastLineScope) : Collections.<JetScope>emptyList();
+            public List<KtScope> getScopes() {
+                return lastLineScope != null ? new SmartList<KtScope>(lastLineScope) : Collections.<KtScope>emptyList();
             }
         };
 
@@ -275,7 +275,7 @@ public class ReplInterpreter {
 
         LightVirtualFile virtualFile = new LightVirtualFile("line" + lineNumber + JetParserDefinition.STD_SCRIPT_EXT, KotlinLanguage.INSTANCE, fullText.toString());
         virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
-        JetFile psiFile = (JetFile) psiFileFactory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false);
+        KtFile psiFile = (KtFile) psiFileFactory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false);
         assert psiFile != null : "Script file not analyzed at line " + lineNumber + ": " + fullText;
 
         DiagnosticMessageHolder errorHolder = createDiagnosticHolder();
@@ -356,7 +356,7 @@ public class ReplInterpreter {
 
             earlierLines.add(new EarlierLine(line, scriptDescriptor, scriptClass, scriptInstance, scriptClassType));
 
-            JetType returnType = scriptDescriptor.getScriptCodeDescriptor().getReturnType();
+            KtType returnType = scriptDescriptor.getScriptCodeDescriptor().getReturnType();
             return LineResult.successful(rv, returnType != null && KotlinBuiltIns.isUnit(returnType));
         }
         catch (Throwable e) {
@@ -400,7 +400,7 @@ public class ReplInterpreter {
     }
 
     @Nullable
-    private ScriptDescriptor doAnalyze(@NotNull JetFile psiFile, @NotNull DiagnosticMessageReporter errorReporter) {
+    private ScriptDescriptor doAnalyze(@NotNull KtFile psiFile, @NotNull DiagnosticMessageReporter errorReporter) {
         scriptDeclarationFactory.setDelegateFactory(
                 new FileBasedDeclarationProviderFactory(resolveSession.getStorageManager(), Collections.singletonList(psiFile)));
 
@@ -442,7 +442,7 @@ public class ReplInterpreter {
 
             PsiElement jetScript = descriptorToDeclaration(earlierDescriptor);
             if (jetScript != null) {
-                registerClassNameForScript(state.getBindingTrace(), (JetScript) jetScript, earlierClassType, state.getFileClassesProvider());
+                registerClassNameForScript(state.getBindingTrace(), (KtScript) jetScript, earlierClassType, state.getFileClassesProvider());
                 earlierScriptDescriptors.add(earlierDescriptor);
             }
         }
@@ -450,7 +450,7 @@ public class ReplInterpreter {
     }
 
     public static void compileScript(
-            @NotNull JetScript script,
+            @NotNull KtScript script,
             @NotNull Type classType,
             @NotNull List<Pair<ScriptDescriptor, Type>> earlierScripts,
             @NotNull GenerationState state,
diff --git a/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/Conditional.kt b/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/Conditional.kt
index 0038a28fcfc..1491be8a7f2 100644
--- a/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/Conditional.kt
+++ b/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/Conditional.kt
@@ -51,13 +51,13 @@ interface Conditional {
     }
 }
 
-fun JetAnnotated.parseConditionalAnnotations(): List<Conditional> =
+fun KtAnnotated.parseConditionalAnnotations(): List<Conditional> =
         annotationEntries.map {
             val parser = Conditional.ANNOTATIONS.get(it.typeReferenceName)
             parser?.parse?.invoke(it.valueArguments.splitToPositionalAndNamed())
         }.filterNotNull()
 
 
-val JetAnnotationEntry.typeReferenceName: String? get() =
-        (typeReference?.typeElement as? JetUserType)?.referencedName
+val KtAnnotationEntry.typeReferenceName: String? get() =
+        (typeReference?.typeElement as? KtUserType)?.referencedName
 
diff --git a/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/Modifications.kt b/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/Modifications.kt
index fe29fa1a4da..8d379a74106 100644
--- a/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/Modifications.kt
+++ b/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/Modifications.kt
@@ -22,16 +22,16 @@ import org.jetbrains.kotlin.psi.*
 
 data class Modification(val range: TextRange, val apply: (String) -> String)
 
-class CollectModificationsVisitor(evaluators: List<Evaluator>) : JetTreeVisitorVoid() {
+class CollectModificationsVisitor(evaluators: List<Evaluator>) : KtTreeVisitorVoid() {
 
     val elementModifications: Map<Evaluator, MutableList<Modification>> =
             evaluators.toMap(selector = { it }, transform = { arrayListOf<Modification>() })
 
-    override fun visitDeclaration(declaration: JetDeclaration) {
+    override fun visitDeclaration(declaration: KtDeclaration) {
         super.visitDeclaration(declaration)
 
         val annotations = declaration.parseConditionalAnnotations()
-        val name = (declaration as? JetNamedDeclaration)?.nameAsSafeName ?: declaration.name
+        val name = (declaration as? KtNamedDeclaration)?.nameAsSafeName ?: declaration.name
 
         val declResults = arrayListOf<Pair<Evaluator, Boolean>>()
         for ((evaluator, modifications) in elementModifications) {
@@ -48,7 +48,7 @@ class CollectModificationsVisitor(evaluators: List<Evaluator>) : JetTreeVisitorV
             else {
                 val targetName = annotations.filterIsInstance<Conditional.TargetName>().singleOrNull()
                 if (targetName != null) {
-                    val placeholderName = (declaration as JetNamedDeclaration).nameAsName!!.asString()
+                    val placeholderName = (declaration as KtNamedDeclaration).nameAsName!!.asString()
                     val realName = targetName.name
                     modifications.add(Modification(declaration.textRange) { it.replace(placeholderName, realName) })
                 }
diff --git a/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/Preprocessor.kt b/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/Preprocessor.kt
index 1753babb837..34a515d24a9 100644
--- a/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/Preprocessor.kt
+++ b/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/Preprocessor.kt
@@ -22,7 +22,7 @@ import com.intellij.openapi.util.io.FileUtil
 import com.intellij.openapi.util.text.StringUtil
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.psi.*
 import java.io.File
 import java.io.IOException
@@ -46,15 +46,15 @@ public fun createProfile(name: String, targetRoot: File): Profile {
 
 public class Preprocessor(val logger: Logger = SystemOutLogger) {
 
-    val fileType = JetFileType.INSTANCE
-    val jetPsiFactory: JetPsiFactory
+    val fileType = KotlinFileType.INSTANCE
+    val jetPsiFactory: KtPsiFactory
 
     init {
         val configuration = CompilerConfiguration()
         val environment = KotlinCoreEnvironment.createForProduction(Disposable {  }, configuration, emptyList())
 
         val project = environment.project
-        jetPsiFactory = JetPsiFactory(project)
+        jetPsiFactory = KtPsiFactory(project)
     }
 
     sealed class FileProcessingResult {
diff --git a/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/ValueArguments.kt b/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/ValueArguments.kt
index 62905e30ad6..dbafa2cceec 100644
--- a/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/ValueArguments.kt
+++ b/compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/ValueArguments.kt
@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.preprocessor
 
-import org.jetbrains.kotlin.psi.JetStringTemplateEntry
+import org.jetbrains.kotlin.psi.KtStringTemplateEntry
 import org.jetbrains.kotlin.psi.ValueArgument
 import org.jetbrains.kotlin.psi.psiUtil.getChildrenOfType
 
@@ -32,4 +32,4 @@ fun List<ValueArgument>.splitToPositionalAndNamed(): PositionalAndNamedArguments
 }
 
 fun ValueArgument.parseIntegerValue(): Int = getArgumentExpression()!!.text.toInt()
-fun ValueArgument.parseStringValue(): String = getArgumentExpression()!!.getChildrenOfType<JetStringTemplateEntry>().joinToString("") { it.text }
\ No newline at end of file
+fun ValueArgument.parseStringValue(): String = getArgumentExpression()!!.getChildrenOfType<KtStringTemplateEntry>().joinToString("") { it.text }
\ No newline at end of file
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassUtil.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassUtil.kt
index af1527a99b8..a3adc3e2957 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassUtil.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassUtil.kt
@@ -41,14 +41,14 @@ public object JvmFileClassUtil {
     public val JVM_MULTIFILE_CLASS_SHORT = JVM_MULTIFILE_CLASS.shortName().asString()
 
     @JvmStatic
-    public fun getFileClassInfo(file: JetFile, jvmFileClassAnnotations: ParsedJmvFileClassAnnotations?): JvmFileClassInfo =
+    public fun getFileClassInfo(file: KtFile, jvmFileClassAnnotations: ParsedJmvFileClassAnnotations?): JvmFileClassInfo =
             if (jvmFileClassAnnotations != null)
                 getFileClassInfoForAnnotation(file, jvmFileClassAnnotations)
             else
                 getDefaultFileClassInfo(file)
 
     @JvmStatic
-    public fun getFileClassInfoForAnnotation(file: JetFile, jvmFileClassAnnotations: ParsedJmvFileClassAnnotations): JvmFileClassInfo =
+    public fun getFileClassInfoForAnnotation(file: KtFile, jvmFileClassAnnotations: ParsedJmvFileClassAnnotations): JvmFileClassInfo =
             if (jvmFileClassAnnotations.multipleFiles)
                 JvmMultifileClassPartInfo(getHiddenPartFqName(file, jvmFileClassAnnotations),
                                           getFacadeFqName(file, jvmFileClassAnnotations))
@@ -56,11 +56,11 @@ public object JvmFileClassUtil {
                 JvmSimpleFileClassInfo(getFacadeFqName(file, jvmFileClassAnnotations), true)
 
     @JvmStatic
-    public fun getDefaultFileClassInfo(file: JetFile): JvmFileClassInfo =
+    public fun getDefaultFileClassInfo(file: KtFile): JvmFileClassInfo =
             JvmSimpleFileClassInfo(PackagePartClassUtils.getPackagePartFqName(file.packageFqName, file.name), false)
 
     @JvmStatic
-    public fun getFacadeFqName(file: JetFile, jvmFileClassAnnotations: ParsedJmvFileClassAnnotations): FqName =
+    public fun getFacadeFqName(file: KtFile, jvmFileClassAnnotations: ParsedJmvFileClassAnnotations): FqName =
             file.packageFqName.child(Name.identifier(jvmFileClassAnnotations.name))
 
     @JvmStatic
@@ -79,7 +79,7 @@ public object JvmFileClassUtil {
             getImplClassNameForProto(proto, nameResolver)
 
     @JvmStatic
-    public fun getHiddenPartFqName(file: JetFile, jvmFileClassAnnotations: ParsedJmvFileClassAnnotations): FqName =
+    public fun getHiddenPartFqName(file: KtFile, jvmFileClassAnnotations: ParsedJmvFileClassAnnotations): FqName =
             file.packageFqName.child(Name.identifier(manglePartName(jvmFileClassAnnotations.name, file.name)))
 
     @JvmStatic
@@ -87,11 +87,11 @@ public object JvmFileClassUtil {
             "${facadeName}__${PackagePartClassUtils.getFilePartShortName(fileName)}"
 
     @JvmStatic
-    public fun getFileClassInfoNoResolve(file: JetFile): JvmFileClassInfo =
+    public fun getFileClassInfoNoResolve(file: KtFile): JvmFileClassInfo =
             getFileClassInfo(file, parseJvmNameOnFileNoResolve(file))
 
     @JvmStatic
-    public fun parseJvmNameOnFileNoResolve(file: JetFile): ParsedJmvFileClassAnnotations? {
+    public fun parseJvmNameOnFileNoResolve(file: KtFile): ParsedJmvFileClassAnnotations? {
         val jvmName = findAnnotationEntryOnFileNoResolve(file, JVM_NAME_SHORT) ?: return null
         val nameExpr = jvmName.valueArguments.firstOrNull()?.getArgumentExpression() ?: return null
         val name = getLiteralStringFromRestrictedConstExpression(nameExpr) ?: return null
@@ -101,16 +101,16 @@ public object JvmFileClassUtil {
     }
 
     @JvmStatic
-    public fun findAnnotationEntryOnFileNoResolve(file: JetFile, shortName: String): JetAnnotationEntry? =
+    public fun findAnnotationEntryOnFileNoResolve(file: KtFile, shortName: String): KtAnnotationEntry? =
             file.fileAnnotationList?.annotationEntries?.firstOrNull {
                 it.calleeExpression?.constructorReferenceExpression?.getReferencedName() == shortName
             }
 
-    private @JvmStatic fun getLiteralStringFromRestrictedConstExpression(argumentExpression: JetExpression?): String? {
-        val stringTemplate = argumentExpression as? JetStringTemplateExpression ?: return null
+    private @JvmStatic fun getLiteralStringFromRestrictedConstExpression(argumentExpression: KtExpression?): String? {
+        val stringTemplate = argumentExpression as? KtStringTemplateExpression ?: return null
         val stringTemplateEntries = stringTemplate.entries
         if (stringTemplateEntries.size() != 1) return null
-        val singleEntry = stringTemplateEntries[0] as? JetLiteralStringTemplateEntry ?: return null
+        val singleEntry = stringTemplateEntries[0] as? KtLiteralStringTemplateEntry ?: return null
         return singleEntry.text
     }
 
@@ -118,7 +118,7 @@ public object JvmFileClassUtil {
 
 public class ParsedJmvFileClassAnnotations(public val name: String, public val multipleFiles: Boolean)
 
-public val JetFile.javaFileFacadeFqName: FqName
+public val KtFile.javaFileFacadeFqName: FqName
     get() {
         return CachedValuesManager.getCachedValue(this) {
             val facadeFqName =
@@ -128,7 +128,7 @@ public val JetFile.javaFileFacadeFqName: FqName
         }
     }
 
-public fun JetDeclaration.isInsideJvmMultifileClassFile() = JvmFileClassUtil.findAnnotationEntryOnFileNoResolve(
+public fun KtDeclaration.isInsideJvmMultifileClassFile() = JvmFileClassUtil.findAnnotationEntryOnFileNoResolve(
         getContainingJetFile(),
         JvmFileClassUtil.JVM_MULTIFILE_CLASS_SHORT
 ) != null
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassesProvider.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassesProvider.kt
index f7f2d572dbb..2b52aef55ce 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassesProvider.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassesProvider.kt
@@ -18,12 +18,12 @@
 package org.jetbrains.kotlin.fileClasses
 
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.org.objectweb.asm.Type
 
 public interface JvmFileClassesProvider {
-    public fun getFileClassInfo(file: JetFile): JvmFileClassInfo
+    public fun getFileClassInfo(file: KtFile): JvmFileClassInfo
 }
 
 public fun FqName.getInternalName(): String =
@@ -32,20 +32,20 @@ public fun FqName.getInternalName(): String =
 public fun FqName.getClassType(): Type =
         Type.getObjectType(getInternalName())
 
-public fun JvmFileClassesProvider.getFileClassFqName(file: JetFile): FqName =
+public fun JvmFileClassesProvider.getFileClassFqName(file: KtFile): FqName =
         getFileClassInfo(file).fileClassFqName
 
-public fun JvmFileClassesProvider.getFileClassInternalName(file: JetFile): String =
+public fun JvmFileClassesProvider.getFileClassInternalName(file: KtFile): String =
         getFileClassFqName(file).getInternalName()
 
-public fun JvmFileClassesProvider.getFileClassType(file: JetFile): Type =
+public fun JvmFileClassesProvider.getFileClassType(file: KtFile): Type =
         getFileClassFqName(file).getClassType()
 
-public fun JvmFileClassesProvider.getFacadeClassFqName(file: JetFile): FqName =
+public fun JvmFileClassesProvider.getFacadeClassFqName(file: KtFile): FqName =
         getFileClassInfo(file).facadeClassFqName
 
-public fun JvmFileClassesProvider.getFacadeClassInternalName(file: JetFile): String =
+public fun JvmFileClassesProvider.getFacadeClassInternalName(file: KtFile): String =
         getFacadeClassFqName(file).getInternalName()
 
-public fun JvmFileClassesProvider.getFacadeClassType(file: JetFile): Type =
+public fun JvmFileClassesProvider.getFacadeClassType(file: KtFile): Type =
         getFacadeClassFqName(file).getClassType()
\ No newline at end of file
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/NoResolveFileClassesProvider.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/NoResolveFileClassesProvider.kt
index 19e69d0f5bc..6dccfa502ed 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/NoResolveFileClassesProvider.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/NoResolveFileClassesProvider.kt
@@ -17,10 +17,10 @@
 package org.jetbrains.kotlin.fileClasses
 
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
 
 public object NoResolveFileClassesProvider : JvmFileClassesProvider {
-    override fun getFileClassInfo(file: JetFile): JvmFileClassInfo =
+    override fun getFileClassInfo(file: KtFile): JvmFileClassInfo =
             JvmFileClassUtil.getFileClassInfo(file, JvmFileClassUtil.parseJvmNameOnFileNoResolve(file))
 }
\ No newline at end of file
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/jvm/RuntimeAssertions.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/jvm/RuntimeAssertions.kt
index 51382bcf1ac..daafd68357a 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/jvm/RuntimeAssertions.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/jvm/RuntimeAssertions.kt
@@ -20,36 +20,36 @@ import com.intellij.openapi.util.text.StringUtil
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.jvm.bindingContextSlices.RUNTIME_ASSERTION_INFO
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker
 import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.upperIfFlexible
 
 public class RuntimeAssertionInfo(public val needNotNullAssertion: Boolean, public val message: String) {
     public interface DataFlowExtras {
         class OnlyMessage(message: String) : DataFlowExtras {
             override val canBeNull: Boolean get() = true
-            override val possibleTypes: Set<JetType> get() = setOf()
+            override val possibleTypes: Set<KtType> get() = setOf()
             override val presentableText: String = message
         }
 
         val canBeNull: Boolean
-        val possibleTypes: Set<JetType>
+        val possibleTypes: Set<KtType>
         val presentableText: String
     }
 
     companion object {
         @JvmStatic
         public fun create(
-                expectedType: JetType,
-                expressionType: JetType,
+                expectedType: KtType,
+                expressionType: KtType,
                 dataFlowExtras: DataFlowExtras
         ): RuntimeAssertionInfo? {
             fun assertNotNull(): Boolean {
@@ -78,13 +78,13 @@ public class RuntimeAssertionInfo(public val needNotNullAssertion: Boolean, publ
                 null
         }
 
-        private fun JetType.hasEnhancedNullability()
+        private fun KtType.hasEnhancedNullability()
                 = getAnnotations().findAnnotation(JvmAnnotationNames.ENHANCED_NULLABILITY_ANNOTATION) != null
     }
 }
 
 public object RuntimeAssertionsTypeChecker : AdditionalTypeChecker {
-    override fun checkType(expression: JetExpression, expressionType: JetType, expressionTypeWithSmartCast: JetType, c: ResolutionContext<*>) {
+    override fun checkType(expression: KtExpression, expressionType: KtType, expressionTypeWithSmartCast: KtType, c: ResolutionContext<*>) {
         if (TypeUtils.noExpectedType(c.expectedType)) return
 
         val assertionInfo = RuntimeAssertionInfo.create(
@@ -93,7 +93,7 @@ public object RuntimeAssertionsTypeChecker : AdditionalTypeChecker {
                 object : RuntimeAssertionInfo.DataFlowExtras {
                     override val canBeNull: Boolean
                         get() = c.dataFlowInfo.getNullability(dataFlowValue).canBeNull()
-                    override val possibleTypes: Set<JetType>
+                    override val possibleTypes: Set<KtType>
                         get() = c.dataFlowInfo.getPossibleTypes(dataFlowValue)
                     override val presentableText: String
                         get() = StringUtil.trimMiddle(expression.getText(), 50)
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/jvm/bindingContextSlices.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/jvm/bindingContextSlices.kt
index 00d32c8a0fa..d2e4dda2cfb 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/jvm/bindingContextSlices.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/jvm/bindingContextSlices.kt
@@ -17,10 +17,10 @@
 package org.jetbrains.kotlin.jvm.bindingContextSlices
 
 import org.jetbrains.kotlin.jvm.RuntimeAssertionInfo
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.util.slicedMap.BasicWritableSlice
 import org.jetbrains.kotlin.util.slicedMap.RewritePolicy
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice
 import org.jetbrains.kotlin.utils.DO_NOTHING
 
-public val RUNTIME_ASSERTION_INFO: WritableSlice<JetExpression, RuntimeAssertionInfo> = BasicWritableSlice(RewritePolicy.DO_NOTHING)
+public val RUNTIME_ASSERTION_INFO: WritableSlice<KtExpression, RuntimeAssertionInfo> = BasicWritableSlice(RewritePolicy.DO_NOTHING)
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/JavaClassFinderImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/JavaClassFinderImpl.java
index 790862131af..866c9d75d30 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/JavaClassFinderImpl.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/JavaClassFinderImpl.java
@@ -24,7 +24,7 @@ import com.intellij.psi.search.DelegatingGlobalSearchScope;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.load.java.structure.JavaClass;
 import org.jetbrains.kotlin.load.java.structure.JavaPackage;
 import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl;
@@ -64,7 +64,7 @@ public class JavaClassFinderImpl implements JavaClassFinder {
         javaSearchScope = new DelegatingGlobalSearchScope(baseScope) {
             @Override
             public boolean contains(@NotNull VirtualFile file) {
-                return myBaseScope.contains(file) && (file.isDirectory() || file.getFileType() != JetFileType.INSTANCE);
+                return myBaseScope.contains(file) && (file.isDirectory() || file.getFileType() != KotlinFileType.INSTANCE);
             }
 
             //NOTE: expected by class finder to be not null
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedExternalSignatureResolver.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedExternalSignatureResolver.java
index c5fb0515834..8779f01e230 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedExternalSignatureResolver.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedExternalSignatureResolver.java
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolverKt;
 import org.jetbrains.kotlin.resolve.jvm.kotlinSignature.AlternativeFieldSignatureData;
 import org.jetbrains.kotlin.resolve.jvm.kotlinSignature.AlternativeMethodSignatureData;
 import org.jetbrains.kotlin.resolve.jvm.kotlinSignature.SignaturesPropagationData;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collections;
 import java.util.List;
@@ -55,8 +55,8 @@ public class TraceBasedExternalSignatureResolver implements ExternalSignatureRes
     public PropagatedMethodSignature resolvePropagatedSignature(
             @NotNull JavaMethod method,
             @NotNull ClassDescriptor owner,
-            @NotNull JetType returnType,
-            @Nullable JetType receiverType,
+            @NotNull KtType returnType,
+            @Nullable KtType receiverType,
             @NotNull List<ValueParameterDescriptor> valueParameters,
             @NotNull List<TypeParameterDescriptor> typeParameters
     ) {
@@ -72,8 +72,8 @@ public class TraceBasedExternalSignatureResolver implements ExternalSignatureRes
     public AlternativeMethodSignature resolveAlternativeMethodSignature(
             @NotNull JavaMember methodOrConstructor,
             boolean hasSuperMethods,
-            @Nullable JetType returnType,
-            @Nullable JetType receiverType,
+            @Nullable KtType returnType,
+            @Nullable KtType receiverType,
             @NotNull List<ValueParameterDescriptor> valueParameters,
             @NotNull List<TypeParameterDescriptor> typeParameters,
             boolean hasStableParameterNames
@@ -102,7 +102,7 @@ public class TraceBasedExternalSignatureResolver implements ExternalSignatureRes
     @NotNull
     public AlternativeFieldSignature resolveAlternativeFieldSignature(
             @NotNull JavaField field,
-            @NotNull JetType returnType,
+            @NotNull KtType returnType,
             boolean isVar
     ) {
         AlternativeFieldSignatureData data = new AlternativeFieldSignatureData(field, returnType, project, isVar);
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamAdapterOverridabilityCondition.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamAdapterOverridabilityCondition.java
index 59776faff0d..a9cbfd4c12b 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamAdapterOverridabilityCondition.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamAdapterOverridabilityCondition.java
@@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.resolve.ExternalOverridabilityCondition;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 import org.jetbrains.kotlin.types.TypeUtils;
 
@@ -57,7 +57,7 @@ public class SamAdapterOverridabilityCondition implements ExternalOverridability
         return true;
     }
 
-    private static boolean differentClasses(@NotNull JetType type1, @NotNull JetType type2) {
+    private static boolean differentClasses(@NotNull KtType type1, @NotNull KtType type2) {
         DeclarationDescriptor declarationDescriptor1 = type1.getConstructor().getDeclarationDescriptor();
         if (declarationDescriptor1 == null) return true; // No class, classes are not equal
         DeclarationDescriptor declarationDescriptor2 = type2.getConstructor().getDeclarationDescriptor();
@@ -100,7 +100,7 @@ public class SamAdapterOverridabilityCondition implements ExternalOverridability
     @Nullable
     private static SamAdapterInfo getNearestDeclarationOrSynthesized(
             @NotNull SimpleFunctionDescriptor samAdapter,
-            @NotNull JetType ownerType
+            @NotNull KtType ownerType
     ) {
         if (samAdapter.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
             return new SamAdapterInfo(samAdapter, ownerType);
@@ -109,7 +109,7 @@ public class SamAdapterOverridabilityCondition implements ExternalOverridability
         for (CallableMemberDescriptor overridden : samAdapter.getOverriddenDescriptors()) {
             ClassDescriptor containingClass = (ClassDescriptor) overridden.getContainingDeclaration();
 
-            for (JetType immediateSupertype : TypeUtils.getImmediateSupertypes(ownerType)) {
+            for (KtType immediateSupertype : TypeUtils.getImmediateSupertypes(ownerType)) {
                 if (containingClass != immediateSupertype.getConstructor().getDeclarationDescriptor()) {
                     continue;
                 }
@@ -126,9 +126,9 @@ public class SamAdapterOverridabilityCondition implements ExternalOverridability
 
     private static class SamAdapterInfo {
         private final SimpleFunctionDescriptor samAdapter;
-        private final JetType ownerType;
+        private final KtType ownerType;
 
-        private SamAdapterInfo(@NotNull SimpleFunctionDescriptor samAdapter, @NotNull JetType ownerType) {
+        private SamAdapterInfo(@NotNull SimpleFunctionDescriptor samAdapter, @NotNull KtType ownerType) {
             this.samAdapter = samAdapter;
             this.ownerType = ownerType;
         }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamConversionResolverImpl.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamConversionResolverImpl.kt
index bc935aa2886..fa101aaec77 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamConversionResolverImpl.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamConversionResolverImpl.kt
@@ -18,21 +18,21 @@ package org.jetbrains.kotlin.load.java.sam
 
 import org.jetbrains.kotlin.load.java.components.SamConversionResolver
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.load.java.descriptors.*
 import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.load.java.structure.JavaMethod
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.load.java.sources.JavaSourceElement
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.kotlin.types.TypeUtils
 import java.util.ArrayList
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 
 public object SamConversionResolverImpl : SamConversionResolver {
-    override fun resolveSamConstructor(name: Name, scope: JetScope): SamConstructorDescriptor? {
+    override fun resolveSamConstructor(name: Name, scope: KtScope): SamConstructorDescriptor? {
         val classifier = scope.getClassifier(name) as? LazyJavaClassDescriptor ?: return null
         if (classifier.getFunctionTypeForSamInterface() == null) return null
         return SingleAbstractMethodUtils.createSamConstructorFunction(scope.getContainingDeclaration(), classifier)
@@ -51,7 +51,7 @@ public object SamConversionResolverImpl : SamConversionResolver {
     override fun resolveFunctionTypeIfSamInterface(
             classDescriptor: JavaClassDescriptor,
             resolveMethod: (JavaMethod) -> FunctionDescriptor
-    ): JetType? {
+    ): KtType? {
         val jClass = (classDescriptor.getSource() as? JavaSourceElement)?.javaElement as? JavaClass ?: return null
         val samInterfaceMethod = SingleAbstractMethodUtils.getSamInterfaceMethod(jClass) ?: return null
         val abstractMethod = if (jClass.getFqName() == samInterfaceMethod.getContainingClass().getFqName()) {
@@ -63,7 +63,7 @@ public object SamConversionResolverImpl : SamConversionResolver {
         return SingleAbstractMethodUtils.getFunctionTypeForAbstractMethod(abstractMethod)
     }
 
-    private fun findFunctionWithMostSpecificReturnType(supertypes: Set<JetType>): SimpleFunctionDescriptor {
+    private fun findFunctionWithMostSpecificReturnType(supertypes: Set<KtType>): SimpleFunctionDescriptor {
         val candidates = ArrayList<SimpleFunctionDescriptor>(supertypes.size())
         for (supertype in supertypes) {
             val abstractMembers = SingleAbstractMethodUtils.getAbstractMembers(supertype)
@@ -79,7 +79,7 @@ public object SamConversionResolverImpl : SamConversionResolver {
             val candidateReturnType = candidate.getReturnType()
             val currentMostSpecificReturnType = currentMostSpecificType.getReturnType()
             assert(candidateReturnType != null && currentMostSpecificReturnType != null) { "$candidate, $currentMostSpecificReturnType" }
-            if (JetTypeChecker.DEFAULT.isSubtypeOf(candidateReturnType!!, currentMostSpecificReturnType!!)) {
+            if (KotlinTypeChecker.DEFAULT.isSubtypeOf(candidateReturnType!!, currentMostSpecificReturnType!!)) {
                 currentMostSpecificType = candidate
             }
         }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java
index f4faa045a4b..7be219b0eaf 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java
@@ -43,7 +43,7 @@ public class SingleAbstractMethodUtils {
     }
 
     @NotNull
-    public static List<CallableMemberDescriptor> getAbstractMembers(@NotNull JetType type) {
+    public static List<CallableMemberDescriptor> getAbstractMembers(@NotNull KtType type) {
         List<CallableMemberDescriptor> abstractMembers = new ArrayList<CallableMemberDescriptor>();
         for (DeclarationDescriptor member : type.getMemberScope().getAllDescriptors()) {
             if (member instanceof CallableMemberDescriptor && ((CallableMemberDescriptor) member).getModality() == Modality.ABSTRACT) {
@@ -53,7 +53,7 @@ public class SingleAbstractMethodUtils {
         return abstractMembers;
     }
 
-    private static JetType fixProjections(@NotNull JetType functionType) {
+    private static KtType fixProjections(@NotNull KtType functionType) {
         //removes redundant projection kinds and detects conflicts
 
         List<TypeParameterDescriptor> typeParameters = functionType.getConstructor().getParameters();
@@ -76,7 +76,7 @@ public class SingleAbstractMethodUtils {
         }
         ClassifierDescriptor classifier = functionType.getConstructor().getDeclarationDescriptor();
         assert classifier instanceof ClassDescriptor : "Not class: " + classifier;
-        return JetTypeImpl.create(
+        return KtTypeImpl.create(
                 functionType.getAnnotations(),
                 functionType.getConstructor(),
                 functionType.isMarkedNullable(),
@@ -86,21 +86,21 @@ public class SingleAbstractMethodUtils {
     }
 
     @Nullable
-    public static JetType getFunctionTypeForSamType(@NotNull JetType samType) {
+    public static KtType getFunctionTypeForSamType(@NotNull KtType samType) {
         // e.g. samType == Comparator<String>?
 
         ClassifierDescriptor classifier = samType.getConstructor().getDeclarationDescriptor();
         if (classifier instanceof JavaClassDescriptor) {
             // Function2<T, T, Int>
-            JetType functionTypeDefault = ((JavaClassDescriptor) classifier).getFunctionTypeForSamInterface();
+            KtType functionTypeDefault = ((JavaClassDescriptor) classifier).getFunctionTypeForSamInterface();
 
             if (functionTypeDefault != null) {
                 // Function2<String, String, Int>?
-                JetType substitute = TypeSubstitutor.create(samType).substitute(functionTypeDefault, Variance.INVARIANT);
+                KtType substitute = TypeSubstitutor.create(samType).substitute(functionTypeDefault, Variance.INVARIANT);
 
                 if (substitute == null) return null;
 
-                JetType type = fixProjections(substitute);
+                KtType type = fixProjections(substitute);
                 if (type == null) return null;
 
                 if (JavaDescriptorResolverKt.getPLATFORM_TYPES() && FlexibleTypesKt.isNullabilityFlexible(samType)) {
@@ -114,11 +114,11 @@ public class SingleAbstractMethodUtils {
     }
 
     @NotNull
-    public static JetType getFunctionTypeForAbstractMethod(@NotNull FunctionDescriptor function) {
-        JetType returnType = function.getReturnType();
+    public static KtType getFunctionTypeForAbstractMethod(@NotNull FunctionDescriptor function) {
+        KtType returnType = function.getReturnType();
         assert returnType != null : "function is not initialized: " + function;
         List<ValueParameterDescriptor> valueParameters = function.getValueParameters();
-        List<JetType> parameterTypes = new ArrayList<JetType>(valueParameters.size());
+        List<KtType> parameterTypes = new ArrayList<KtType>(valueParameters.size());
         for (ValueParameterDescriptor parameter : valueParameters) {
             parameterTypes.add(parameter.getType());
         }
@@ -151,9 +151,9 @@ public class SingleAbstractMethodUtils {
 
         TypeParameters typeParameters = recreateAndInitializeTypeParameters(samInterface.getTypeConstructor().getParameters(), result);
 
-        JetType parameterTypeUnsubstituted = getFunctionTypeForSamType(samInterface.getDefaultType());
+        KtType parameterTypeUnsubstituted = getFunctionTypeForSamType(samInterface.getDefaultType());
         assert parameterTypeUnsubstituted != null : "couldn't get function type for SAM type " + samInterface.getDefaultType();
-        JetType parameterType = typeParameters.substitutor.substitute(parameterTypeUnsubstituted, Variance.IN_VARIANCE);
+        KtType parameterType = typeParameters.substitutor.substitute(parameterTypeUnsubstituted, Variance.IN_VARIANCE);
         assert parameterType != null : "couldn't substitute type: " + parameterTypeUnsubstituted +
                                        ", substitutor = " + typeParameters.substitutor;
         ValueParameterDescriptor parameter = new ValueParameterDescriptorImpl(
@@ -163,7 +163,7 @@ public class SingleAbstractMethodUtils {
                 /* isNoinline = */ false,
                 null, SourceElement.NO_SOURCE);
 
-        JetType returnType = typeParameters.substitutor.substitute(samInterface.getDefaultType(), Variance.OUT_VARIANCE);
+        KtType returnType = typeParameters.substitutor.substitute(samInterface.getDefaultType(), Variance.OUT_VARIANCE);
         assert returnType != null : "couldn't substitute type: " + samInterface.getDefaultType() +
                                     ", substitutor = " + typeParameters.substitutor;
 
@@ -180,7 +180,7 @@ public class SingleAbstractMethodUtils {
         return result;
     }
 
-    public static boolean isSamType(@NotNull JetType type) {
+    public static boolean isSamType(@NotNull KtType type) {
         return getFunctionTypeForSamType(type) != null;
     }
 
@@ -201,7 +201,7 @@ public class SingleAbstractMethodUtils {
             public void initialize(
                     @NotNull List<TypeParameterDescriptor> typeParameters,
                     @NotNull List<ValueParameterDescriptor> valueParameters,
-                    @NotNull JetType returnType
+                    @NotNull KtType returnType
             ) {
                 result.initialize(
                         null,
@@ -224,7 +224,7 @@ public class SingleAbstractMethodUtils {
             public void initialize(
                     @NotNull List<TypeParameterDescriptor> typeParameters,
                     @NotNull List<ValueParameterDescriptor> valueParameters,
-                    @NotNull JetType returnType
+                    @NotNull KtType returnType
             ) {
                 result.initialize(typeParameters, valueParameters, original.getVisibility());
                 result.setReturnType(returnType);
@@ -240,11 +240,11 @@ public class SingleAbstractMethodUtils {
     ) {
         TypeParameters typeParameters = recreateAndInitializeTypeParameters(original.getTypeParameters(), adapter);
 
-        JetType returnTypeUnsubstituted = original.getReturnType();
+        KtType returnTypeUnsubstituted = original.getReturnType();
         assert returnTypeUnsubstituted != null : "Creating SAM adapter for not initialized original: " + original;
 
         TypeSubstitutor substitutor = typeParameters.substitutor;
-        JetType returnType = substitutor.substitute(returnTypeUnsubstituted, Variance.INVARIANT);
+        KtType returnType = substitutor.substitute(returnTypeUnsubstituted, Variance.INVARIANT);
         assert returnType != null : "couldn't substitute type: " + returnTypeUnsubstituted +
                                         ", substitutor = " + substitutor;
 
@@ -264,10 +264,10 @@ public class SingleAbstractMethodUtils {
         List<ValueParameterDescriptor> originalValueParameters = original.getValueParameters();
         List<ValueParameterDescriptor> valueParameters = new ArrayList<ValueParameterDescriptor>(originalValueParameters.size());
         for (ValueParameterDescriptor originalParam : originalValueParameters) {
-            JetType originalType = originalParam.getType();
-            JetType functionType = getFunctionTypeForSamType(originalType);
-            JetType newTypeUnsubstituted = functionType != null ? functionType : originalType;
-            JetType newType = substitutor.substitute(newTypeUnsubstituted, Variance.IN_VARIANCE);
+            KtType originalType = originalParam.getType();
+            KtType functionType = getFunctionTypeForSamType(originalType);
+            KtType newTypeUnsubstituted = functionType != null ? functionType : originalType;
+            KtType newType = substitutor.substitute(newTypeUnsubstituted, Variance.IN_VARIANCE);
             assert newType != null : "couldn't substitute type: " + newTypeUnsubstituted + ", substitutor = " + substitutor;
 
             ValueParameterDescriptor newParam = new ValueParameterDescriptorImpl(
@@ -295,8 +295,8 @@ public class SingleAbstractMethodUtils {
             TypeParameterDescriptor traitTypeParameter = mapEntry.getKey();
             TypeParameterDescriptorImpl funTypeParameter = mapEntry.getValue();
 
-            for (JetType upperBound : traitTypeParameter.getUpperBounds()) {
-                JetType upperBoundSubstituted = typeParametersSubstitutor.substitute(upperBound, Variance.INVARIANT);
+            for (KtType upperBound : traitTypeParameter.getUpperBounds()) {
+                KtType upperBoundSubstituted = typeParametersSubstitutor.substitute(upperBound, Variance.INVARIANT);
                 assert upperBoundSubstituted != null : "couldn't substitute type: " + upperBound + ", substitutor = " + typeParametersSubstitutor;
                 funTypeParameter.addUpperBound(upperBoundSubstituted);
             }
@@ -345,7 +345,7 @@ public class SingleAbstractMethodUtils {
         public abstract void initialize(
                 @NotNull List<TypeParameterDescriptor> typeParameters,
                 @NotNull List<ValueParameterDescriptor> valueParameters,
-                @NotNull JetType returnType
+                @NotNull KtType returnType
         );
     }
 
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationCallChecker.kt
index 2819fd3b0f2..78251776b06 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationCallChecker.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationCallChecker.kt
@@ -27,8 +27,8 @@ import org.jetbrains.kotlin.load.java.components.JavaAnnotationMapper
 import org.jetbrains.kotlin.load.java.descriptors.JavaConstructorDescriptor
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.FqNameUnsafe
-import org.jetbrains.kotlin.psi.JetAnnotationEntry
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtAnnotationEntry
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import java.lang.annotation.Target
 
@@ -52,7 +52,7 @@ public class JavaAnnotationCallChecker : CallChecker {
     }
 
     private fun reportDeprecatedJavaAnnotation(resolvedCall: ResolvedCall<*>, context: BasicCallResolutionContext) {
-        val annotationEntry = resolvedCall.call.callElement as? JetAnnotationEntry ?: return
+        val annotationEntry = resolvedCall.call.callElement as? KtAnnotationEntry ?: return
         val type = context.trace.get(BindingContext.TYPE, annotationEntry.typeReference) ?: return
         JavaAnnotationMapper.javaToKotlinNameMap[type.constructor.declarationDescriptor?.let { DescriptorUtils.getFqNameSafe(it) }]?.let {
             context.trace.report(ErrorsJvm.DEPRECATED_JAVA_ANNOTATION.on(annotationEntry, it))
@@ -71,7 +71,7 @@ public class JavaAnnotationCallChecker : CallChecker {
     private fun reportOnValueArgument(
             context: BasicCallResolutionContext,
             argument: Map.Entry<ValueParameterDescriptor, ResolvedValueArgument>,
-            diagnostic: DiagnosticFactory0<JetExpression>
+            diagnostic: DiagnosticFactory0<KtExpression>
     ) {
         argument.getValue().getArguments().forEach {
             if (it.getArgumentExpression() != null) {
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/PackagePartClassUtils.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/PackagePartClassUtils.kt
index 6e041153ad9..a58e22bf3d6 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/PackagePartClassUtils.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/PackagePartClassUtils.kt
@@ -22,9 +22,9 @@ import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import java.util.*
 
@@ -67,21 +67,21 @@ public object PackagePartClassUtils {
 
     @Deprecated("Migrate to JvmFileClassesProvider")
     @JvmStatic
-    public fun getPackagePartInternalName(file: JetFile): String =
+    public fun getPackagePartInternalName(file: KtFile): String =
             JvmClassName.byFqNameWithoutInnerClasses(getPackagePartFqName(file)).internalName
 
     @Deprecated("Migrate to JvmFileClassesProvider")
     @JvmStatic
-    public fun getPackagePartFqName(file: JetFile): FqName =
+    public fun getPackagePartFqName(file: KtFile): FqName =
             getPackagePartFqName(file.packageFqName, file.name)
 
     @JvmStatic
-    public fun getFilesWithCallables(files: Collection<JetFile>): List<JetFile> =
+    public fun getFilesWithCallables(files: Collection<KtFile>): List<KtFile> =
             files.filter { fileHasTopLevelCallables(it) }
 
     @JvmStatic
-    public fun fileHasTopLevelCallables(file: JetFile): Boolean =
-            file.declarations.any { it is JetProperty || it is JetNamedFunction }
+    public fun fileHasTopLevelCallables(file: KtFile): Boolean =
+            file.declarations.any { it is KtProperty || it is KtNamedFunction }
 
     @JvmStatic
     public fun getFilePartShortName(fileName: String): String =
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt
index febb72378a4..cffb3e17f3d 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt
@@ -30,10 +30,10 @@ import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
 import org.jetbrains.kotlin.modules.TargetId
 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.jvm.JvmClassName
 import org.jetbrains.kotlin.resolve.scopes.ChainedScope
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.serialization.PackageData
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationComponents
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
 import java.util.*
 
 public class IncrementalPackageFragmentProvider(
-        sourceFiles: Collection<JetFile>,
+        sourceFiles: Collection<KtFile>,
         val moduleDescriptor: ModuleDescriptor,
         val storageManager: StorageManager,
         val deserializationComponents: DeserializationComponents,
@@ -56,7 +56,7 @@ public class IncrementalPackageFragmentProvider(
     companion object {
         private val LOG = Logger.getLogger(IncrementalPackageFragmentProvider::class.java)
 
-        public fun fqNamesToLoad(obsoletePackageParts: Collection<String>, sourceFiles: Collection<JetFile>): Set<FqName> =
+        public fun fqNamesToLoad(obsoletePackageParts: Collection<String>, sourceFiles: Collection<KtFile>): Set<FqName> =
                 (obsoletePackageParts.map { JvmClassName.byInternalName(it).packageFqName }
                  + PackagePartClassUtils.getFilesWithCallables(sourceFiles).map { it.packageFqName }).toSet()
     }
@@ -97,9 +97,9 @@ public class IncrementalPackageFragmentProvider(
         public val target: TargetId
             get() = this@IncrementalPackageFragmentProvider.target
 
-        val memberScope: NotNullLazyValue<JetScope> = storageManager.createLazyValue {
+        val memberScope: NotNullLazyValue<KtScope> = storageManager.createLazyValue {
             if (fqName !in fqNamesToLoad) {
-                JetScope.Empty
+                KtScope.Empty
             }
             else {
                 val moduleMapping = incrementalCache.getModuleMappingData()?.let { ModuleMapping.create(it) }
@@ -128,7 +128,7 @@ public class IncrementalPackageFragmentProvider(
                         }
 
                 if (scopes.isEmpty()) {
-                    JetScope.Empty
+                    KtScope.Empty
                 }
                 else {
                     ChainedScope(this, "Member scope for incremental compilation: union of package parts data", *scopes.toTypedArray())
@@ -142,7 +142,7 @@ public class IncrementalPackageFragmentProvider(
             return IncrementalMultifileClassPackageFragment(multifileClassFqName, partsNames)
         }
 
-        override fun getMemberScope(): JetScope = memberScope()
+        override fun getMemberScope(): KtScope = memberScope()
 
         public inner class IncrementalMultifileClassPackageFragment(
                 val multifileClassFqName: FqName,
@@ -151,16 +151,16 @@ public class IncrementalPackageFragmentProvider(
             val memberScope = storageManager.createLazyValue {
                 val partsData = partsNames.map { incrementalCache.getPackagePartData(it) }.filterNotNull()
                 if (partsData.isEmpty())
-                    JetScope.Empty
+                    KtScope.Empty
                 else {
                     val scopes = partsData.map { IncrementalPackageScope(JvmProtoBufUtil.readPackageDataFrom(it.data, it.strings)) }
                     ChainedScope(this,
                                  "Member scope for incremental compilation: union of multifile class parts data for $multifileClassFqName",
-                                 *scopes.toTypedArray<JetScope>())
+                                 *scopes.toTypedArray<KtScope>())
                 }
             }
 
-            override fun getMemberScope(): JetScope = memberScope()
+            override fun getMemberScope(): KtScope = memberScope()
         }
 
         private inner class IncrementalPackageScope(val packageData: PackageData) : DeserializedPackageMemberScope(
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackagePartProvider.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackagePartProvider.kt
index 239001e812a..fabd2c5287f 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackagePartProvider.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackagePartProvider.kt
@@ -21,12 +21,12 @@ import org.jetbrains.kotlin.load.kotlin.ModuleMapping
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
 import org.jetbrains.kotlin.modules.TargetId
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.storage.StorageManager
 
 internal class IncrementalPackagePartProvider private constructor(
         private val parent: PackagePartProvider,
-        sourceFiles: Collection<JetFile>,
+        sourceFiles: Collection<KtFile>,
         incrementalCaches: List<IncrementalCache>,
         storageManager: StorageManager
 ) : PackagePartProvider {
@@ -46,7 +46,7 @@ internal class IncrementalPackagePartProvider private constructor(
         @JvmStatic
         public fun create(
                 parent: PackagePartProvider,
-                sourceFiles: Collection<JetFile>,
+                sourceFiles: Collection<KtFile>,
                 targets: List<TargetId>?,
                 incrementalCompilationComponents: IncrementalCompilationComponents?,
                 storageManager: StorageManager
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/native.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/native.kt
index ba89afa2b9b..30447acfab5 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/native.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/native.kt
@@ -18,14 +18,11 @@ package org.jetbrains.kotlin.load.kotlin.nativeDeclarations
 
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetDeclarationWithBody
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtDeclarationWithBody
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DeclarationChecker
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.diagnostics.FUNCTION_NO_BODY_ERRORS
-import org.jetbrains.kotlin.resolve.diagnostics.SuppressDiagnosticsByAnnotations
 import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 
@@ -35,7 +32,7 @@ public fun DeclarationDescriptor.hasNativeAnnotation(): Boolean {
 
 public class NativeFunChecker : DeclarationChecker {
     override fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext
@@ -50,7 +47,7 @@ public class NativeFunChecker : DeclarationChecker {
             diagnosticHolder.report(ErrorsJvm.EXTERNAL_DECLARATION_CANNOT_BE_ABSTRACT.on(declaration))
         }
 
-        if (descriptor !is ConstructorDescriptor && declaration is JetDeclarationWithBody && declaration.hasBody()) {
+        if (descriptor !is ConstructorDescriptor && declaration is KtDeclarationWithBody && declaration.hasBody()) {
             diagnosticHolder.report(ErrorsJvm.EXTERNAL_DECLARATION_CANNOT_HAVE_BODY.on(declaration))
         }
 
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt
index 51f8cc0b10e..8666f15bcd9 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.frontend.java.di.createContainerForLazyResolveWithJa
 import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.load.java.structure.JavaClass
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
 import org.jetbrains.kotlin.resolve.TargetEnvironment
 import org.jetbrains.kotlin.resolve.TargetPlatform
@@ -83,7 +83,7 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
     }
 
     @JvmStatic
-    public fun getAllFilesToAnalyze(project: Project, moduleInfo: ModuleInfo?, baseFiles: Collection<JetFile>): List<JetFile> {
+    public fun getAllFilesToAnalyze(project: Project, moduleInfo: ModuleInfo?, baseFiles: Collection<KtFile>): List<KtFile> {
         val allFiles = ArrayList(baseFiles)
         for (externalDeclarationsProvider in ExternalDeclarationsProvider.getInstances(project)) {
             allFiles.addAll(externalDeclarationsProvider.getExternalDeclarations(moduleInfo))
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java
index 8b95b7a1d9b..bf0eade3c5f 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java
@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.modules.Module;
 import org.jetbrains.kotlin.modules.TargetId;
 import org.jetbrains.kotlin.modules.TargetIdKt;
 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.TopDownAnalysisMode;
@@ -57,7 +57,7 @@ public enum TopDownAnalyzerFacadeForJVM {
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegrationNoIncremental(
             @NotNull ModuleContext moduleContext,
-            @NotNull Collection<JetFile> files,
+            @NotNull Collection<KtFile> files,
             @NotNull BindingTrace trace,
             @NotNull TopDownAnalysisMode topDownAnalysisMode,
             PackagePartProvider packagePartProvider
@@ -68,7 +68,7 @@ public enum TopDownAnalyzerFacadeForJVM {
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegrationWithCustomContext(
             @NotNull ModuleContext moduleContext,
-            @NotNull Collection<JetFile> files,
+            @NotNull Collection<KtFile> files,
             @NotNull BindingTrace trace,
             @Nullable List<Module> modules,
             @Nullable IncrementalCompilationComponents incrementalCompilationComponents,
@@ -82,7 +82,7 @@ public enum TopDownAnalyzerFacadeForJVM {
     @NotNull
     private static AnalysisResult analyzeFilesWithJavaIntegration(
             @NotNull ModuleContext moduleContext,
-            @NotNull Collection<JetFile> files,
+            @NotNull Collection<KtFile> files,
             @NotNull BindingTrace trace,
             @NotNull TopDownAnalysisMode topDownAnalysisMode,
             @Nullable List<Module> modules,
@@ -90,7 +90,7 @@ public enum TopDownAnalyzerFacadeForJVM {
             @NotNull PackagePartProvider packagePartProvider
     ) {
         Project project = moduleContext.getProject();
-        List<JetFile> allFiles = JvmAnalyzerFacade.getAllFilesToAnalyze(project, null, files);
+        List<KtFile> allFiles = JvmAnalyzerFacade.getAllFilesToAnalyze(project, null, files);
 
         FileBasedDeclarationProviderFactory providerFactory =
                 new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles);
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaClassOnCompanionChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaClassOnCompanionChecker.kt
index 5f389350048..c8844e5d07e 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaClassOnCompanionChecker.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaClassOnCompanionChecker.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
-import org.jetbrains.kotlin.types.JetTypeImpl
+import org.jetbrains.kotlin.types.KtTypeImpl
 import org.jetbrains.kotlin.types.TypeProjectionImpl
 
 public class JavaClassOnCompanionChecker : CallChecker {
@@ -42,7 +42,7 @@ public class JavaClassOnCompanionChecker : CallChecker {
         if (companionObject.isCompanionObject) {
             val containingClass = companionObject.containingDeclaration as ClassDescriptor
             val javaLangClass = actualType.constructor.declarationDescriptor as? ClassDescriptor ?: return
-            val expectedType = JetTypeImpl.create(
+            val expectedType = KtTypeImpl.create(
                     Annotations.EMPTY, javaLangClass, actualType.isMarkedNullable,
                     listOf(TypeProjectionImpl(containingClass.defaultType))
             )
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityWarningsChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityWarningsChecker.kt
index 5a7116386c3..ca8c440f4f4 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityWarningsChecker.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityWarningsChecker.kt
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.resolve.jvm.checkers
 import org.jetbrains.kotlin.cfg.WhenChecker
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.load.java.lazy.types.isMarkedNotNull
 import org.jetbrains.kotlin.load.java.lazy.types.isMarkedNullable
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetPostfixExpression
-import org.jetbrains.kotlin.psi.JetWhenExpression
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtPostfixExpression
+import org.jetbrains.kotlin.psi.KtWhenExpression
 import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker
 import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
@@ -36,14 +36,14 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.expressions.SenselessComparisonChecker
 import org.jetbrains.kotlin.types.flexibility
 import org.jetbrains.kotlin.types.isFlexible
 
 public class JavaNullabilityWarningsChecker : AdditionalTypeChecker {
-    private fun JetType.mayBeNull(): ErrorsJvm.NullabilityInformationSource? {
+    private fun KtType.mayBeNull(): ErrorsJvm.NullabilityInformationSource? {
         if (!isError() && !isFlexible() && TypeUtils.isNullableType(this)) return ErrorsJvm.NullabilityInformationSource.KOTLIN
 
         if (isFlexible() && TypeUtils.isNullableType(flexibility().lowerBound)) return ErrorsJvm.NullabilityInformationSource.KOTLIN
@@ -52,7 +52,7 @@ public class JavaNullabilityWarningsChecker : AdditionalTypeChecker {
         return null
     }
 
-    private fun JetType.mustNotBeNull(): ErrorsJvm.NullabilityInformationSource? {
+    private fun KtType.mustNotBeNull(): ErrorsJvm.NullabilityInformationSource? {
         if (!isError() && !isFlexible() && !TypeUtils.isNullableType(this)) return ErrorsJvm.NullabilityInformationSource.KOTLIN
 
         if (isFlexible() && !TypeUtils.isNullableType(flexibility().upperBound)) return ErrorsJvm.NullabilityInformationSource.KOTLIN
@@ -62,8 +62,8 @@ public class JavaNullabilityWarningsChecker : AdditionalTypeChecker {
     }
 
     private fun doCheckType(
-            expressionType: JetType,
-            expectedType: JetType,
+            expressionType: KtType,
+            expectedType: KtType,
             dataFlowValue: DataFlowValue,
             dataFlowInfo: DataFlowInfo,
             reportWarning: (expectedMustNotBeNull: ErrorsJvm.NullabilityInformationSource, actualMayBeNull: ErrorsJvm.NullabilityInformationSource) -> Unit
@@ -85,7 +85,7 @@ public class JavaNullabilityWarningsChecker : AdditionalTypeChecker {
         }
     }
 
-    override fun checkType(expression: JetExpression, expressionType: JetType, expressionTypeWithSmartCast: JetType, c: ResolutionContext<*>) {
+    override fun checkType(expression: KtExpression, expressionType: KtType, expressionTypeWithSmartCast: KtType, c: ResolutionContext<*>) {
         doCheckType(
                 expressionType,
                 c.expectedType,
@@ -98,7 +98,7 @@ public class JavaNullabilityWarningsChecker : AdditionalTypeChecker {
         }
 
         when (expression) {
-            is JetWhenExpression ->
+            is KtWhenExpression ->
                     if (expression.getElseExpression() == null) {
                         // Check for conditionally-exhaustive when on platform enums, see KT-6399
                         val type = expression.getSubjectExpression()?.let { c.trace.getType(it) } ?: return
@@ -112,8 +112,8 @@ public class JavaNullabilityWarningsChecker : AdditionalTypeChecker {
                             }
                         }
                     }
-            is JetPostfixExpression ->
-                    if (expression.getOperationToken() == JetTokens.EXCLEXCL) {
+            is KtPostfixExpression ->
+                    if (expression.getOperationToken() == KtTokens.EXCLEXCL) {
                         val baseExpression = expression.getBaseExpression() ?: return
                         val baseExpressionType = c.trace.getType(baseExpression) ?: return
                         doIfNotNull(
@@ -123,9 +123,9 @@ public class JavaNullabilityWarningsChecker : AdditionalTypeChecker {
                             c.trace.report(Errors.UNNECESSARY_NOT_NULL_ASSERTION.on(expression.getOperationReference(), baseExpressionType))
                         }
                     }
-            is JetBinaryExpression ->
+            is KtBinaryExpression ->
                 when (expression.getOperationToken()) {
-                    JetTokens.ELVIS -> {
+                    KtTokens.ELVIS -> {
                         val baseExpression = expression.getLeft()
                         val baseExpressionType = baseExpression?.let{ c.trace.getType(it) } ?: return
                         doIfNotNull(
@@ -135,10 +135,10 @@ public class JavaNullabilityWarningsChecker : AdditionalTypeChecker {
                             c.trace.report(Errors.USELESS_ELVIS.on(expression, baseExpressionType))
                         }
                     }
-                    JetTokens.EQEQ,
-                    JetTokens.EXCLEQ,
-                    JetTokens.EQEQEQ,
-                    JetTokens.EXCLEQEQEQ -> {
+                    KtTokens.EQEQ,
+                    KtTokens.EXCLEQ,
+                    KtTokens.EQEQEQ,
+                    KtTokens.EXCLEQEQEQ -> {
                         if (expression.getLeft() != null && expression.getRight() != null) {
                             SenselessComparisonChecker.checkSenselessComparisonWithNull(
                                     expression, expression.getLeft()!!, expression.getRight()!!, c,
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmFieldApplicabilityChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmFieldApplicabilityChecker.kt
index e89bfdad1c3..4a85fc80d59 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmFieldApplicabilityChecker.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmFieldApplicabilityChecker.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
 import org.jetbrains.kotlin.fileClasses.isInsideJvmMultifileClassFile
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DeclarationChecker
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
@@ -49,7 +49,7 @@ class JvmFieldApplicabilityChecker : DeclarationChecker {
     }
 
     override fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmSimpleNameBacktickChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmSimpleNameBacktickChecker.kt
index 3d9e9fb2f4c..94101074598 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmSimpleNameBacktickChecker.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmSimpleNameBacktickChecker.kt
@@ -32,22 +32,22 @@ object JvmSimpleNameBacktickChecker : IdentifierChecker {
         reportIfNeeded(identifier.text, identifier, diagnosticHolder)
     }
 
-    override fun checkDeclaration(declaration: JetDeclaration, diagnosticHolder: DiagnosticSink) {
-        if (declaration is JetMultiDeclaration) {
+    override fun checkDeclaration(declaration: KtDeclaration, diagnosticHolder: DiagnosticSink) {
+        if (declaration is KtMultiDeclaration) {
             declaration.entries.forEach { checkNamed(it, diagnosticHolder) }
         }
-        if (declaration is JetCallableDeclaration) {
+        if (declaration is KtCallableDeclaration) {
             declaration.valueParameters.forEach { checkNamed(it, diagnosticHolder) }
         }
-        if (declaration is JetTypeParameterListOwner) {
+        if (declaration is KtTypeParameterListOwner) {
             declaration.typeParameters.forEach { checkNamed(it, diagnosticHolder) }
         }
-        if (declaration is JetNamedDeclaration) {
+        if (declaration is KtNamedDeclaration) {
             checkNamed(declaration, diagnosticHolder)
         }
     }
 
-    fun checkNamed(declaration: JetNamedDeclaration, diagnosticHolder: DiagnosticSink) {
+    fun checkNamed(declaration: KtNamedDeclaration, diagnosticHolder: DiagnosticSink) {
         val name = declaration.name ?: return
 
         val element = declaration.nameIdentifier ?: declaration
@@ -55,7 +55,7 @@ object JvmSimpleNameBacktickChecker : IdentifierChecker {
     }
 
     private fun reportIfNeeded(name: String, element: PsiElement, diagnosticHolder: DiagnosticSink) {
-        val text = JetPsiUtil.unquoteIdentifier(name)
+        val text = KtPsiUtil.unquoteIdentifier(name)
         if (text.isEmpty()) {
             diagnosticHolder.report(Errors.INVALID_CHARACTERS.on(element, "should not be empty"))
         }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/NeedSyntheticChecker.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/NeedSyntheticChecker.java
index 471ae89db38..b89c7b7493c 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/NeedSyntheticChecker.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/NeedSyntheticChecker.java
@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.descriptors.Visibilities;
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
 
 import static org.jetbrains.kotlin.resolve.BindingContext.NEED_SYNTHETIC_ACCESSOR;
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/TraitDefaultMethodCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/TraitDefaultMethodCallChecker.kt
index 27cc2161c2b..f14f6d51d48 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/TraitDefaultMethodCallChecker.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/TraitDefaultMethodCallChecker.kt
@@ -20,7 +20,7 @@ import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getSuperCallExpression
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
@@ -43,7 +43,7 @@ public class TraitDefaultMethodCallChecker : CallChecker {
             if (classifier != null && DescriptorUtils.isInterface(classifier)) {
                 context.trace.report(
                         ErrorsJvm.INTERFACE_CANT_CALL_DEFAULT_METHOD_VIA_SUPER.on(
-                                PsiTreeUtil.getParentOfType(resolvedCall.getCall().getCallElement(), javaClass<JetExpression>())
+                                PsiTreeUtil.getParentOfType(resolvedCall.getCall().getCallElement(), javaClass<KtExpression>())
                         )
                 )
             }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/annotationCheckers.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/annotationCheckers.kt
index 36b9a47f11c..5e0986659aa 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/annotationCheckers.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/annotationCheckers.kt
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
-import org.jetbrains.kotlin.psi.JetAnnotationEntry
+import org.jetbrains.kotlin.psi.KtAnnotationEntry
 import org.jetbrains.kotlin.resolve.AdditionalAnnotationChecker
 import org.jetbrains.kotlin.resolve.AnnotationChecker
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -30,12 +30,12 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.classId
 import org.jetbrains.kotlin.resolve.descriptorUtil.getAnnotationRetention
 import org.jetbrains.kotlin.resolve.descriptorUtil.isRepeatableAnnotation
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 
 public object RepeatableAnnotationChecker: AdditionalAnnotationChecker {
-    override fun checkEntries(entries: List<JetAnnotationEntry>, actualTargets: List<KotlinTarget>, trace: BindingTrace) {
-        val entryTypesWithAnnotations = hashMapOf<JetType, MutableList<AnnotationUseSiteTarget?>>()
+    override fun checkEntries(entries: List<KtAnnotationEntry>, actualTargets: List<KotlinTarget>, trace: BindingTrace) {
+        val entryTypesWithAnnotations = hashMapOf<KtType, MutableList<AnnotationUseSiteTarget?>>()
 
         for (entry in entries) {
             val descriptor = trace.get(BindingContext.ANNOTATION, entry) ?: continue
@@ -61,8 +61,8 @@ public object FileClassAnnotationsChecker: AdditionalAnnotationChecker {
     // JvmName & JvmMultifileClass annotations are applicable to multi-file class parts regardless of their retention.
     private val ALWAYS_APPLICABLE = hashSetOf(JvmFileClassUtil.JVM_NAME, JvmFileClassUtil.JVM_MULTIFILE_CLASS)
 
-    override fun checkEntries(entries: List<JetAnnotationEntry>, actualTargets: List<KotlinTarget>, trace: BindingTrace) {
-        val fileAnnotationsToCheck = arrayListOf<Pair<JetAnnotationEntry, ClassDescriptor>>()
+    override fun checkEntries(entries: List<KtAnnotationEntry>, actualTargets: List<KotlinTarget>, trace: BindingTrace) {
+        val fileAnnotationsToCheck = arrayListOf<Pair<KtAnnotationEntry, ClassDescriptor>>()
         for (entry in entries) {
             if (entry.useSiteTarget?.getAnnotationUseSiteTarget() != AnnotationUseSiteTarget.FILE) continue
             val descriptor = trace.get(BindingContext.ANNOTATION, entry) ?: continue
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt
index 7bb2de342dc..c3e789c3c74 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -37,12 +37,12 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 public class LocalFunInlineChecker : DeclarationChecker {
 
     override fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext) {
         if (InlineUtil.isInline(descriptor) &&
-            declaration is JetNamedFunction &&
+            declaration is KtNamedFunction &&
             descriptor is FunctionDescriptor &&
             descriptor.getVisibility() == Visibilities.LOCAL) {
             diagnosticHolder.report(Errors.NOT_YET_SUPPORTED_IN_INLINE.on(declaration, declaration, descriptor))
@@ -53,20 +53,20 @@ public class LocalFunInlineChecker : DeclarationChecker {
 public class PlatformStaticAnnotationChecker : DeclarationChecker {
 
     override fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext
     ) {
         if (descriptor.hasPlatformStaticAnnotation()) {
-            if (declaration is JetNamedFunction || declaration is JetProperty || declaration is JetPropertyAccessor) {
+            if (declaration is KtNamedFunction || declaration is KtProperty || declaration is KtPropertyAccessor) {
                 checkDeclaration(declaration, descriptor, diagnosticHolder)
             }
         }
     }
 
     private fun checkDeclaration(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink
     ) {
@@ -81,18 +81,18 @@ public class PlatformStaticAnnotationChecker : DeclarationChecker {
         }
 
         val checkDeclaration = when(declaration) {
-            is JetPropertyAccessor -> declaration.getParent() as JetProperty
+            is KtPropertyAccessor -> declaration.getParent() as KtProperty
             else -> declaration
         }
 
-        if (insideObject && checkDeclaration.getModifierList()?.hasModifier(JetTokens.OVERRIDE_KEYWORD) == true) {
+        if (insideObject && checkDeclaration.getModifierList()?.hasModifier(KtTokens.OVERRIDE_KEYWORD) == true) {
             diagnosticHolder.report(ErrorsJvm.OVERRIDE_CANNOT_BE_STATIC.on(declaration))
         }
     }
 }
 
 public class JvmNameAnnotationChecker : DeclarationChecker {
-    override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink, bindingContext: BindingContext) {
+    override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink, bindingContext: BindingContext) {
         val platformNameAnnotation = DescriptorUtils.getJvmNameAnnotation(descriptor)
         if (platformNameAnnotation != null) {
             checkDeclaration(descriptor, platformNameAnnotation, diagnosticHolder)
@@ -130,7 +130,7 @@ public class JvmNameAnnotationChecker : DeclarationChecker {
 
 public class VolatileAnnotationChecker : DeclarationChecker {
 
-    override fun check(declaration: JetDeclaration,
+    override fun check(declaration: KtDeclaration,
                        descriptor: DeclarationDescriptor,
                        diagnosticHolder: DiagnosticSink,
                        bindingContext: BindingContext
@@ -145,7 +145,7 @@ public class VolatileAnnotationChecker : DeclarationChecker {
 
 public class SynchronizedAnnotationChecker : DeclarationChecker {
 
-    override fun check(declaration: JetDeclaration,
+    override fun check(declaration: KtDeclaration,
                        descriptor: DeclarationDescriptor,
                        diagnosticHolder: DiagnosticSink,
                        bindingContext: BindingContext
@@ -160,7 +160,7 @@ public class SynchronizedAnnotationChecker : DeclarationChecker {
 
 public class OverloadsAnnotationChecker: DeclarationChecker {
     override fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext
@@ -170,7 +170,7 @@ public class OverloadsAnnotationChecker: DeclarationChecker {
         }
     }
 
-    private fun checkDeclaration(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
+    private fun checkDeclaration(declaration: KtDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
         if (descriptor !is CallableDescriptor) {
             return
         }
@@ -189,7 +189,7 @@ public class OverloadsAnnotationChecker: DeclarationChecker {
 
 public class TypeParameterBoundIsNotArrayChecker : DeclarationChecker {
     override fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext
@@ -210,7 +210,7 @@ public class TypeParameterBoundIsNotArrayChecker : DeclarationChecker {
 public class ReifiedTypeParameterAnnotationChecker : DeclarationChecker {
 
     override fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext
@@ -233,11 +233,11 @@ public class ReifiedTypeParameterAnnotationChecker : DeclarationChecker {
     ) {
         for (reifiedTypeParameterDescriptor in typeParameterDescriptors.filter { it.isReified() }) {
             val typeParameterDeclaration = DescriptorToSourceUtils.descriptorToDeclaration(reifiedTypeParameterDescriptor)
-            if (typeParameterDeclaration !is JetTypeParameter) throw AssertionError("JetTypeParameter expected")
+            if (typeParameterDeclaration !is KtTypeParameter) throw AssertionError("JetTypeParameter expected")
 
             diagnosticHolder.report(
                     Errors.REIFIED_TYPE_PARAMETER_NO_INLINE.on(
-                            typeParameterDeclaration.getModifierList()!!.getModifier(JetTokens.REIFIED_KEYWORD)!!
+                            typeParameterDeclaration.getModifierList()!!.getModifier(KtTokens.REIFIED_KEYWORD)!!
                     )
             )
         }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java
index 52c047741fc..92e68a50d7d 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java
@@ -23,11 +23,11 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory2;
 import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetAnnotationEntry;
-import org.jetbrains.kotlin.psi.JetDeclaration;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.psi.KtAnnotationEntry;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtElement;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.types.KtType;
 
 import static org.jetbrains.kotlin.diagnostics.PositioningStrategies.*;
 import static org.jetbrains.kotlin.diagnostics.Severity.ERROR;
@@ -42,40 +42,40 @@ public interface ErrorsJvm {
     DiagnosticFactory1<PsiElement, ConflictingJvmDeclarationsData> CONFLICTING_INHERITED_JVM_DECLARATIONS =
             DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
 
-    DiagnosticFactory0<JetDeclaration> OVERRIDE_CANNOT_BE_STATIC = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
-    DiagnosticFactory0<JetDeclaration> JVM_STATIC_NOT_IN_OBJECT = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtDeclaration> OVERRIDE_CANNOT_BE_STATIC = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtDeclaration> JVM_STATIC_NOT_IN_OBJECT = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
 
     DiagnosticFactory0<PsiElement> INAPPLICABLE_JVM_NAME = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetAnnotationEntry> ILLEGAL_JVM_NAME = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtAnnotationEntry> ILLEGAL_JVM_NAME = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory1<JetAnnotationEntry, String> INAPPLICABLE_JVM_FIELD = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtAnnotationEntry, String> INAPPLICABLE_JVM_FIELD = DiagnosticFactory1.create(ERROR);
 
-    DiagnosticFactory0<JetAnnotationEntry> VOLATILE_ON_VALUE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetAnnotationEntry> SYNCHRONIZED_ON_ABSTRACT = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtAnnotationEntry> VOLATILE_ON_VALUE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtAnnotationEntry> SYNCHRONIZED_ON_ABSTRACT = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetDeclaration> OVERLOADS_WITHOUT_DEFAULT_ARGUMENTS = DiagnosticFactory0.create(WARNING, DECLARATION_SIGNATURE);
-    DiagnosticFactory0<JetDeclaration> OVERLOADS_ABSTRACT = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
-    DiagnosticFactory0<JetDeclaration> OVERLOADS_PRIVATE = DiagnosticFactory0.create(WARNING, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtDeclaration> OVERLOADS_WITHOUT_DEFAULT_ARGUMENTS = DiagnosticFactory0.create(WARNING, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtDeclaration> OVERLOADS_ABSTRACT = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtDeclaration> OVERLOADS_PRIVATE = DiagnosticFactory0.create(WARNING, DECLARATION_SIGNATURE);
 
-    DiagnosticFactory0<JetDeclaration> EXTERNAL_DECLARATION_CANNOT_BE_ABSTRACT = DiagnosticFactory0.create(ERROR, ABSTRACT_MODIFIER);
-    DiagnosticFactory0<JetDeclaration> EXTERNAL_DECLARATION_CANNOT_HAVE_BODY = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
-    DiagnosticFactory0<JetDeclaration> EXTERNAL_DECLARATION_IN_INTERFACE = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
-    DiagnosticFactory0<JetDeclaration> EXTERNAL_DECLARATION_CANNOT_BE_INLINED = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtDeclaration> EXTERNAL_DECLARATION_CANNOT_BE_ABSTRACT = DiagnosticFactory0.create(ERROR, ABSTRACT_MODIFIER);
+    DiagnosticFactory0<KtDeclaration> EXTERNAL_DECLARATION_CANNOT_HAVE_BODY = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtDeclaration> EXTERNAL_DECLARATION_IN_INTERFACE = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtDeclaration> EXTERNAL_DECLARATION_CANNOT_BE_INLINED = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
 
-    DiagnosticFactory0<JetExpression> POSITIONED_VALUE_ARGUMENT_FOR_JAVA_ANNOTATION = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetElement> DEPRECATED_ANNOTATION_METHOD_CALL = DiagnosticFactory0.create(WARNING);
-    DiagnosticFactory1<JetAnnotationEntry, FqName> DEPRECATED_JAVA_ANNOTATION = DiagnosticFactory1.create(WARNING);
-    DiagnosticFactory0<JetAnnotationEntry> NON_SOURCE_REPEATED_ANNOTATION = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory1<JetAnnotationEntry, FqName> ANNOTATION_IS_NOT_APPLICABLE_TO_MULTIFILE_CLASSES = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory0<KtExpression> POSITIONED_VALUE_ARGUMENT_FOR_JAVA_ANNOTATION = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtElement> DEPRECATED_ANNOTATION_METHOD_CALL = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory1<KtAnnotationEntry, FqName> DEPRECATED_JAVA_ANNOTATION = DiagnosticFactory1.create(WARNING);
+    DiagnosticFactory0<KtAnnotationEntry> NON_SOURCE_REPEATED_ANNOTATION = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory1<KtAnnotationEntry, FqName> ANNOTATION_IS_NOT_APPLICABLE_TO_MULTIFILE_CLASSES = DiagnosticFactory1.create(ERROR);
 
-    DiagnosticFactory0<JetElement> INTERFACE_CANT_CALL_DEFAULT_METHOD_VIA_SUPER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtElement> INTERFACE_CANT_CALL_DEFAULT_METHOD_VIA_SUPER = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetElement> INAPPLICABLE_PUBLIC_FIELD = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtElement> INAPPLICABLE_PUBLIC_FIELD = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetElement> NO_REFLECTION_IN_CLASS_PATH = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory0<KtElement> NO_REFLECTION_IN_CLASS_PATH = DiagnosticFactory0.create(WARNING);
 
-    DiagnosticFactory2<JetElement, JetType, JetType> JAVA_CLASS_ON_COMPANION = DiagnosticFactory2.create(WARNING);
-    DiagnosticFactory2<JetExpression, JetType, JetType> JAVA_TYPE_MISMATCH = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory2<KtElement, KtType, KtType> JAVA_CLASS_ON_COMPANION = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<KtExpression, KtType, KtType> JAVA_TYPE_MISMATCH = DiagnosticFactory2.create(ERROR);
 
     DiagnosticFactory2<PsiElement, String, String> DUPLICATE_CLASS_NAMES = DiagnosticFactory2.create(ERROR);
 
@@ -98,9 +98,9 @@ public interface ErrorsJvm {
         };
     }
 
-    DiagnosticFactory2<JetElement, NullabilityInformationSource, NullabilityInformationSource> NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<KtElement, NullabilityInformationSource, NullabilityInformationSource> NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS = DiagnosticFactory2.create(WARNING);
 
-    DiagnosticFactory0<JetExpression> WHEN_ENUM_CAN_BE_NULL_IN_JAVA = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory0<KtExpression> WHEN_ENUM_CAN_BE_NULL_IN_JAVA = DiagnosticFactory0.create(WARNING);
 
     @SuppressWarnings("UnusedDeclaration")
     Object _initializer = new Object() {
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/JvmDeclarationOrigin.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/JvmDeclarationOrigin.kt
index 4a2df785bf3..0a5c17803fd 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/JvmDeclarationOrigin.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/JvmDeclarationOrigin.kt
@@ -19,9 +19,9 @@ package org.jetbrains.kotlin.resolve.jvm.diagnostics
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind.*
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
@@ -68,17 +68,17 @@ public fun Bridge(descriptor: DeclarationDescriptor, element: PsiElement? = Desc
         JvmDeclarationOrigin(BRIDGE, element, descriptor)
 
 public fun PackageFacade(descriptor: PackageFragmentDescriptor): JvmDeclarationOrigin = JvmDeclarationOrigin(PACKAGE_FACADE, null, descriptor)
-public fun PackagePart(file: JetFile, descriptor: PackageFragmentDescriptor): JvmDeclarationOrigin = JvmDeclarationOrigin(PACKAGE_PART, file, descriptor)
+public fun PackagePart(file: KtFile, descriptor: PackageFragmentDescriptor): JvmDeclarationOrigin = JvmDeclarationOrigin(PACKAGE_PART, file, descriptor)
 
 /**
  * @param representativeFile one of the files representing this multifile class (will be used for diagnostics)
  */
-public fun MultifileClass(representativeFile: JetFile?, descriptor: PackageFragmentDescriptor, multifileClassFqName: FqName): JvmDeclarationOrigin =
+public fun MultifileClass(representativeFile: KtFile?, descriptor: PackageFragmentDescriptor, multifileClassFqName: FqName): JvmDeclarationOrigin =
         JvmDeclarationOrigin(MULTIFILE_CLASS, representativeFile, descriptor)
-public fun MultifileClassPart(file: JetFile, descriptor: PackageFragmentDescriptor, multifileClassFqName: FqName): JvmDeclarationOrigin =
+public fun MultifileClassPart(file: KtFile, descriptor: PackageFragmentDescriptor, multifileClassFqName: FqName): JvmDeclarationOrigin =
         JvmDeclarationOrigin(MULTIFILE_CLASS_PART, file, descriptor)
 
-public fun TraitImpl(element: JetClassOrObject, descriptor: ClassDescriptor): JvmDeclarationOrigin = JvmDeclarationOrigin(INTERFACE_DEFAULT_IMPL, element, descriptor)
+public fun TraitImpl(element: KtClassOrObject, descriptor: ClassDescriptor): JvmDeclarationOrigin = JvmDeclarationOrigin(INTERFACE_DEFAULT_IMPL, element, descriptor)
 public fun DelegationToTraitImpl(element: PsiElement?, descriptor: FunctionDescriptor): JvmDeclarationOrigin =
         JvmDeclarationOrigin(DELEGATION_TO_DEFAULT_IMPLS, element, descriptor)
 
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/extensions/AnalysisCompletedHandlerExtension.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/extensions/AnalysisCompletedHandlerExtension.kt
index 4bd47baf21f..51d36968be5 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/extensions/AnalysisCompletedHandlerExtension.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/extensions/AnalysisCompletedHandlerExtension.kt
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.extensions.ProjectExtensionDescriptor
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingContext
 
 public interface AnalysisCompletedHandlerExtension {
@@ -34,5 +34,5 @@ public interface AnalysisCompletedHandlerExtension {
             project: Project,
             module: ModuleDescriptor,
             bindingContext: BindingContext,
-            files: Collection<JetFile>): AnalysisResult?
+            files: Collection<KtFile>): AnalysisResult?
 }
\ No newline at end of file
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeFieldSignatureData.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeFieldSignatureData.java
index 5e573da8226..9aa5ab354c0 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeFieldSignatureData.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeFieldSignatureData.java
@@ -22,18 +22,18 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.kotlin.load.java.structure.JavaField;
-import org.jetbrains.kotlin.psi.JetProperty;
-import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.psi.KtProperty;
+import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.HashMap;
 
 public class AlternativeFieldSignatureData extends ElementAlternativeSignatureData {
-    private JetType altReturnType;
+    private KtType altReturnType;
 
     public AlternativeFieldSignatureData(
             @NotNull JavaField field,
-            @NotNull JetType originalReturnType,
+            @NotNull KtType originalReturnType,
             @NotNull Project project,
             boolean isVar
     ) {
@@ -45,7 +45,7 @@ public class AlternativeFieldSignatureData extends ElementAlternativeSignatureDa
         }
 
         setAnnotated(true);
-        JetProperty altPropertyDeclaration = JetPsiFactoryKt.JetPsiFactory(project).createProperty(signature);
+        KtProperty altPropertyDeclaration = KtPsiFactoryKt.KtPsiFactory(project).createProperty(signature);
 
         try {
             checkForSyntaxErrors(altPropertyDeclaration);
@@ -59,12 +59,12 @@ public class AlternativeFieldSignatureData extends ElementAlternativeSignatureDa
     }
 
     @NotNull
-    public JetType getReturnType() {
+    public KtType getReturnType() {
         checkForErrors();
         return altReturnType;
     }
 
-    private static void checkFieldAnnotation(@NotNull JetProperty altProperty, @NotNull JavaField field, boolean isVar) {
+    private static void checkFieldAnnotation(@NotNull KtProperty altProperty, @NotNull JavaField field, boolean isVar) {
         if (!ComparatorUtil.equalsNullable(field.getName().asString(), altProperty.getName())) {
             throw new AlternativeSignatureMismatchException("Field name mismatch, original: %s, alternative: %s",
                                                             field.getName().asString(), altProperty.getName());
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeMethodSignatureData.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeMethodSignatureData.java
index a3c623c1f8d..a95aa938c44 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeMethodSignatureData.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeMethodSignatureData.java
@@ -32,11 +32,11 @@ import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolverKt;
 import org.jetbrains.kotlin.resolve.jvm.JavaResolverUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.kotlin.types.Variance;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.typeUtil.TypeUtilsKt;
 
 import java.util.ArrayList;
@@ -49,20 +49,20 @@ import static org.jetbrains.kotlin.load.java.components.TypeUsage.UPPER_BOUND;
 import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.getBuiltIns;
 
 public class AlternativeMethodSignatureData extends ElementAlternativeSignatureData {
-    private final JetNamedFunction altFunDeclaration;
+    private final KtNamedFunction altFunDeclaration;
 
     private List<ValueParameterDescriptor> altValueParameters;
-    private JetType altReturnType;
+    private KtType altReturnType;
     private List<TypeParameterDescriptor> altTypeParameters;
 
     private Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> originalToAltTypeParameters;
 
     public AlternativeMethodSignatureData(
             @NotNull JavaMember methodOrConstructor,
-            @Nullable JetType receiverType,
+            @Nullable KtType receiverType,
             @NotNull Project project,
             @NotNull List<ValueParameterDescriptor> valueParameters,
-            @Nullable JetType originalReturnType,
+            @Nullable KtType originalReturnType,
             @NotNull List<TypeParameterDescriptor> methodTypeParameters,
             boolean hasSuperMethods
     ) {
@@ -79,7 +79,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
         }
 
         setAnnotated(true);
-        altFunDeclaration = JetPsiFactoryKt.JetPsiFactory(project).createFunction(signature);
+        altFunDeclaration = KtPsiFactoryKt.KtPsiFactory(project).createFunction(signature);
 
         originalToAltTypeParameters = JavaResolverUtils.recreateTypeParametersAndReturnMapping(methodTypeParameters, null);
 
@@ -119,7 +119,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
     private void checkParameterAndReturnTypesForOverridingMethods(
             @NotNull List<ValueParameterDescriptor> valueParameters,
             @NotNull List<TypeParameterDescriptor> methodTypeParameters,
-            @Nullable JetType returnType
+            @Nullable KtType returnType
     ) {
         if (JavaDescriptorResolverKt.getPLATFORM_TYPES()) return;
         TypeSubstitutor substitutor = JavaResolverUtils.createSubstitutorForTypeParameters(originalToAltTypeParameters);
@@ -128,7 +128,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
             int index = parameter.getIndex();
             ValueParameterDescriptor altParameter = altValueParameters.get(index);
 
-            JetType substituted = substitutor.substitute(parameter.getType(), Variance.INVARIANT);
+            KtType substituted = substitutor.substitute(parameter.getType(), Variance.INVARIANT);
             assert substituted != null;
 
             if (!TypeUtils.equalTypes(substituted, altParameter.getType())) {
@@ -143,7 +143,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
         for (TypeParameterDescriptor parameter : methodTypeParameters) {
             int index = parameter.getIndex();
 
-            JetType substituted = substitutor.substitute(parameter.getUpperBoundsAsType(), Variance.INVARIANT);
+            KtType substituted = substitutor.substitute(parameter.getUpperBoundsAsType(), Variance.INVARIANT);
             assert substituted != null;
 
             if (!TypeUtils.equalTypes(substituted, altTypeParameters.get(index).getUpperBoundsAsType())) {
@@ -154,10 +154,10 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
         }
 
         if (returnType != null) {
-            JetType substitutedReturnType = substitutor.substitute(returnType, Variance.INVARIANT);
+            KtType substitutedReturnType = substitutor.substitute(returnType, Variance.INVARIANT);
             assert substitutedReturnType != null;
 
-            if (!JetTypeChecker.DEFAULT.isSubtypeOf(altReturnType, substitutedReturnType)) {
+            if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(altReturnType, substitutedReturnType)) {
                 throw new AlternativeSignatureMismatchException(
                         "Return type is changed to not subtype for method which overrides another: " + altReturnType + ", was: " + returnType);
             }
@@ -171,7 +171,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
     }
 
     @Nullable
-    public JetType getReturnType() {
+    public KtType getReturnType() {
         checkForErrors();
         return altReturnType;
     }
@@ -191,16 +191,16 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
         List<ValueParameterDescriptor> altParamDescriptors = new ArrayList<ValueParameterDescriptor>(parameterDescriptors.size());
         for (int i = 0; i < parameterDescriptors.size(); i++) {
             ValueParameterDescriptor originalParameterDescriptor = parameterDescriptors.get(i);
-            JetParameter annotationValueParameter = altFunDeclaration.getValueParameters().get(i);
+            KtParameter annotationValueParameter = altFunDeclaration.getValueParameters().get(i);
 
             //noinspection ConstantConditions
-            JetTypeElement alternativeTypeElement = annotationValueParameter.getTypeReference().getTypeElement();
+            KtTypeElement alternativeTypeElement = annotationValueParameter.getTypeReference().getTypeElement();
             assert alternativeTypeElement != null;
 
-            JetType alternativeType;
-            JetType alternativeVarargElementType;
+            KtType alternativeType;
+            KtType alternativeVarargElementType;
 
-            JetType originalParamVarargElementType = originalParameterDescriptor.getVarargElementType();
+            KtType originalParamVarargElementType = originalParameterDescriptor.getVarargElementType();
             if (originalParamVarargElementType == null) {
                 if (annotationValueParameter.isVarArg()) {
                     throw new AlternativeSignatureMismatchException("Parameter in method signature is not vararg, but in alternative signature it is vararg");
@@ -251,10 +251,10 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
             TypeParameterDescriptor originalTypeParamDescriptor = typeParameters.get(i);
 
             TypeParameterDescriptorImpl altParamDescriptor = originalToAltTypeParameters.get(originalTypeParamDescriptor);
-            JetTypeParameter altTypeParameter = altFunDeclaration.getTypeParameters().get(i);
+            KtTypeParameter altTypeParameter = altFunDeclaration.getTypeParameters().get(i);
 
-            Set<JetType> originalUpperBounds = originalTypeParamDescriptor.getUpperBounds();
-            List<JetTypeReference> altUpperBounds = getUpperBounds(altFunDeclaration, altTypeParameter);
+            Set<KtType> originalUpperBounds = originalTypeParamDescriptor.getUpperBounds();
+            List<KtTypeReference> altUpperBounds = getUpperBounds(altFunDeclaration, altTypeParameter);
             if (altUpperBounds.size() != originalUpperBounds.size()) {
                 if (altUpperBounds.isEmpty()
                     && originalUpperBounds.size() == 1
@@ -274,9 +274,9 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
             }
             else {
                 int upperBoundIndex = 0;
-                for (JetType upperBound : originalUpperBounds) {
+                for (KtType upperBound : originalUpperBounds) {
 
-                    JetTypeElement altTypeElement = altUpperBounds.get(upperBoundIndex).getTypeElement();
+                    KtTypeElement altTypeElement = altUpperBounds.get(upperBoundIndex).getTypeElement();
                     assert altTypeElement != null;
 
                     altParamDescriptor.addUpperBound(TypeTransformingVisitor.computeType(altTypeElement, upperBound,
@@ -291,15 +291,15 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
     }
 
     @NotNull
-    private static List<JetTypeReference> getUpperBounds(@NotNull JetFunction function, @NotNull JetTypeParameter jetTypeParameter) {
-        List<JetTypeReference> result = new ArrayList<JetTypeReference>();
+    private static List<KtTypeReference> getUpperBounds(@NotNull KtFunction function, @NotNull KtTypeParameter jetTypeParameter) {
+        List<KtTypeReference> result = new ArrayList<KtTypeReference>();
         ContainerUtil.addIfNotNull(result, jetTypeParameter.getExtendsBound());
 
         Name name = jetTypeParameter.getNameAsName();
         if (name == null) return result;
 
-        for (JetTypeConstraint constraint : function.getTypeConstraints()) {
-            JetSimpleNameExpression parameterName = constraint.getSubjectTypeParameterName();
+        for (KtTypeConstraint constraint : function.getTypeConstraints()) {
+            KtSimpleNameExpression parameterName = constraint.getSubjectTypeParameterName();
             assert parameterName != null : "No parameter name in constraint " + constraint.getText();
             if (name.equals(parameterName.getReferencedNameAsName())) {
                 result.add(constraint.getBoundTypeReference());
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/ElementAlternativeSignatureData.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/ElementAlternativeSignatureData.java
index a511ae71bdc..a5debafeb78 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/ElementAlternativeSignatureData.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/ElementAlternativeSignatureData.java
@@ -23,11 +23,11 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
-import org.jetbrains.kotlin.psi.JetTypeElement;
-import org.jetbrains.kotlin.psi.JetTypeReference;
+import org.jetbrains.kotlin.psi.KtTypeElement;
+import org.jetbrains.kotlin.psi.KtTypeReference;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.AnalyzingUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.List;
 import java.util.Map;
@@ -86,9 +86,9 @@ public abstract class ElementAlternativeSignatureData {
         }
     }
 
-    protected static JetType computeReturnType(
-            @NotNull JetType originalType,
-            @Nullable JetTypeReference altReturnTypeReference,
+    protected static KtType computeReturnType(
+            @NotNull KtType originalType,
+            @Nullable KtTypeReference altReturnTypeReference,
             @NotNull Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> originalToAltTypeParameters) {
         if (altReturnTypeReference == null) {
             if (KotlinBuiltIns.isUnit(originalType)) {
@@ -101,7 +101,7 @@ public abstract class ElementAlternativeSignatureData {
             }
         }
 
-        JetTypeElement typeElement = altReturnTypeReference.getTypeElement();
+        KtTypeElement typeElement = altReturnTypeReference.getTypeElement();
         assert (typeElement != null);
 
         return TypeTransformingVisitor.computeType(typeElement, originalType, originalToAltTypeParameters, MEMBER_SIGNATURE_COVARIANT);
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/PropagationHeuristics.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/PropagationHeuristics.java
index 603cc886287..4dd4fe8b2ed 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/PropagationHeuristics.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/PropagationHeuristics.java
@@ -21,16 +21,15 @@ import com.intellij.openapi.util.Condition;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.types.JetType;
-import org.jetbrains.kotlin.types.JetTypeImpl;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
+import org.jetbrains.kotlin.types.KtType;
+import org.jetbrains.kotlin.types.KtTypeImpl;
 import org.jetbrains.kotlin.types.TypeProjectionImpl;
 import org.jetbrains.kotlin.types.Variance;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.Arrays;
 import java.util.List;
@@ -42,7 +41,7 @@ class PropagationHeuristics {
     // Checks for case when method returning Super[] is overridden with method returning Sub[]
     static void checkArrayInReturnType(
             @NotNull SignaturesPropagationData data,
-            @NotNull JetType type,
+            @NotNull KtType type,
             @NotNull List<SignaturesPropagationData.TypeAndVariance> typesFromSuper
     ) {
         List<SignaturesPropagationData.TypeAndVariance> arrayTypesFromSuper = ContainerUtil
@@ -56,19 +55,19 @@ class PropagationHeuristics {
             assert type.getArguments().size() == 1;
             if (type.getArguments().get(0).getProjectionKind() == Variance.INVARIANT) {
                 for (SignaturesPropagationData.TypeAndVariance typeAndVariance : arrayTypesFromSuper) {
-                    JetType arrayTypeFromSuper = typeAndVariance.type;
+                    KtType arrayTypeFromSuper = typeAndVariance.type;
                     assert arrayTypeFromSuper.getArguments().size() == 1;
-                    JetType elementTypeInSuper = arrayTypeFromSuper.getArguments().get(0).getType();
-                    JetType elementType = type.getArguments().get(0).getType();
+                    KtType elementTypeInSuper = arrayTypeFromSuper.getArguments().get(0).getType();
+                    KtType elementType = type.getArguments().get(0).getType();
 
-                    if (JetTypeChecker.DEFAULT.isSubtypeOf(elementType, elementTypeInSuper)
-                        && !JetTypeChecker.DEFAULT.equalTypes(elementType, elementTypeInSuper)) {
-                        JetTypeImpl betterTypeInSuper = JetTypeImpl.create(
+                    if (KotlinTypeChecker.DEFAULT.isSubtypeOf(elementType, elementTypeInSuper)
+                        && !KotlinTypeChecker.DEFAULT.equalTypes(elementType, elementTypeInSuper)) {
+                        KtTypeImpl betterTypeInSuper = KtTypeImpl.create(
                                 arrayTypeFromSuper.getAnnotations(),
                                 arrayTypeFromSuper.getConstructor(),
                                 arrayTypeFromSuper.isMarkedNullable(),
                                 Arrays.asList(new TypeProjectionImpl(Variance.OUT_VARIANCE, elementTypeInSuper)),
-                                JetScope.Empty.INSTANCE$);
+                                KtScope.Empty.INSTANCE$);
 
                         data.reportError("Return type is not a subtype of overridden method. " +
                                          "To fix it, add annotation with Kotlin signature to super method with type "
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java
index 9840a884b1d..bca515c88af 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.resolve.jvm.JavaResolverUtils;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.KotlinToJvmSignatureMapper;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.KotlinToJvmSignatureMapperKt;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.types.*;
 
 import java.util.*;
@@ -66,7 +66,7 @@ public class SignaturesPropagationData {
     private final List<TypeParameterDescriptor> modifiedTypeParameters;
     private final ValueParameters modifiedValueParameters;
 
-    private final JetType modifiedReturnType;
+    private final KtType modifiedReturnType;
     private final List<String> signatureErrors = Lists.newArrayList();
     private final List<FunctionDescriptor> superFunctions;
     private final Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> autoTypeParameterToModified;
@@ -74,8 +74,8 @@ public class SignaturesPropagationData {
 
     public SignaturesPropagationData(
             @NotNull ClassDescriptor containingClass,
-            @NotNull JetType autoReturnType, // type built by JavaTypeTransformer from Java signature and @NotNull annotations
-            @Nullable JetType receiverType,
+            @NotNull KtType autoReturnType, // type built by JavaTypeTransformer from Java signature and @NotNull annotations
+            @Nullable KtType receiverType,
             @NotNull List<ValueParameterDescriptor> autoValueParameters, // descriptors built by parameters resolver
             @NotNull List<TypeParameterDescriptor> autoTypeParameters, // descriptors built by signature resolver
             @NotNull JavaMethod method
@@ -97,8 +97,8 @@ public class SignaturesPropagationData {
     @NotNull
     private static JavaMethodDescriptor createAutoMethodDescriptor(
             @NotNull ClassDescriptor containingClass,
-            @NotNull JavaMethod method, JetType autoReturnType,
-            @Nullable JetType receiverType,
+            @NotNull JavaMethod method, KtType autoReturnType,
+            @Nullable KtType receiverType,
             @NotNull List<ValueParameterDescriptor> autoValueParameters,
             @NotNull List<TypeParameterDescriptor> autoTypeParameters
     ) {
@@ -125,7 +125,7 @@ public class SignaturesPropagationData {
         return modifiedTypeParameters;
     }
 
-    public JetType getModifiedReceiverType() {
+    public KtType getModifiedReceiverType() {
         return modifiedValueParameters.receiverType;
     }
 
@@ -137,7 +137,7 @@ public class SignaturesPropagationData {
         return modifiedValueParameters.hasStableParameterNames;
     }
 
-    public JetType getModifiedReturnType() {
+    public KtType getModifiedReturnType() {
         return modifiedReturnType;
     }
 
@@ -153,8 +153,8 @@ public class SignaturesPropagationData {
         signatureErrors.add(error);
     }
 
-    private JetType modifyReturnTypeAccordingToSuperMethods(
-            @NotNull JetType autoType // type built by JavaTypeTransformer
+    private KtType modifyReturnTypeAccordingToSuperMethods(
+            @NotNull KtType autoType // type built by JavaTypeTransformer
     ) {
         if (JavaDescriptorResolverKt.getPLATFORM_TYPES()) return autoType;
 
@@ -179,24 +179,24 @@ public class SignaturesPropagationData {
             int index = autoParameter.getIndex();
             TypeParameterDescriptorImpl modifiedTypeParameter = autoTypeParameterToModified.get(autoParameter);
 
-            List<Iterator<JetType>> upperBoundFromSuperFunctionsIterators = Lists.newArrayList();
+            List<Iterator<KtType>> upperBoundFromSuperFunctionsIterators = Lists.newArrayList();
             for (FunctionDescriptor superFunction : superFunctions) {
                 upperBoundFromSuperFunctionsIterators.add(superFunction.getTypeParameters().get(index).getUpperBounds().iterator());
             }
 
-            for (JetType autoUpperBound : autoParameter.getUpperBounds()) {
+            for (KtType autoUpperBound : autoParameter.getUpperBounds()) {
                 List<TypeAndVariance> upperBoundsFromSuperFunctions = Lists.newArrayList();
 
-                for (Iterator<JetType> iterator : upperBoundFromSuperFunctionsIterators) {
+                for (Iterator<KtType> iterator : upperBoundFromSuperFunctionsIterators) {
                     assert iterator.hasNext();
                     upperBoundsFromSuperFunctions.add(new TypeAndVariance(iterator.next(), INVARIANT));
                 }
 
-                JetType modifiedUpperBound = modifyTypeAccordingToSuperMethods(autoUpperBound, upperBoundsFromSuperFunctions, UPPER_BOUND);
+                KtType modifiedUpperBound = modifyTypeAccordingToSuperMethods(autoUpperBound, upperBoundsFromSuperFunctions, UPPER_BOUND);
                 modifiedTypeParameter.addUpperBound(modifiedUpperBound);
             }
 
-            for (Iterator<JetType> iterator : upperBoundFromSuperFunctionsIterators) {
+            for (Iterator<KtType> iterator : upperBoundFromSuperFunctionsIterators) {
                 assert !iterator.hasNext();
             }
 
@@ -208,14 +208,14 @@ public class SignaturesPropagationData {
     }
 
     private ValueParameters modifyValueParametersAccordingToSuperMethods(
-            @Nullable JetType receiverType,
+            @Nullable KtType receiverType,
             @NotNull List<ValueParameterDescriptor> parameters // descriptors built by parameters resolver
     ) {
         assert receiverType == null : "Parameters before propagation have receiver type," +
                                       " but propagation should be disabled for functions compiled from Kotlin in class: " +
                                       DescriptorUtils.getFqName(containingClass);
 
-        JetType resultReceiverType = null;
+        KtType resultReceiverType = null;
         List<ValueParameterDescriptor> resultParameters = new ArrayList<ValueParameterDescriptor>(parameters.size());
 
         boolean shouldBeExtension = checkIfShouldBeExtension();
@@ -239,9 +239,9 @@ public class SignaturesPropagationData {
 
             VarargCheckResult varargCheckResult = checkVarargInSuperFunctions(originalParam);
 
-            JetType altType = modifyTypeAccordingToSuperMethods(varargCheckResult.parameterType,
-                                                                convertToTypeVarianceList(typesFromSuperMethods),
-                                                                MEMBER_SIGNATURE_CONTRAVARIANT);
+            KtType altType = modifyTypeAccordingToSuperMethods(varargCheckResult.parameterType,
+                                                               convertToTypeVarianceList(typesFromSuperMethods),
+                                                               MEMBER_SIGNATURE_CONTRAVARIANT);
 
             if (shouldBeExtension && originalIndex == 0) {
                 resultReceiverType = altType;
@@ -304,7 +304,7 @@ public class SignaturesPropagationData {
         // TODO: Add propagation for other kotlin descriptors (KT-3621)
         Name name = method.getName();
         JvmMethodSignature autoSignature = SIGNATURE_MAPPER.mapToJvmMethodSignature(autoMethodDescriptor);
-        for (JetType supertype : containingClass.getTypeConstructor().getSupertypes()) {
+        for (KtType supertype : containingClass.getTypeConstructor().getSupertypes()) {
             Collection<FunctionDescriptor> superFunctionCandidates = supertype.getMemberScope().getFunctions(name, NoLookupLocation.WHEN_GET_SUPER_MEMBERS);
             for (FunctionDescriptor candidate : superFunctionCandidates) {
                 JvmMethodSignature candidateSignature = SIGNATURE_MAPPER.mapToJvmMethodSignature(candidate);
@@ -365,8 +365,8 @@ public class SignaturesPropagationData {
             }
         }
 
-        JetType originalVarargElementType = originalParam.getVarargElementType();
-        JetType originalType = originalParam.getType();
+        KtType originalVarargElementType = originalParam.getVarargElementType();
+        KtType originalType = originalParam.getType();
 
         if (someSupersVararg && someSupersNotVararg) {
             reportError("Incompatible super methods: some have vararg parameter, some have not");
@@ -389,8 +389,8 @@ public class SignaturesPropagationData {
     }
 
     @NotNull
-    private JetType modifyTypeAccordingToSuperMethods(
-            @NotNull JetType autoType,
+    private KtType modifyTypeAccordingToSuperMethods(
+            @NotNull KtType autoType,
             @NotNull List<TypeAndVariance> typesFromSuper,
             @NotNull TypeUsage howThisTypeIsUsed
     ) {
@@ -401,7 +401,7 @@ public class SignaturesPropagationData {
         boolean resultNullable = typeMustBeNullable(autoType, typesFromSuper, howThisTypeIsUsed);
         ClassifierDescriptor resultClassifier = modifyTypeClassifier(autoType, typesFromSuper);
         List<TypeProjection> resultArguments = getTypeArgsOfType(autoType, resultClassifier, typesFromSuper);
-        JetScope resultScope;
+        KtScope resultScope;
         if (resultClassifier instanceof ClassDescriptor) {
             resultScope = ((ClassDescriptor) resultClassifier).getMemberScope(resultArguments);
         }
@@ -409,11 +409,11 @@ public class SignaturesPropagationData {
             resultScope = autoType.getMemberScope();
         }
 
-        JetType type = JetTypeImpl.create(autoType.getAnnotations(),
-                                           resultClassifier.getTypeConstructor(),
-                                           resultNullable,
-                                           resultArguments,
-                                           resultScope);
+        KtType type = KtTypeImpl.create(autoType.getAnnotations(),
+                                        resultClassifier.getTypeConstructor(),
+                                        resultNullable,
+                                        resultArguments,
+                                        resultScope);
 
         PropagationHeuristics.checkArrayInReturnType(this, type, typesFromSuper);
         return type;
@@ -421,7 +421,7 @@ public class SignaturesPropagationData {
 
     @NotNull
     private List<TypeProjection> getTypeArgsOfType(
-            @NotNull JetType autoType,
+            @NotNull KtType autoType,
             @NotNull ClassifierDescriptor classifier,
             @NotNull List<TypeAndVariance> typesFromSuper
     ) {
@@ -444,11 +444,11 @@ public class SignaturesPropagationData {
         for (TypeParameterDescriptor parameter : classifier.getTypeConstructor().getParameters()) {
             TypeProjection argument = autoArguments.get(parameter.getIndex());
 
-            JetType argumentType = argument.getType();
+            KtType argumentType = argument.getType();
             List<TypeProjectionAndVariance> projectionsFromSuper = typeArgumentsFromSuper.get(parameter.getIndex());
             List<TypeAndVariance> argTypesFromSuper = getTypes(projectionsFromSuper);
 
-            JetType type = modifyTypeAccordingToSuperMethods(argumentType, argTypesFromSuper, TYPE_ARGUMENT);
+            KtType type = modifyTypeAccordingToSuperMethods(argumentType, argTypesFromSuper, TYPE_ARGUMENT);
             Variance projectionKind = calculateArgumentProjectionKindFromSuper(argument, projectionsFromSuper);
 
             resultArguments.add(new TypeProjectionImpl(projectionKind, type));
@@ -567,7 +567,7 @@ public class SignaturesPropagationData {
     }
 
     private boolean typeMustBeNullable(
-            @NotNull JetType autoType,
+            @NotNull KtType autoType,
             @NotNull List<TypeAndVariance> typesFromSuper,
             @NotNull TypeUsage howThisTypeIsUsed
     ) {
@@ -611,7 +611,7 @@ public class SignaturesPropagationData {
 
     @NotNull
     private ClassifierDescriptor modifyTypeClassifier(
-            @NotNull JetType autoType,
+            @NotNull KtType autoType,
             @NotNull List<TypeAndVariance> typesFromSuper
     ) {
         ClassifierDescriptor classifier = autoType.getConstructor().getDeclarationDescriptor();
@@ -666,15 +666,15 @@ public class SignaturesPropagationData {
         return fixed != null ? fixed : classifier;
     }
 
-    private static boolean isArrayType(@NotNull JetType type) {
+    private static boolean isArrayType(@NotNull KtType type) {
         return KotlinBuiltIns.isArray(type) || KotlinBuiltIns.isPrimitiveArray(type);
     }
 
     private static class VarargCheckResult {
-        public final JetType parameterType;
+        public final KtType parameterType;
         public final boolean isVararg;
 
-        public VarargCheckResult(JetType parameterType, boolean isVararg) {
+        public VarargCheckResult(KtType parameterType, boolean isVararg) {
             this.parameterType = parameterType;
             this.isVararg = isVararg;
         }
@@ -695,10 +695,10 @@ public class SignaturesPropagationData {
     }
 
     static class TypeAndVariance {
-        public final JetType type;
+        public final KtType type;
         public final Variance varianceOfPosition;
 
-        public TypeAndVariance(JetType type, Variance varianceOfPosition) {
+        public TypeAndVariance(KtType type, Variance varianceOfPosition) {
             this.type = type;
             this.varianceOfPosition = varianceOfPosition;
         }
@@ -709,22 +709,22 @@ public class SignaturesPropagationData {
     }
 
     private static class TypeAndName {
-        public final JetType type;
+        public final KtType type;
         public final Name name;
 
-        public TypeAndName(JetType type, Name name) {
+        public TypeAndName(KtType type, Name name) {
             this.type = type;
             this.name = name;
         }
     }
 
     private static class ValueParameters {
-        private final JetType receiverType;
+        private final KtType receiverType;
         private final List<ValueParameterDescriptor> descriptors;
         private final boolean hasStableParameterNames;
 
         public ValueParameters(
-                @Nullable JetType receiverType,
+                @Nullable KtType receiverType,
                 @NotNull List<ValueParameterDescriptor> descriptors,
                 boolean hasStableParameterNames
         ) {
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/TypeTransformingVisitor.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/TypeTransformingVisitor.java
index 50b7a947e0a..52788172454 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/TypeTransformingVisitor.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/TypeTransformingVisitor.java
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.TypeResolver;
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolverKt;
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.types.*;
 
 import java.util.*;
@@ -42,16 +42,16 @@ import java.util.*;
 import static org.jetbrains.kotlin.load.java.components.TypeUsage.TYPE_ARGUMENT;
 import static org.jetbrains.kotlin.types.Variance.INVARIANT;
 
-public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
+public class TypeTransformingVisitor extends KtVisitor<KtType, Void> {
     private static boolean strictMode = false;
 
-    private final JetType originalType;
+    private final KtType originalType;
     private final Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> originalToAltTypeParameters;
 
     private final TypeUsage typeUsage;
 
     private TypeTransformingVisitor(
-            JetType originalType,
+            KtType originalType,
             Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> originalToAltTypeParameters,
             TypeUsage typeUsage
     ) {
@@ -61,30 +61,30 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
     }
 
     @NotNull
-    public static JetType computeType(
-            @NotNull JetTypeElement alternativeTypeElement,
-            @NotNull JetType originalType,
+    public static KtType computeType(
+            @NotNull KtTypeElement alternativeTypeElement,
+            @NotNull KtType originalType,
             @NotNull Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> originalToAltTypeParameters,
             @NotNull TypeUsage typeUsage
     ) {
-        JetType computedType = alternativeTypeElement.accept(new TypeTransformingVisitor(originalType, originalToAltTypeParameters, typeUsage), null);
+        KtType computedType = alternativeTypeElement.accept(new TypeTransformingVisitor(originalType, originalToAltTypeParameters, typeUsage), null);
         assert (computedType != null);
         return computedType;
     }
 
     @Override
-    public JetType visitNullableType(@NotNull JetNullableType nullableType, Void aVoid) {
+    public KtType visitNullableType(@NotNull KtNullableType nullableType, Void aVoid) {
         if (!TypeUtils.isNullableType(originalType) && typeUsage != TYPE_ARGUMENT) {
             throw new AlternativeSignatureMismatchException("Auto type '%s' is not-null, while type in alternative signature is nullable: '%s'",
                  DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(originalType), nullableType.getText());
         }
-        JetTypeElement innerType = nullableType.getInnerType();
+        KtTypeElement innerType = nullableType.getInnerType();
         assert innerType != null : "Syntax error: " + nullableType.getText();
         return TypeUtils.makeNullable(computeType(innerType, originalType, originalToAltTypeParameters, typeUsage));
     }
 
     @Override
-    public JetType visitFunctionType(@NotNull JetFunctionType type, Void data) {
+    public KtType visitFunctionType(@NotNull KtFunctionType type, Void data) {
         KotlinBuiltIns builtIns = JvmPlatform.INSTANCE$.getBuiltIns();
         return visitCommonType(type.getReceiverTypeReference() == null
                 ? builtIns.getFunction(type.getParameters().size())
@@ -92,8 +92,8 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
     }
 
     @Override
-    public JetType visitUserType(@NotNull JetUserType type, Void data) {
-        JetUserType qualifier = type.getQualifier();
+    public KtType visitUserType(@NotNull KtUserType type, Void data) {
+        KtUserType qualifier = type.getQualifier();
 
         //noinspection ConstantConditions
         String shortName = type.getReferenceExpression().getReferencedName();
@@ -102,12 +102,12 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
         return visitCommonType(longName, type);
     }
 
-    private JetType visitCommonType(@NotNull ClassDescriptor classDescriptor, @NotNull JetTypeElement type) {
+    private KtType visitCommonType(@NotNull ClassDescriptor classDescriptor, @NotNull KtTypeElement type) {
         return visitCommonType(DescriptorUtils.getFqNameSafe(classDescriptor).asString(), type);
     }
 
     @NotNull
-    private JetType visitCommonType(@NotNull String qualifiedName, @NotNull JetTypeElement type) {
+    private KtType visitCommonType(@NotNull String qualifiedName, @NotNull KtTypeElement type) {
         if (originalType.isError()) {
             return originalType;
         }
@@ -148,7 +148,7 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
             altArguments.add(getAltArgument(type, typeConstructor, i, arguments.get(i)));
         }
 
-        JetScope memberScope;
+        KtScope memberScope;
         if (typeConstructorClassifier instanceof TypeParameterDescriptor) {
             memberScope = ((TypeParameterDescriptor) typeConstructorClassifier).getUpperBoundsAsType().getMemberScope();
         }
@@ -159,35 +159,35 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
             throw new AssertionError("Unexpected class of type constructor classifier "
                                      + (typeConstructorClassifier == null ? "null" : typeConstructorClassifier.getClass().getName()));
         }
-        return JetTypeImpl.create(originalType.getAnnotations(), typeConstructor, false, altArguments, memberScope);
+        return KtTypeImpl.create(originalType.getAnnotations(), typeConstructor, false, altArguments, memberScope);
     }
 
     @NotNull
     private TypeProjection getAltArgument(
-            @NotNull JetTypeElement type,
+            @NotNull KtTypeElement type,
             @NotNull TypeConstructor typeConstructor,
             int i,
             @NotNull TypeProjection originalArgument
     ) {
-        JetTypeReference typeReference = type.getTypeArgumentsAsTypes().get(i); // process both function type and user type
+        KtTypeReference typeReference = type.getTypeArgumentsAsTypes().get(i); // process both function type and user type
 
         if (typeReference == null) {
             // star projection
-            assert type instanceof JetUserType
-                   && ((JetUserType) type).getTypeArguments().get(i).getProjectionKind() == JetProjectionKind.STAR;
+            assert type instanceof KtUserType
+                   && ((KtUserType) type).getTypeArguments().get(i).getProjectionKind() == KtProjectionKind.STAR;
 
             return originalArgument;
         }
 
-        JetTypeElement argumentAlternativeTypeElement = typeReference.getTypeElement();
+        KtTypeElement argumentAlternativeTypeElement = typeReference.getTypeElement();
         assert argumentAlternativeTypeElement != null;
 
         TypeParameterDescriptor parameter = typeConstructor.getParameters().get(i);
-        JetType alternativeArgumentType = computeType(argumentAlternativeTypeElement, originalArgument.getType(), originalToAltTypeParameters, TYPE_ARGUMENT);
+        KtType alternativeArgumentType = computeType(argumentAlternativeTypeElement, originalArgument.getType(), originalToAltTypeParameters, TYPE_ARGUMENT);
         Variance projectionKind = originalArgument.getProjectionKind();
         Variance altProjectionKind;
-        if (type instanceof JetUserType) {
-            JetTypeProjection typeProjection = ((JetUserType) type).getTypeArguments().get(i);
+        if (type instanceof KtUserType) {
+            KtTypeProjection typeProjection = ((KtUserType) type).getTypeArguments().get(i);
             altProjectionKind = TypeResolver.resolveProjectionKind(typeProjection.getProjectionKind());
             if (altProjectionKind != projectionKind && projectionKind != Variance.INVARIANT && !JavaDescriptorResolverKt.getPLATFORM_TYPES()) {
                 throw new AlternativeSignatureMismatchException("Projection kind mismatch, actual: %s, in alternative signature: %s",
@@ -234,7 +234,7 @@ public class TypeTransformingVisitor extends JetVisitor<JetType, Void> {
     }
 
     @Override
-    public JetType visitSelfType(@NotNull JetSelfType type, Void data) {
+    public KtType visitSelfType(@NotNull KtSelfType type, Void data) {
         throw new UnsupportedOperationException("Self-types are not supported yet");
     }
 
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JavaGenericVarianceViolationTypeChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JavaGenericVarianceViolationTypeChecker.kt
index 036e3ee171f..5187116d257 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JavaGenericVarianceViolationTypeChecker.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JavaGenericVarianceViolationTypeChecker.kt
@@ -18,14 +18,14 @@ package org.jetbrains.kotlin.resolve.jvm.platform
 
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.load.java.lazy.types.RawTypeTag
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker
 import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure
 
 public object JavaGenericVarianceViolationTypeChecker : AdditionalTypeChecker {
@@ -38,9 +38,9 @@ public object JavaGenericVarianceViolationTypeChecker : AdditionalTypeChecker {
     // val x: MutableList<String>
     // JavaClass.fillWithDefaultObjects(x) // using `x` after this call may lead to CCE
     override fun checkType(
-            expression: JetExpression,
-            expressionType: JetType,
-            expressionTypeWithSmartCast: JetType,
+            expression: KtExpression,
+            expressionType: KtType,
+            expressionTypeWithSmartCast: KtType,
             c: ResolutionContext<*>
     ) {
         val expectedType = c.expectedType
@@ -82,7 +82,7 @@ public object JavaGenericVarianceViolationTypeChecker : AdditionalTypeChecker {
             if (lowerParameters[index].variance == Variance.INVARIANT
                 && upperParameters[index].variance == Variance.OUT_VARIANCE
                 && lowerArgument.projectionKind != Variance.OUT_VARIANCE
-                && !JetTypeChecker.DEFAULT.equalTypes(correspondingSubType.arguments[index].type, lowerArgument.type)
+                && !KotlinTypeChecker.DEFAULT.equalTypes(correspondingSubType.arguments[index].type, lowerArgument.type)
             ) {
                 c.trace.report(ErrorsJvm.JAVA_TYPE_MISMATCH.on(expression, expressionTypeWithSmartCast, expectedType))
             }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatform.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatform.kt
index f6365c604d2..d195ab6cf35 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatform.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatform.kt
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.resolve.ImportPath
 import org.jetbrains.kotlin.resolve.PlatformConfigurator
 import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import java.util.*
 
 public object JvmPlatform : TargetPlatform("JVM") {
@@ -50,8 +50,8 @@ private val DEFAULT_IMPORTS_FOR_JVM = ArrayList<ImportPath>().apply {
     add(ImportPath("kotlin.jvm.*"))
     add(ImportPath("kotlin.io.*"))
 
-    fun addAllClassifiersFromScope(scope: JetScope) {
-        for (descriptor in scope.getDescriptors(DescriptorKindFilter.CLASSIFIERS, JetScope.ALL_NAME_FILTER)) {
+    fun addAllClassifiersFromScope(scope: KtScope) {
+        for (descriptor in scope.getDescriptors(DescriptorKindFilter.CLASSIFIERS, KtScope.ALL_NAME_FILTER)) {
             add(ImportPath(DescriptorUtils.getFqNameSafe(descriptor), false))
         }
     }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt
index ea035835075..41da2de2d88 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt
@@ -28,8 +28,8 @@ import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
+import org.jetbrains.kotlin.resolve.scopes.KtScope
+import org.jetbrains.kotlin.resolve.scopes.KtScopeImpl
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
@@ -47,7 +47,7 @@ interface SyntheticJavaPropertyDescriptor : PropertyDescriptor {
     val setMethod: FunctionDescriptor?
 
     companion object {
-        fun findByGetterOrSetter(getterOrSetter: FunctionDescriptor, resolutionScope: JetScope): SyntheticJavaPropertyDescriptor? {
+        fun findByGetterOrSetter(getterOrSetter: FunctionDescriptor, resolutionScope: KtScope): SyntheticJavaPropertyDescriptor? {
             val name = getterOrSetter.getName()
             if (name.isSpecial()) return null
             val identifier = name.getIdentifier()
@@ -69,7 +69,7 @@ interface SyntheticJavaPropertyDescriptor : PropertyDescriptor {
     }
 }
 
-class JavaSyntheticPropertiesScope(storageManager: StorageManager) : JetScopeImpl() {
+class JavaSyntheticPropertiesScope(storageManager: StorageManager) : KtScopeImpl() {
     private val syntheticPropertyInClass = storageManager.createMemoizedFunctionWithNullableValues<Pair<ClassDescriptor, Name>, PropertyDescriptor> { pair ->
         syntheticPropertyInClassNotCached(pair.first, pair.second)
     }
@@ -130,7 +130,7 @@ class JavaSyntheticPropertiesScope(storageManager: StorageManager) : JetScopeImp
         return null
     }
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor> {
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor> {
         //TODO: use location parameter!
 
         var result: SmartList<PropertyDescriptor>? = null
@@ -162,7 +162,7 @@ class JavaSyntheticPropertiesScope(storageManager: StorageManager) : JetScopeImp
         return result
     }
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor> {
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>): Collection<PropertyDescriptor> {
         val result = ArrayList<PropertyDescriptor>()
         val processedTypes = HashSet<TypeConstructor>()
         receiverTypes.forEach { result.collectSyntheticProperties(it.constructor, processedTypes) }
@@ -253,7 +253,7 @@ class JavaSyntheticPropertiesScope(storageManager: StorageManager) : JetScopeImp
             private set
 
         companion object {
-            fun create(ownerClass: ClassDescriptor, getMethod: FunctionDescriptor, setMethod: FunctionDescriptor?, name: Name, type: JetType): MyPropertyDescriptor {
+            fun create(ownerClass: ClassDescriptor, getMethod: FunctionDescriptor, setMethod: FunctionDescriptor?, name: Name, type: KtType): MyPropertyDescriptor {
                 val visibility = syntheticExtensionVisibility(getMethod)
                 val descriptor = MyPropertyDescriptor(DescriptorUtils.getContainingModule(ownerClass),
                                                       null,
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/SamAdapterFunctionsScope.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/SamAdapterFunctionsScope.kt
index 85697d95031..dd11a86584a 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/SamAdapterFunctionsScope.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/SamAdapterFunctionsScope.kt
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.parentsWithSelf
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.*
 import java.util.*
@@ -37,7 +37,7 @@ interface SamAdapterExtensionFunctionDescriptor : FunctionDescriptor {
     val sourceFunction: FunctionDescriptor
 }
 
-class SamAdapterFunctionsScope(storageManager: StorageManager) : JetScope by JetScope.Empty {
+class SamAdapterFunctionsScope(storageManager: StorageManager) : KtScope by KtScope.Empty {
     private val extensionForFunction = storageManager.createMemoizedFunctionWithNullableValues<FunctionDescriptor, FunctionDescriptor> { function ->
         extensionForFunctionNotCached(function)
     }
@@ -52,7 +52,7 @@ class SamAdapterFunctionsScope(storageManager: StorageManager) : JetScope by Jet
         return MyFunctionDescriptor.create(enhancedFunction)
     }
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
         var result: SmartList<FunctionDescriptor>? = null
         for (type in receiverTypes) {
             for (function in type.memberScope.getFunctions(name, location)) {
@@ -72,7 +72,7 @@ class SamAdapterFunctionsScope(storageManager: StorageManager) : JetScope by Jet
         }
     }
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>): Collection<FunctionDescriptor> {
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>): Collection<FunctionDescriptor> {
         return receiverTypes.flatMapTo(LinkedHashSet<FunctionDescriptor>()) { type ->
             type.memberScope.getDescriptors(DescriptorKindFilter.FUNCTIONS)
                     .filterIsInstance<FunctionDescriptor>()
@@ -156,8 +156,8 @@ class SamAdapterFunctionsScope(storageManager: StorageManager) : JetScope by Jet
                 copyOverrides: Boolean,
                 kind: CallableMemberDescriptor.Kind,
                 newValueParameterDescriptors: MutableList<ValueParameterDescriptor>,
-                newExtensionReceiverParameterType: JetType?,
-                newReturnType: JetType
+                newExtensionReceiverParameterType: KtType?,
+                newReturnType: KtType
         ): FunctionDescriptor? {
             val descriptor = super<SimpleFunctionDescriptorImpl>.doSubstitute(
                     originalSubstitutor, newOwner, newModality, newVisibility,
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/JetNodeTypes.java b/compiler/frontend/src/org/jetbrains/kotlin/JetNodeTypes.java
deleted file mode 100644
index 60bb1368326..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/JetNodeTypes.java
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin;
-
-import com.intellij.psi.tree.IElementType;
-import com.intellij.psi.tree.IFileElementType;
-import org.jetbrains.kotlin.idea.KotlinLanguage;
-import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
-
-public interface JetNodeTypes {
-    IFileElementType JET_FILE = new IFileElementType(KotlinLanguage.INSTANCE);
-
-    IElementType CLASS     = JetStubElementTypes.CLASS;
-    IElementType FUN       = JetStubElementTypes.FUNCTION;
-    IElementType PROPERTY  = JetStubElementTypes.PROPERTY;
-    IElementType MULTI_VARIABLE_DECLARATION  = new JetNodeType("MULTI_VARIABLE_DECLARATION", JetMultiDeclaration.class);
-    IElementType MULTI_VARIABLE_DECLARATION_ENTRY = new JetNodeType("MULTI_VARIABLE_DECLARATION_ENTRY", JetMultiDeclarationEntry.class);
-
-    JetNodeType TYPEDEF    = new JetNodeType("TYPEDEF", JetTypedef.class);
-    IElementType OBJECT_DECLARATION = JetStubElementTypes.OBJECT_DECLARATION;
-    JetNodeType OBJECT_DECLARATION_NAME = new JetNodeType("OBJECT_DECLARATION_NAME", JetObjectDeclarationName.class);
-
-    IElementType ENUM_ENTRY            = JetStubElementTypes.ENUM_ENTRY;
-    IElementType ANONYMOUS_INITIALIZER = JetStubElementTypes.ANONYMOUS_INITIALIZER;
-    IElementType SECONDARY_CONSTRUCTOR  = JetStubElementTypes.SECONDARY_CONSTRUCTOR;
-    IElementType PRIMARY_CONSTRUCTOR    = JetStubElementTypes.PRIMARY_CONSTRUCTOR;
-
-    IElementType TYPE_PARAMETER_LIST                 = JetStubElementTypes.TYPE_PARAMETER_LIST;
-    IElementType TYPE_PARAMETER                      = JetStubElementTypes.TYPE_PARAMETER;
-    IElementType DELEGATION_SPECIFIER_LIST           = JetStubElementTypes.DELEGATION_SPECIFIER_LIST;
-    IElementType DELEGATOR_BY                        = JetStubElementTypes.DELEGATOR_BY;
-    IElementType DELEGATOR_SUPER_CALL                = JetStubElementTypes.DELEGATOR_SUPER_CALL;
-    IElementType DELEGATOR_SUPER_CLASS               = JetStubElementTypes.DELEGATOR_SUPER_CLASS;
-    JetNodeType PROPERTY_DELEGATE                    = new JetNodeType("PROPERTY_DELEGATE", JetPropertyDelegate.class);
-    IElementType CONSTRUCTOR_CALLEE                  = JetStubElementTypes.CONSTRUCTOR_CALLEE;
-    IElementType VALUE_PARAMETER_LIST               = JetStubElementTypes.VALUE_PARAMETER_LIST;
-    IElementType VALUE_PARAMETER                    = JetStubElementTypes.VALUE_PARAMETER;
-
-    IElementType CLASS_BODY                         = JetStubElementTypes.CLASS_BODY;
-    IElementType IMPORT_LIST                        = JetStubElementTypes.IMPORT_LIST;
-    IElementType FILE_ANNOTATION_LIST               = JetStubElementTypes.FILE_ANNOTATION_LIST;
-    IElementType IMPORT_DIRECTIVE                   = JetStubElementTypes.IMPORT_DIRECTIVE;
-    IElementType MODIFIER_LIST                      = JetStubElementTypes.MODIFIER_LIST;
-    IElementType ANNOTATION                         = JetStubElementTypes.ANNOTATION;
-    IElementType ANNOTATION_ENTRY                   = JetStubElementTypes.ANNOTATION_ENTRY;
-    IElementType ANNOTATION_TARGET                  = JetStubElementTypes.ANNOTATION_TARGET;
-
-    IElementType TYPE_ARGUMENT_LIST                 = JetStubElementTypes.TYPE_ARGUMENT_LIST;
-    JetNodeType VALUE_ARGUMENT_LIST                 = new JetNodeType("VALUE_ARGUMENT_LIST", JetValueArgumentList.class);
-    JetNodeType VALUE_ARGUMENT                      = new JetNodeType("VALUE_ARGUMENT", JetValueArgument.class);
-    JetNodeType FUNCTION_LITERAL_ARGUMENT           = new JetNodeType("FUNCTION_LITERAL_ARGUMENT", JetFunctionLiteralArgument.class);
-    JetNodeType VALUE_ARGUMENT_NAME                 = new JetNodeType("VALUE_ARGUMENT_NAME", JetValueArgumentName.class);
-    IElementType TYPE_REFERENCE                     = JetStubElementTypes.TYPE_REFERENCE;
-
-    IElementType USER_TYPE                = JetStubElementTypes.USER_TYPE;
-    IElementType DYNAMIC_TYPE             = JetStubElementTypes.DYNAMIC_TYPE;
-    IElementType FUNCTION_TYPE            = JetStubElementTypes.FUNCTION_TYPE;
-    IElementType FUNCTION_TYPE_RECEIVER   = JetStubElementTypes.FUNCTION_TYPE_RECEIVER;
-    JetNodeType SELF_TYPE     = new JetNodeType("SELF_TYPE", JetSelfType.class);
-    IElementType NULLABLE_TYPE            = JetStubElementTypes.NULLABLE_TYPE;
-    IElementType TYPE_PROJECTION          = JetStubElementTypes.TYPE_PROJECTION;
-
-    // TODO: review
-    IElementType PROPERTY_ACCESSOR       = JetStubElementTypes.PROPERTY_ACCESSOR;
-    IElementType INITIALIZER_LIST        = JetStubElementTypes.INITIALIZER_LIST;
-    IElementType TYPE_CONSTRAINT_LIST    = JetStubElementTypes.TYPE_CONSTRAINT_LIST;
-    IElementType TYPE_CONSTRAINT         = JetStubElementTypes.TYPE_CONSTRAINT;
-
-    IElementType CONSTRUCTOR_DELEGATION_CALL = new JetNodeType("CONSTRUCTOR_DELEGATION_CALL", JetConstructorDelegationCall.class);
-    JetNodeType CONSTRUCTOR_DELEGATION_REFERENCE =
-            new JetNodeType("CONSTRUCTOR_DELEGATION_REFERENCE", JetConstructorDelegationReferenceExpression.class);
-
-    // TODO: Not sure if we need separate NT for each kind of constants
-    JetNodeType NULL               = new JetNodeType("NULL", JetConstantExpression.class);
-    JetNodeType BOOLEAN_CONSTANT   = new JetNodeType("BOOLEAN_CONSTANT", JetConstantExpression.class);
-    JetNodeType FLOAT_CONSTANT     = new JetNodeType("FLOAT_CONSTANT", JetConstantExpression.class);
-    JetNodeType CHARACTER_CONSTANT = new JetNodeType("CHARACTER_CONSTANT", JetConstantExpression.class);
-    JetNodeType INTEGER_CONSTANT   = new JetNodeType("INTEGER_CONSTANT", JetConstantExpression.class);
-
-    JetNodeType STRING_TEMPLATE    = new JetNodeType("STRING_TEMPLATE", JetStringTemplateExpression.class);
-    JetNodeType LONG_STRING_TEMPLATE_ENTRY = new JetNodeType("LONG_STRING_TEMPLATE_ENTRY", JetBlockStringTemplateEntry.class);
-    JetNodeType SHORT_STRING_TEMPLATE_ENTRY = new JetNodeType("SHORT_STRING_TEMPLATE_ENTRY", JetSimpleNameStringTemplateEntry.class);
-    JetNodeType LITERAL_STRING_TEMPLATE_ENTRY = new JetNodeType("LITERAL_STRING_TEMPLATE_ENTRY", JetLiteralStringTemplateEntry.class);
-    JetNodeType ESCAPE_STRING_TEMPLATE_ENTRY = new JetNodeType("ESCAPE_STRING_TEMPLATE_ENTRY", JetEscapeStringTemplateEntry.class);
-
-    JetNodeType PARENTHESIZED             = new JetNodeType("PARENTHESIZED", JetParenthesizedExpression.class);
-    JetNodeType RETURN                    = new JetNodeType("RETURN", JetReturnExpression.class);
-    JetNodeType THROW                     = new JetNodeType("THROW", JetThrowExpression.class);
-    JetNodeType CONTINUE                  = new JetNodeType("CONTINUE", JetContinueExpression.class);
-    JetNodeType BREAK                     = new JetNodeType("BREAK", JetBreakExpression.class);
-    JetNodeType IF                        = new JetNodeType("IF", JetIfExpression.class);
-    JetNodeType CONDITION                 = new JetNodeType("CONDITION", JetContainerNode.class);
-    JetNodeType THEN                      = new JetNodeType("THEN", JetContainerNode.class);
-    JetNodeType ELSE                      = new JetNodeType("ELSE", JetContainerNode.class);
-    JetNodeType TRY                       = new JetNodeType("TRY", JetTryExpression.class);
-    JetNodeType CATCH                     = new JetNodeType("CATCH", JetCatchClause.class);
-    JetNodeType FINALLY                   = new JetNodeType("FINALLY", JetFinallySection.class);
-    JetNodeType FOR                       = new JetNodeType("FOR", JetForExpression.class);
-    JetNodeType WHILE                     = new JetNodeType("WHILE", JetWhileExpression.class);
-    JetNodeType DO_WHILE                  = new JetNodeType("DO_WHILE", JetDoWhileExpression.class);
-    JetNodeType LOOP_RANGE                = new JetNodeType("LOOP_RANGE", JetContainerNode.class);
-    JetNodeType BODY                      = new JetNodeType("BODY", JetContainerNode.class);
-    JetNodeType BLOCK                     = new JetNodeType("BLOCK", JetBlockExpression.class);
-    JetNodeType FUNCTION_LITERAL_EXPRESSION = new JetNodeType("FUNCTION_LITERAL_EXPRESSION", JetFunctionLiteralExpression.class);
-    JetNodeType FUNCTION_LITERAL          = new JetNodeType("FUNCTION_LITERAL", JetFunctionLiteral.class);
-    JetNodeType ANNOTATED_EXPRESSION      = new JetNodeType("ANNOTATED_EXPRESSION", JetAnnotatedExpression.class);
-
-    IElementType REFERENCE_EXPRESSION     = JetStubElementTypes.REFERENCE_EXPRESSION;
-    IElementType ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION = JetStubElementTypes.ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION;
-    JetNodeType OPERATION_REFERENCE       = new JetNodeType("OPERATION_REFERENCE", JetOperationReferenceExpression.class);
-    JetNodeType LABEL                     = new JetNodeType("LABEL", JetLabelReferenceExpression.class);
-
-    JetNodeType LABEL_QUALIFIER           = new JetNodeType("LABEL_QUALIFIER", JetContainerNode.class);
-
-    JetNodeType THIS_EXPRESSION           = new JetNodeType("THIS_EXPRESSION", JetThisExpression.class);
-    JetNodeType SUPER_EXPRESSION          = new JetNodeType("SUPER_EXPRESSION", JetSuperExpression.class);
-    JetNodeType BINARY_EXPRESSION         = new JetNodeType("BINARY_EXPRESSION", JetBinaryExpression.class);
-    JetNodeType BINARY_WITH_TYPE          = new JetNodeType("BINARY_WITH_TYPE", JetBinaryExpressionWithTypeRHS.class);
-    JetNodeType IS_EXPRESSION = new JetNodeType("IS_EXPRESSION", JetIsExpression.class); // TODO:
-    JetNodeType PREFIX_EXPRESSION         = new JetNodeType("PREFIX_EXPRESSION", JetPrefixExpression.class);
-    JetNodeType POSTFIX_EXPRESSION        = new JetNodeType("POSTFIX_EXPRESSION", JetPostfixExpression.class);
-    JetNodeType LABELED_EXPRESSION         = new JetNodeType("LABELED_EXPRESSION", JetLabeledExpression.class);
-    JetNodeType CALL_EXPRESSION           = new JetNodeType("CALL_EXPRESSION", JetCallExpression.class);
-    JetNodeType ARRAY_ACCESS_EXPRESSION   = new JetNodeType("ARRAY_ACCESS_EXPRESSION", JetArrayAccessExpression.class);
-    JetNodeType INDICES                   = new JetNodeType("INDICES", JetContainerNode.class);
-    IElementType DOT_QUALIFIED_EXPRESSION = JetStubElementTypes.DOT_QUALIFIED_EXPRESSION;
-    JetNodeType CALLABLE_REFERENCE_EXPRESSION = new JetNodeType("CALLABLE_REFERENCE_EXPRESSION", JetCallableReferenceExpression.class);
-    JetNodeType CLASS_LITERAL_EXPRESSION  = new JetNodeType("CLASS_LITERAL_EXPRESSION", JetClassLiteralExpression.class);
-    JetNodeType SAFE_ACCESS_EXPRESSION    = new JetNodeType("SAFE_ACCESS_EXPRESSION", JetSafeQualifiedExpression.class);
-
-    JetNodeType OBJECT_LITERAL            = new JetNodeType("OBJECT_LITERAL", JetObjectLiteralExpression.class);
-    JetNodeType ROOT_PACKAGE = new JetNodeType("ROOT_PACKAGE", JetRootPackageExpression.class);
-
-    JetNodeType WHEN                      = new JetNodeType("WHEN", JetWhenExpression.class);
-    JetNodeType WHEN_ENTRY                = new JetNodeType("WHEN_ENTRY", JetWhenEntry.class);
-
-    JetNodeType WHEN_CONDITION_IN_RANGE   = new JetNodeType("WHEN_CONDITION_IN_RANGE", JetWhenConditionInRange.class);
-    JetNodeType WHEN_CONDITION_IS_PATTERN = new JetNodeType("WHEN_CONDITION_IS_PATTERN", JetWhenConditionIsPattern.class);
-    JetNodeType WHEN_CONDITION_EXPRESSION = new JetNodeType("WHEN_CONDITION_WITH_EXPRESSION", JetWhenConditionWithExpression.class);
-
-    IElementType PACKAGE_DIRECTIVE = JetStubElementTypes.PACKAGE_DIRECTIVE;
-
-    // SCRIPT: script node type
-    JetNodeType SCRIPT = new JetNodeType("SCRIPT", JetScript.class);
-
-    IFileElementType TYPE_CODE_FRAGMENT = new JetTypeCodeFragmentType();
-    IFileElementType EXPRESSION_CODE_FRAGMENT = new JetExpressionCodeFragmentType();
-    IFileElementType BLOCK_CODE_FRAGMENT = new JetBlockCodeFragmentType();
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/JetNodeType.java b/compiler/frontend/src/org/jetbrains/kotlin/KtNodeType.java
similarity index 76%
rename from compiler/frontend/src/org/jetbrains/kotlin/JetNodeType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/KtNodeType.java
index 29e5a8b1682..453c0d9a54e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/JetNodeType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/KtNodeType.java
@@ -21,19 +21,19 @@ import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetElementImpl;
+import org.jetbrains.kotlin.psi.KtElement;
+import org.jetbrains.kotlin.psi.KtElementImpl;
 
 import java.lang.reflect.Constructor;
 
-public class JetNodeType extends IElementType {
-    private Constructor<? extends JetElement> myPsiFactory;
+public class KtNodeType extends IElementType {
+    private Constructor<? extends KtElement> myPsiFactory;
 
-    public JetNodeType(@NotNull @NonNls String debugName) {
+    public KtNodeType(@NotNull @NonNls String debugName) {
         this(debugName, null);
     }
 
-    public JetNodeType(@NotNull @NonNls String debugName, Class<? extends JetElement> psiClass) {
+    public KtNodeType(@NotNull @NonNls String debugName, Class<? extends KtElement> psiClass) {
         super(debugName, KotlinLanguage.INSTANCE);
         try {
             myPsiFactory = psiClass != null ? psiClass.getConstructor(ASTNode.class) : null;
@@ -42,12 +42,12 @@ public class JetNodeType extends IElementType {
         }
     }
 
-    public JetElement createPsi(ASTNode node) {
+    public KtElement createPsi(ASTNode node) {
         assert node.getElementType() == this;
 
         try {
             if (myPsiFactory == null) {
-                return new JetElementImpl(node);
+                return new KtElementImpl(node);
             }
             return myPsiFactory.newInstance(node);
         } catch (Exception e) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/KtNodeTypes.java b/compiler/frontend/src/org/jetbrains/kotlin/KtNodeTypes.java
new file mode 100644
index 00000000000..1e992aa02ba
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/KtNodeTypes.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin;
+
+import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.tree.IFileElementType;
+import org.jetbrains.kotlin.idea.KotlinLanguage;
+import org.jetbrains.kotlin.psi.*;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
+
+public interface KtNodeTypes {
+    IFileElementType JET_FILE = new IFileElementType(KotlinLanguage.INSTANCE);
+
+    IElementType CLASS     = KtStubElementTypes.CLASS;
+    IElementType FUN       = KtStubElementTypes.FUNCTION;
+    IElementType PROPERTY  = KtStubElementTypes.PROPERTY;
+    IElementType MULTI_VARIABLE_DECLARATION  = new KtNodeType("MULTI_VARIABLE_DECLARATION", KtMultiDeclaration.class);
+    IElementType MULTI_VARIABLE_DECLARATION_ENTRY = new KtNodeType("MULTI_VARIABLE_DECLARATION_ENTRY", KtMultiDeclarationEntry.class);
+
+    KtNodeType TYPEDEF    = new KtNodeType("TYPEDEF", KtTypedef.class);
+    IElementType OBJECT_DECLARATION = KtStubElementTypes.OBJECT_DECLARATION;
+    KtNodeType OBJECT_DECLARATION_NAME = new KtNodeType("OBJECT_DECLARATION_NAME", KtObjectDeclarationName.class);
+
+    IElementType ENUM_ENTRY            = KtStubElementTypes.ENUM_ENTRY;
+    IElementType ANONYMOUS_INITIALIZER = KtStubElementTypes.ANONYMOUS_INITIALIZER;
+    IElementType SECONDARY_CONSTRUCTOR  = KtStubElementTypes.SECONDARY_CONSTRUCTOR;
+    IElementType PRIMARY_CONSTRUCTOR    = KtStubElementTypes.PRIMARY_CONSTRUCTOR;
+
+    IElementType TYPE_PARAMETER_LIST                 = KtStubElementTypes.TYPE_PARAMETER_LIST;
+    IElementType TYPE_PARAMETER                      = KtStubElementTypes.TYPE_PARAMETER;
+    IElementType DELEGATION_SPECIFIER_LIST           = KtStubElementTypes.DELEGATION_SPECIFIER_LIST;
+    IElementType DELEGATOR_BY                        = KtStubElementTypes.DELEGATOR_BY;
+    IElementType DELEGATOR_SUPER_CALL                = KtStubElementTypes.DELEGATOR_SUPER_CALL;
+    IElementType DELEGATOR_SUPER_CLASS               = KtStubElementTypes.DELEGATOR_SUPER_CLASS;
+    KtNodeType PROPERTY_DELEGATE                    = new KtNodeType("PROPERTY_DELEGATE", KtPropertyDelegate.class);
+    IElementType CONSTRUCTOR_CALLEE                  = KtStubElementTypes.CONSTRUCTOR_CALLEE;
+    IElementType VALUE_PARAMETER_LIST               = KtStubElementTypes.VALUE_PARAMETER_LIST;
+    IElementType VALUE_PARAMETER                    = KtStubElementTypes.VALUE_PARAMETER;
+
+    IElementType CLASS_BODY                         = KtStubElementTypes.CLASS_BODY;
+    IElementType IMPORT_LIST                        = KtStubElementTypes.IMPORT_LIST;
+    IElementType FILE_ANNOTATION_LIST               = KtStubElementTypes.FILE_ANNOTATION_LIST;
+    IElementType IMPORT_DIRECTIVE                   = KtStubElementTypes.IMPORT_DIRECTIVE;
+    IElementType MODIFIER_LIST                      = KtStubElementTypes.MODIFIER_LIST;
+    IElementType ANNOTATION                         = KtStubElementTypes.ANNOTATION;
+    IElementType ANNOTATION_ENTRY                   = KtStubElementTypes.ANNOTATION_ENTRY;
+    IElementType ANNOTATION_TARGET                  = KtStubElementTypes.ANNOTATION_TARGET;
+
+    IElementType TYPE_ARGUMENT_LIST                 = KtStubElementTypes.TYPE_ARGUMENT_LIST;
+    KtNodeType VALUE_ARGUMENT_LIST                 = new KtNodeType("VALUE_ARGUMENT_LIST", KtValueArgumentList.class);
+    KtNodeType VALUE_ARGUMENT                      = new KtNodeType("VALUE_ARGUMENT", KtValueArgument.class);
+    KtNodeType FUNCTION_LITERAL_ARGUMENT           = new KtNodeType("FUNCTION_LITERAL_ARGUMENT", KtFunctionLiteralArgument.class);
+    KtNodeType VALUE_ARGUMENT_NAME                 = new KtNodeType("VALUE_ARGUMENT_NAME", KtValueArgumentName.class);
+    IElementType TYPE_REFERENCE                     = KtStubElementTypes.TYPE_REFERENCE;
+
+    IElementType USER_TYPE                = KtStubElementTypes.USER_TYPE;
+    IElementType DYNAMIC_TYPE             = KtStubElementTypes.DYNAMIC_TYPE;
+    IElementType FUNCTION_TYPE            = KtStubElementTypes.FUNCTION_TYPE;
+    IElementType FUNCTION_TYPE_RECEIVER   = KtStubElementTypes.FUNCTION_TYPE_RECEIVER;
+    KtNodeType SELF_TYPE     = new KtNodeType("SELF_TYPE", KtSelfType.class);
+    IElementType NULLABLE_TYPE            = KtStubElementTypes.NULLABLE_TYPE;
+    IElementType TYPE_PROJECTION          = KtStubElementTypes.TYPE_PROJECTION;
+
+    // TODO: review
+    IElementType PROPERTY_ACCESSOR       = KtStubElementTypes.PROPERTY_ACCESSOR;
+    IElementType INITIALIZER_LIST        = KtStubElementTypes.INITIALIZER_LIST;
+    IElementType TYPE_CONSTRAINT_LIST    = KtStubElementTypes.TYPE_CONSTRAINT_LIST;
+    IElementType TYPE_CONSTRAINT         = KtStubElementTypes.TYPE_CONSTRAINT;
+
+    IElementType CONSTRUCTOR_DELEGATION_CALL = new KtNodeType("CONSTRUCTOR_DELEGATION_CALL", KtConstructorDelegationCall.class);
+    KtNodeType CONSTRUCTOR_DELEGATION_REFERENCE =
+            new KtNodeType("CONSTRUCTOR_DELEGATION_REFERENCE", KtConstructorDelegationReferenceExpression.class);
+
+    // TODO: Not sure if we need separate NT for each kind of constants
+    KtNodeType NULL               = new KtNodeType("NULL", KtConstantExpression.class);
+    KtNodeType BOOLEAN_CONSTANT   = new KtNodeType("BOOLEAN_CONSTANT", KtConstantExpression.class);
+    KtNodeType FLOAT_CONSTANT     = new KtNodeType("FLOAT_CONSTANT", KtConstantExpression.class);
+    KtNodeType CHARACTER_CONSTANT = new KtNodeType("CHARACTER_CONSTANT", KtConstantExpression.class);
+    KtNodeType INTEGER_CONSTANT   = new KtNodeType("INTEGER_CONSTANT", KtConstantExpression.class);
+
+    KtNodeType STRING_TEMPLATE    = new KtNodeType("STRING_TEMPLATE", KtStringTemplateExpression.class);
+    KtNodeType LONG_STRING_TEMPLATE_ENTRY = new KtNodeType("LONG_STRING_TEMPLATE_ENTRY", KtBlockStringTemplateEntry.class);
+    KtNodeType SHORT_STRING_TEMPLATE_ENTRY = new KtNodeType("SHORT_STRING_TEMPLATE_ENTRY", KtSimpleNameStringTemplateEntry.class);
+    KtNodeType LITERAL_STRING_TEMPLATE_ENTRY = new KtNodeType("LITERAL_STRING_TEMPLATE_ENTRY", KtLiteralStringTemplateEntry.class);
+    KtNodeType ESCAPE_STRING_TEMPLATE_ENTRY = new KtNodeType("ESCAPE_STRING_TEMPLATE_ENTRY", KtEscapeStringTemplateEntry.class);
+
+    KtNodeType PARENTHESIZED             = new KtNodeType("PARENTHESIZED", KtParenthesizedExpression.class);
+    KtNodeType RETURN                    = new KtNodeType("RETURN", KtReturnExpression.class);
+    KtNodeType THROW                     = new KtNodeType("THROW", KtThrowExpression.class);
+    KtNodeType CONTINUE                  = new KtNodeType("CONTINUE", KtContinueExpression.class);
+    KtNodeType BREAK                     = new KtNodeType("BREAK", KtBreakExpression.class);
+    KtNodeType IF                        = new KtNodeType("IF", KtIfExpression.class);
+    KtNodeType CONDITION                 = new KtNodeType("CONDITION", KtContainerNode.class);
+    KtNodeType THEN                      = new KtNodeType("THEN", KtContainerNode.class);
+    KtNodeType ELSE                      = new KtNodeType("ELSE", KtContainerNode.class);
+    KtNodeType TRY                       = new KtNodeType("TRY", KtTryExpression.class);
+    KtNodeType CATCH                     = new KtNodeType("CATCH", KtCatchClause.class);
+    KtNodeType FINALLY                   = new KtNodeType("FINALLY", KtFinallySection.class);
+    KtNodeType FOR                       = new KtNodeType("FOR", KtForExpression.class);
+    KtNodeType WHILE                     = new KtNodeType("WHILE", KtWhileExpression.class);
+    KtNodeType DO_WHILE                  = new KtNodeType("DO_WHILE", KtDoWhileExpression.class);
+    KtNodeType LOOP_RANGE                = new KtNodeType("LOOP_RANGE", KtContainerNode.class);
+    KtNodeType BODY                      = new KtNodeType("BODY", KtContainerNode.class);
+    KtNodeType BLOCK                     = new KtNodeType("BLOCK", KtBlockExpression.class);
+    KtNodeType FUNCTION_LITERAL_EXPRESSION = new KtNodeType("FUNCTION_LITERAL_EXPRESSION", KtFunctionLiteralExpression.class);
+    KtNodeType FUNCTION_LITERAL          = new KtNodeType("FUNCTION_LITERAL", KtFunctionLiteral.class);
+    KtNodeType ANNOTATED_EXPRESSION      = new KtNodeType("ANNOTATED_EXPRESSION", KtAnnotatedExpression.class);
+
+    IElementType REFERENCE_EXPRESSION     = KtStubElementTypes.REFERENCE_EXPRESSION;
+    IElementType ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION = KtStubElementTypes.ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION;
+    KtNodeType OPERATION_REFERENCE       = new KtNodeType("OPERATION_REFERENCE", KtOperationReferenceExpression.class);
+    KtNodeType LABEL                     = new KtNodeType("LABEL", KtLabelReferenceExpression.class);
+
+    KtNodeType LABEL_QUALIFIER           = new KtNodeType("LABEL_QUALIFIER", KtContainerNode.class);
+
+    KtNodeType THIS_EXPRESSION           = new KtNodeType("THIS_EXPRESSION", KtThisExpression.class);
+    KtNodeType SUPER_EXPRESSION          = new KtNodeType("SUPER_EXPRESSION", KtSuperExpression.class);
+    KtNodeType BINARY_EXPRESSION         = new KtNodeType("BINARY_EXPRESSION", KtBinaryExpression.class);
+    KtNodeType BINARY_WITH_TYPE          = new KtNodeType("BINARY_WITH_TYPE", KtBinaryExpressionWithTypeRHS.class);
+    KtNodeType IS_EXPRESSION = new KtNodeType("IS_EXPRESSION", KtIsExpression.class); // TODO:
+    KtNodeType PREFIX_EXPRESSION         = new KtNodeType("PREFIX_EXPRESSION", KtPrefixExpression.class);
+    KtNodeType POSTFIX_EXPRESSION        = new KtNodeType("POSTFIX_EXPRESSION", KtPostfixExpression.class);
+    KtNodeType LABELED_EXPRESSION         = new KtNodeType("LABELED_EXPRESSION", KtLabeledExpression.class);
+    KtNodeType CALL_EXPRESSION           = new KtNodeType("CALL_EXPRESSION", KtCallExpression.class);
+    KtNodeType ARRAY_ACCESS_EXPRESSION   = new KtNodeType("ARRAY_ACCESS_EXPRESSION", KtArrayAccessExpression.class);
+    KtNodeType INDICES                   = new KtNodeType("INDICES", KtContainerNode.class);
+    IElementType DOT_QUALIFIED_EXPRESSION = KtStubElementTypes.DOT_QUALIFIED_EXPRESSION;
+    KtNodeType CALLABLE_REFERENCE_EXPRESSION = new KtNodeType("CALLABLE_REFERENCE_EXPRESSION", KtCallableReferenceExpression.class);
+    KtNodeType CLASS_LITERAL_EXPRESSION  = new KtNodeType("CLASS_LITERAL_EXPRESSION", KtClassLiteralExpression.class);
+    KtNodeType SAFE_ACCESS_EXPRESSION    = new KtNodeType("SAFE_ACCESS_EXPRESSION", KtSafeQualifiedExpression.class);
+
+    KtNodeType OBJECT_LITERAL            = new KtNodeType("OBJECT_LITERAL", KtObjectLiteralExpression.class);
+    KtNodeType ROOT_PACKAGE = new KtNodeType("ROOT_PACKAGE", KtRootPackageExpression.class);
+
+    KtNodeType WHEN                      = new KtNodeType("WHEN", KtWhenExpression.class);
+    KtNodeType WHEN_ENTRY                = new KtNodeType("WHEN_ENTRY", KtWhenEntry.class);
+
+    KtNodeType WHEN_CONDITION_IN_RANGE   = new KtNodeType("WHEN_CONDITION_IN_RANGE", KtWhenConditionInRange.class);
+    KtNodeType WHEN_CONDITION_IS_PATTERN = new KtNodeType("WHEN_CONDITION_IS_PATTERN", KtWhenConditionIsPattern.class);
+    KtNodeType WHEN_CONDITION_EXPRESSION = new KtNodeType("WHEN_CONDITION_WITH_EXPRESSION", KtWhenConditionWithExpression.class);
+
+    IElementType PACKAGE_DIRECTIVE = KtStubElementTypes.PACKAGE_DIRECTIVE;
+
+    // SCRIPT: script node type
+    KtNodeType SCRIPT = new KtNodeType("SCRIPT", KtScript.class);
+
+    IFileElementType TYPE_CODE_FRAGMENT = new KtTypeCodeFragmentType();
+    IFileElementType EXPRESSION_CODE_FRAGMENT = new KtExpressionCodeFragmentType();
+    IFileElementType BLOCK_CODE_FRAGMENT = new KtBlockCodeFragmentType();
+}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt
index f166d228efd..4641ed3d575 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.descriptors.impl.LazyModuleDependencies
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 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.TargetEnvironment
 import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.createModule
@@ -92,7 +92,7 @@ public class ResolverForProjectImpl<M : ModuleInfo>(
 }
 
 public data class ModuleContent(
-        public val syntheticFiles: Collection<JetFile>,
+        public val syntheticFiles: Collection<KtFile>,
         public val moduleContentScope: GlobalSearchScope
 )
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/BreakableBlockInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/BreakableBlockInfo.java
index f903d829b32..2d06c241368 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/BreakableBlockInfo.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/BreakableBlockInfo.java
@@ -17,18 +17,18 @@
 package org.jetbrains.kotlin.cfg;
 
 import com.google.common.collect.Sets;
-import org.jetbrains.kotlin.psi.JetElement;
+import org.jetbrains.kotlin.psi.KtElement;
 
 import java.util.Collections;
 import java.util.Set;
 
 public class BreakableBlockInfo extends BlockInfo {
-    private final JetElement element;
+    private final KtElement element;
     private final Label entryPoint;
     private final Label exitPoint;
     private final Set<Label> referablePoints = Sets.newHashSet();
 
-    public BreakableBlockInfo(JetElement element, Label entryPoint, Label exitPoint) {
+    public BreakableBlockInfo(KtElement element, Label entryPoint, Label exitPoint) {
         this.element = element;
         this.entryPoint = entryPoint;
         this.exitPoint = exitPoint;
@@ -39,7 +39,7 @@ public class BreakableBlockInfo extends BlockInfo {
         Collections.addAll(referablePoints, labels);
     }
 
-    public JetElement getElement() {
+    public KtElement getElement() {
         return element;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilder.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilder.java
index 4035bfba69c..a77de11ae91 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilder.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilder.java
@@ -32,32 +32,32 @@ import java.util.Map;
 
 public interface JetControlFlowBuilder {
     // Subroutines
-    void enterSubroutine(@NotNull JetElement subroutine);
+    void enterSubroutine(@NotNull KtElement subroutine);
 
     @NotNull
-    Pseudocode exitSubroutine(@NotNull JetElement subroutine);
+    Pseudocode exitSubroutine(@NotNull KtElement subroutine);
 
     @NotNull
-    JetElement getCurrentSubroutine();
+    KtElement getCurrentSubroutine();
     @Nullable
-    JetElement getReturnSubroutine();
+    KtElement getReturnSubroutine();
 
     // Lexical scopes
-    void enterLexicalScope(@NotNull JetElement element);
-    void exitLexicalScope(@NotNull JetElement element);
+    void enterLexicalScope(@NotNull KtElement element);
+    void exitLexicalScope(@NotNull KtElement element);
 
     // Entry/exit points
     @NotNull
-    Label getEntryPoint(@NotNull JetElement labelElement);
+    Label getEntryPoint(@NotNull KtElement labelElement);
     @NotNull
-    Label getExitPoint(@NotNull JetElement labelElement);
+    Label getExitPoint(@NotNull KtElement labelElement);
     @NotNull
-    Label getConditionEntryPoint(@NotNull JetElement labelElement);
+    Label getConditionEntryPoint(@NotNull KtElement labelElement);
 
     // Declarations
-    void declareParameter(@NotNull JetParameter parameter);
-    void declareVariable(@NotNull JetVariableDeclaration property);
-    void declareFunction(@NotNull JetElement subroutine, @NotNull Pseudocode pseudocode);
+    void declareParameter(@NotNull KtParameter parameter);
+    void declareVariable(@NotNull KtVariableDeclaration property);
+    void declareFunction(@NotNull KtElement subroutine, @NotNull Pseudocode pseudocode);
 
     // Labels
     @NotNull
@@ -68,25 +68,25 @@ public interface JetControlFlowBuilder {
     void bindLabel(@NotNull Label label);
 
     // Jumps
-    void jump(@NotNull Label label, @NotNull JetElement element);
-    void jumpOnFalse(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue conditionValue);
-    void jumpOnTrue(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue conditionValue);
-    void nondeterministicJump(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue inputValue); // Maybe, jump to label
-    void nondeterministicJump(@NotNull List<Label> label, @NotNull JetElement element);
-    void jumpToError(@NotNull JetElement element);
+    void jump(@NotNull Label label, @NotNull KtElement element);
+    void jumpOnFalse(@NotNull Label label, @NotNull KtElement element, @Nullable PseudoValue conditionValue);
+    void jumpOnTrue(@NotNull Label label, @NotNull KtElement element, @Nullable PseudoValue conditionValue);
+    void nondeterministicJump(@NotNull Label label, @NotNull KtElement element, @Nullable PseudoValue inputValue); // Maybe, jump to label
+    void nondeterministicJump(@NotNull List<Label> label, @NotNull KtElement element);
+    void jumpToError(@NotNull KtElement element);
 
-    void returnValue(@NotNull JetExpression returnExpression, @NotNull PseudoValue returnValue, @NotNull JetElement subroutine);
-    void returnNoValue(@NotNull JetReturnExpression returnExpression, @NotNull JetElement subroutine);
+    void returnValue(@NotNull KtExpression returnExpression, @NotNull PseudoValue returnValue, @NotNull KtElement subroutine);
+    void returnNoValue(@NotNull KtReturnExpression returnExpression, @NotNull KtElement subroutine);
 
-    void throwException(@NotNull JetThrowExpression throwExpression, @NotNull PseudoValue thrownValue);
+    void throwException(@NotNull KtThrowExpression throwExpression, @NotNull PseudoValue thrownValue);
 
     // Loops
     @NotNull
-    LoopInfo enterLoop(@NotNull JetLoopExpression expression);
-    void enterLoopBody(@NotNull JetLoopExpression expression);
-    void exitLoopBody(@NotNull JetLoopExpression expression);
+    LoopInfo enterLoop(@NotNull KtLoopExpression expression);
+    void enterLoopBody(@NotNull KtLoopExpression expression);
+    void exitLoopBody(@NotNull KtLoopExpression expression);
     @Nullable
-    JetLoopExpression getCurrentLoop();
+    KtLoopExpression getCurrentLoop();
 
     // Try-Finally
     void enterTryFinally(@NotNull GenerationTrigger trigger);
@@ -95,49 +95,49 @@ public interface JetControlFlowBuilder {
     void repeatPseudocode(@NotNull Label startLabel, @NotNull Label finishLabel);
 
     // Reading values
-    void mark(@NotNull JetElement element);
+    void mark(@NotNull KtElement element);
 
     @Nullable
-    PseudoValue getBoundValue(@Nullable JetElement element);
-    void bindValue(@NotNull PseudoValue value, @NotNull JetElement element);
+    PseudoValue getBoundValue(@Nullable KtElement element);
+    void bindValue(@NotNull PseudoValue value, @NotNull KtElement element);
     @NotNull
-    PseudoValue newValue(@Nullable JetElement element);
+    PseudoValue newValue(@Nullable KtElement element);
 
-    void loadUnit(@NotNull JetExpression expression);
+    void loadUnit(@NotNull KtExpression expression);
 
     @NotNull
-    InstructionWithValue loadConstant(@NotNull JetExpression expression, @Nullable CompileTimeConstant<?> constant);
+    InstructionWithValue loadConstant(@NotNull KtExpression expression, @Nullable CompileTimeConstant<?> constant);
     @NotNull
-    InstructionWithValue createAnonymousObject(@NotNull JetObjectLiteralExpression expression);
+    InstructionWithValue createAnonymousObject(@NotNull KtObjectLiteralExpression expression);
     @NotNull
-    InstructionWithValue createLambda(@NotNull JetFunction expression);
+    InstructionWithValue createLambda(@NotNull KtFunction expression);
     @NotNull
-    InstructionWithValue loadStringTemplate(@NotNull JetStringTemplateExpression expression, @NotNull List<PseudoValue> inputValues);
+    InstructionWithValue loadStringTemplate(@NotNull KtStringTemplateExpression expression, @NotNull List<PseudoValue> inputValues);
 
     @NotNull
     MagicInstruction magic(
-            @NotNull JetElement instructionElement,
-            @Nullable JetElement valueElement,
+            @NotNull KtElement instructionElement,
+            @Nullable KtElement valueElement,
             @NotNull List<PseudoValue> inputValues,
             @NotNull MagicKind kind
     );
 
     @NotNull
     MergeInstruction merge(
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             @NotNull List<PseudoValue> inputValues
     );
 
     @NotNull
     ReadValueInstruction readVariable(
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             @NotNull ResolvedCall<?> resolvedCall,
             @NotNull Map<PseudoValue, ReceiverValue> receiverValues
     );
 
     @NotNull
     CallInstruction call(
-            @NotNull JetElement valueElement,
+            @NotNull KtElement valueElement,
             @NotNull ResolvedCall<?> resolvedCall,
             @NotNull Map<PseudoValue, ReceiverValue> receiverValues,
             @NotNull Map<PseudoValue, ValueParameterDescriptor> arguments
@@ -150,14 +150,14 @@ public interface JetControlFlowBuilder {
     }
     @NotNull
     OperationInstruction predefinedOperation(
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             @NotNull PredefinedOperation operation,
             @NotNull List<PseudoValue> inputValues
     );
 
     void write(
-            @NotNull JetElement assignment,
-            @NotNull JetElement lValue,
+            @NotNull KtElement assignment,
+            @NotNull KtElement lValue,
             @NotNull PseudoValue rValue,
             @NotNull AccessTarget target,
             @NotNull Map<PseudoValue, ReceiverValue> receiverValues);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilderAdapter.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilderAdapter.java
index a5ac8a404a0..73cf3f045e8 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilderAdapter.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilderAdapter.java
@@ -36,39 +36,39 @@ public abstract class JetControlFlowBuilderAdapter implements JetControlFlowBuil
     protected abstract JetControlFlowBuilder getDelegateBuilder();
 
     @Override
-    public void loadUnit(@NotNull JetExpression expression) {
+    public void loadUnit(@NotNull KtExpression expression) {
         getDelegateBuilder().loadUnit(expression);
     }
 
     @NotNull
     @Override
-    public InstructionWithValue loadConstant(@NotNull JetExpression expression, @Nullable CompileTimeConstant<?> constant) {
+    public InstructionWithValue loadConstant(@NotNull KtExpression expression, @Nullable CompileTimeConstant<?> constant) {
         return getDelegateBuilder().loadConstant(expression, constant);
     }
 
     @NotNull
     @Override
-    public InstructionWithValue createAnonymousObject(@NotNull JetObjectLiteralExpression expression) {
+    public InstructionWithValue createAnonymousObject(@NotNull KtObjectLiteralExpression expression) {
         return getDelegateBuilder().createAnonymousObject(expression);
     }
 
     @NotNull
     @Override
-    public InstructionWithValue createLambda(@NotNull JetFunction expression) {
+    public InstructionWithValue createLambda(@NotNull KtFunction expression) {
         return getDelegateBuilder().createLambda(expression);
     }
 
     @NotNull
     @Override
-    public InstructionWithValue loadStringTemplate(@NotNull JetStringTemplateExpression expression, @NotNull List<PseudoValue> inputValues) {
+    public InstructionWithValue loadStringTemplate(@NotNull KtStringTemplateExpression expression, @NotNull List<PseudoValue> inputValues) {
         return getDelegateBuilder().loadStringTemplate(expression, inputValues);
     }
 
     @NotNull
     @Override
     public MagicInstruction magic(
-            @NotNull JetElement instructionElement,
-            @Nullable JetElement valueElement,
+            @NotNull KtElement instructionElement,
+            @Nullable KtElement valueElement,
             @NotNull List<PseudoValue> inputValues,
             @NotNull MagicKind kind
     ) {
@@ -77,14 +77,14 @@ public abstract class JetControlFlowBuilderAdapter implements JetControlFlowBuil
 
     @NotNull
     @Override
-    public MergeInstruction merge(@NotNull JetExpression expression, @NotNull List<PseudoValue> inputValues) {
+    public MergeInstruction merge(@NotNull KtExpression expression, @NotNull List<PseudoValue> inputValues) {
         return getDelegateBuilder().merge(expression, inputValues);
     }
 
     @NotNull
     @Override
     public ReadValueInstruction readVariable(
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             @NotNull ResolvedCall<?> resolvedCall,
             @NotNull Map<PseudoValue, ReceiverValue> receiverValues
     ) {
@@ -94,7 +94,7 @@ public abstract class JetControlFlowBuilderAdapter implements JetControlFlowBuil
     @NotNull
     @Override
     public CallInstruction call(
-            @NotNull JetElement valueElement,
+            @NotNull KtElement valueElement,
             @NotNull ResolvedCall<?> resolvedCall,
             @NotNull Map<PseudoValue, ReceiverValue> receiverValues,
             @NotNull Map<PseudoValue, ValueParameterDescriptor> arguments
@@ -105,7 +105,7 @@ public abstract class JetControlFlowBuilderAdapter implements JetControlFlowBuil
     @NotNull
     @Override
     public OperationInstruction predefinedOperation(
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             @NotNull PredefinedOperation operation,
             @NotNull List<PseudoValue> inputValues
     ) {
@@ -130,77 +130,77 @@ public abstract class JetControlFlowBuilderAdapter implements JetControlFlowBuil
     }
 
     @Override
-    public void jump(@NotNull Label label, @NotNull JetElement element) {
+    public void jump(@NotNull Label label, @NotNull KtElement element) {
         getDelegateBuilder().jump(label, element);
     }
 
     @Override
-    public void jumpOnFalse(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue conditionValue) {
+    public void jumpOnFalse(@NotNull Label label, @NotNull KtElement element, @Nullable PseudoValue conditionValue) {
         getDelegateBuilder().jumpOnFalse(label, element, conditionValue);
     }
 
     @Override
-    public void jumpOnTrue(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue conditionValue) {
+    public void jumpOnTrue(@NotNull Label label, @NotNull KtElement element, @Nullable PseudoValue conditionValue) {
         getDelegateBuilder().jumpOnTrue(label, element, conditionValue);
     }
 
     @Override
-    public void nondeterministicJump(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue inputValue) {
+    public void nondeterministicJump(@NotNull Label label, @NotNull KtElement element, @Nullable PseudoValue inputValue) {
         getDelegateBuilder().nondeterministicJump(label, element, inputValue);
     }
 
     @Override
-    public void nondeterministicJump(@NotNull List<Label> labels, @NotNull JetElement element) {
+    public void nondeterministicJump(@NotNull List<Label> labels, @NotNull KtElement element) {
         getDelegateBuilder().nondeterministicJump(labels, element);
     }
 
     @Override
-    public void jumpToError(@NotNull JetElement element) {
+    public void jumpToError(@NotNull KtElement element) {
         getDelegateBuilder().jumpToError(element);
     }
 
     @Override
-    public void throwException(@NotNull JetThrowExpression throwExpression, @NotNull PseudoValue thrownValue) {
+    public void throwException(@NotNull KtThrowExpression throwExpression, @NotNull PseudoValue thrownValue) {
         getDelegateBuilder().throwException(throwExpression, thrownValue);
     }
 
     @Override
     @NotNull
-    public Label getEntryPoint(@NotNull JetElement labelElement) {
+    public Label getEntryPoint(@NotNull KtElement labelElement) {
         return getDelegateBuilder().getEntryPoint(labelElement);
     }
 
     @NotNull
     @Override
-    public Label getExitPoint(@NotNull JetElement labelElement) {
+    public Label getExitPoint(@NotNull KtElement labelElement) {
         return getDelegateBuilder().getExitPoint(labelElement);
     }
 
     @NotNull
     @Override
-    public Label getConditionEntryPoint(@NotNull JetElement labelElement) {
+    public Label getConditionEntryPoint(@NotNull KtElement labelElement) {
         return getDelegateBuilder().getConditionEntryPoint(labelElement);
     }
 
     @NotNull
     @Override
-    public LoopInfo enterLoop(@NotNull JetLoopExpression expression) {
+    public LoopInfo enterLoop(@NotNull KtLoopExpression expression) {
         return getDelegateBuilder().enterLoop(expression);
     }
 
     @Override
-    public void enterLoopBody(@NotNull JetLoopExpression expression) {
+    public void enterLoopBody(@NotNull KtLoopExpression expression) {
         getDelegateBuilder().enterLoopBody(expression);
     }
 
     @Override
-    public void exitLoopBody(@NotNull JetLoopExpression expression) {
+    public void exitLoopBody(@NotNull KtLoopExpression expression) {
         getDelegateBuilder().exitLoopBody(expression);
     }
 
     @Override
     @Nullable
-    public JetLoopExpression getCurrentLoop() {
+    public KtLoopExpression getCurrentLoop() {
         return getDelegateBuilder().getCurrentLoop();
     }
 
@@ -215,42 +215,42 @@ public abstract class JetControlFlowBuilderAdapter implements JetControlFlowBuil
     }
 
     @Override
-    public void enterSubroutine(@NotNull JetElement subroutine) {
+    public void enterSubroutine(@NotNull KtElement subroutine) {
         getDelegateBuilder().enterSubroutine(subroutine);
     }
 
     @NotNull
     @Override
-    public Pseudocode exitSubroutine(@NotNull JetElement subroutine) {
+    public Pseudocode exitSubroutine(@NotNull KtElement subroutine) {
         return getDelegateBuilder().exitSubroutine(subroutine);
     }
 
     @NotNull
     @Override
-    public JetElement getCurrentSubroutine() {
+    public KtElement getCurrentSubroutine() {
         return getDelegateBuilder().getCurrentSubroutine();
     }
 
     @Override
     @Nullable
-    public JetElement getReturnSubroutine() {
+    public KtElement getReturnSubroutine() {
         return getDelegateBuilder().getReturnSubroutine();
     }
 
     @Override
-    public void returnValue(@NotNull JetExpression returnExpression, @NotNull PseudoValue returnValue, @NotNull JetElement subroutine) {
+    public void returnValue(@NotNull KtExpression returnExpression, @NotNull PseudoValue returnValue, @NotNull KtElement subroutine) {
         getDelegateBuilder().returnValue(returnExpression, returnValue, subroutine);
     }
 
     @Override
-    public void returnNoValue(@NotNull JetReturnExpression returnExpression, @NotNull JetElement subroutine) {
+    public void returnNoValue(@NotNull KtReturnExpression returnExpression, @NotNull KtElement subroutine) {
         getDelegateBuilder().returnNoValue(returnExpression, subroutine);
     }
 
     @Override
     public void write(
-            @NotNull JetElement assignment,
-            @NotNull JetElement lValue,
+            @NotNull KtElement assignment,
+            @NotNull KtElement lValue,
             @NotNull PseudoValue rValue,
             @NotNull AccessTarget target,
             @NotNull Map<PseudoValue, ReceiverValue> receiverValues) {
@@ -258,17 +258,17 @@ public abstract class JetControlFlowBuilderAdapter implements JetControlFlowBuil
     }
 
     @Override
-    public void declareParameter(@NotNull JetParameter parameter) {
+    public void declareParameter(@NotNull KtParameter parameter) {
         getDelegateBuilder().declareParameter(parameter);
     }
 
     @Override
-    public void declareVariable(@NotNull JetVariableDeclaration property) {
+    public void declareVariable(@NotNull KtVariableDeclaration property) {
         getDelegateBuilder().declareVariable(property);
     }
 
     @Override
-    public void declareFunction(@NotNull JetElement subroutine, @NotNull Pseudocode pseudocode) {
+    public void declareFunction(@NotNull KtElement subroutine, @NotNull Pseudocode pseudocode) {
         getDelegateBuilder().declareFunction(subroutine, pseudocode);
     }
 
@@ -278,34 +278,34 @@ public abstract class JetControlFlowBuilderAdapter implements JetControlFlowBuil
     }
 
     @Override
-    public void mark(@NotNull JetElement element) {
+    public void mark(@NotNull KtElement element) {
         getDelegateBuilder().mark(element);
     }
 
     @Nullable
     @Override
-    public PseudoValue getBoundValue(@Nullable JetElement element) {
+    public PseudoValue getBoundValue(@Nullable KtElement element) {
         return getDelegateBuilder().getBoundValue(element);
     }
 
     @Override
-    public void bindValue(@NotNull PseudoValue value, @NotNull JetElement element) {
+    public void bindValue(@NotNull PseudoValue value, @NotNull KtElement element) {
         getDelegateBuilder().bindValue(value, element);
     }
 
     @NotNull
     @Override
-    public PseudoValue newValue(@Nullable JetElement element) {
+    public PseudoValue newValue(@Nullable KtElement element) {
         return getDelegateBuilder().newValue(element);
     }
 
     @Override
-    public void enterLexicalScope(@NotNull JetElement element) {
+    public void enterLexicalScope(@NotNull KtElement element) {
         getDelegateBuilder().enterLexicalScope(element);
     }
 
     @Override
-    public void exitLexicalScope(@NotNull JetElement element) {
+    public void exitLexicalScope(@NotNull KtElement element) {
         getDelegateBuilder().exitLexicalScope(element);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowProcessor.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowProcessor.java
index 6f052577efe..f7fe5068184 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowProcessor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowProcessor.java
@@ -38,8 +38,8 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.InstructionWithValu
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.MagicKind;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
-import org.jetbrains.kotlin.lexer.JetToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.JetPsiUtilKt;
@@ -56,14 +56,14 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
 
 import java.util.*;
 
 import static org.jetbrains.kotlin.cfg.JetControlFlowBuilder.PredefinedOperation.*;
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
+import static org.jetbrains.kotlin.lexer.KtTokens.*;
 
 public class JetControlFlowProcessor {
 
@@ -76,23 +76,23 @@ public class JetControlFlowProcessor {
     }
 
     @NotNull
-    public Pseudocode generatePseudocode(@NotNull JetElement subroutine) {
+    public Pseudocode generatePseudocode(@NotNull KtElement subroutine) {
         Pseudocode pseudocode = generate(subroutine);
         ((PseudocodeImpl) pseudocode).postProcess();
         return pseudocode;
     }
 
     @NotNull
-    private Pseudocode generate(@NotNull JetElement subroutine) {
+    private Pseudocode generate(@NotNull KtElement subroutine) {
         builder.enterSubroutine(subroutine);
         CFPVisitor cfpVisitor = new CFPVisitor(builder);
-        if (subroutine instanceof JetDeclarationWithBody && !(subroutine instanceof JetSecondaryConstructor)) {
-            JetDeclarationWithBody declarationWithBody = (JetDeclarationWithBody) subroutine;
-            List<JetParameter> valueParameters = declarationWithBody.getValueParameters();
-            for (JetParameter valueParameter : valueParameters) {
+        if (subroutine instanceof KtDeclarationWithBody && !(subroutine instanceof KtSecondaryConstructor)) {
+            KtDeclarationWithBody declarationWithBody = (KtDeclarationWithBody) subroutine;
+            List<KtParameter> valueParameters = declarationWithBody.getValueParameters();
+            for (KtParameter valueParameter : valueParameters) {
                 cfpVisitor.generateInstructions(valueParameter);
             }
-            JetExpression bodyExpression = declarationWithBody.getBodyExpression();
+            KtExpression bodyExpression = declarationWithBody.getBodyExpression();
             if (bodyExpression != null) {
                 cfpVisitor.generateInstructions(bodyExpression);
                 if (!declarationWithBody.hasBlockBody()) {
@@ -105,11 +105,11 @@ public class JetControlFlowProcessor {
         return builder.exitSubroutine(subroutine);
     }
 
-    private void generateImplicitReturnValue(@NotNull JetExpression bodyExpression, @NotNull JetElement subroutine) {
+    private void generateImplicitReturnValue(@NotNull KtExpression bodyExpression, @NotNull KtElement subroutine) {
         CallableDescriptor subroutineDescriptor = (CallableDescriptor) trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, subroutine);
         if (subroutineDescriptor == null) return;
 
-        JetType returnType = subroutineDescriptor.getReturnType();
+        KtType returnType = subroutineDescriptor.getReturnType();
         if (returnType != null && KotlinBuiltIns.isUnit(returnType) && subroutineDescriptor instanceof AnonymousFunctionDescriptor) return;
 
         PseudoValue returnValue = builder.getBoundValue(bodyExpression);
@@ -118,7 +118,7 @@ public class JetControlFlowProcessor {
         builder.returnValue(bodyExpression, returnValue, subroutine);
     }
 
-    private void processLocalDeclaration(@NotNull JetDeclaration subroutine) {
+    private void processLocalDeclaration(@NotNull KtDeclaration subroutine) {
         Label afterDeclaration = builder.createUnboundLabel("after local declaration");
 
         builder.nondeterministicJump(afterDeclaration, subroutine, null);
@@ -126,39 +126,39 @@ public class JetControlFlowProcessor {
         builder.bindLabel(afterDeclaration);
     }
 
-    private class CFPVisitor extends JetVisitorVoid {
+    private class CFPVisitor extends KtVisitorVoid {
         private final JetControlFlowBuilder builder;
 
-        private final JetVisitorVoid conditionVisitor = new JetVisitorVoid() {
+        private final KtVisitorVoid conditionVisitor = new KtVisitorVoid() {
 
-            private JetExpression getSubjectExpression(JetWhenCondition condition) {
-                JetWhenExpression whenExpression = PsiTreeUtil.getParentOfType(condition, JetWhenExpression.class);
+            private KtExpression getSubjectExpression(KtWhenCondition condition) {
+                KtWhenExpression whenExpression = PsiTreeUtil.getParentOfType(condition, KtWhenExpression.class);
                 return whenExpression != null ? whenExpression.getSubjectExpression() : null;
             }
 
             @Override
-            public void visitWhenConditionInRange(@NotNull JetWhenConditionInRange condition) {
+            public void visitWhenConditionInRange(@NotNull KtWhenConditionInRange condition) {
                 if (!generateCall(condition.getOperationReference())) {
-                    JetExpression rangeExpression = condition.getRangeExpression();
+                    KtExpression rangeExpression = condition.getRangeExpression();
                     generateInstructions(rangeExpression);
                     createNonSyntheticValue(condition, MagicKind.UNRESOLVED_CALL, rangeExpression);
                 }
             }
 
             @Override
-            public void visitWhenConditionIsPattern(@NotNull JetWhenConditionIsPattern condition) {
+            public void visitWhenConditionIsPattern(@NotNull KtWhenConditionIsPattern condition) {
                 mark(condition);
                 createNonSyntheticValue(condition, MagicKind.IS, getSubjectExpression(condition));
             }
 
             @Override
-            public void visitWhenConditionWithExpression(@NotNull JetWhenConditionWithExpression condition) {
+            public void visitWhenConditionWithExpression(@NotNull KtWhenConditionWithExpression condition) {
                 mark(condition);
 
-                JetExpression expression = condition.getExpression();
+                KtExpression expression = condition.getExpression();
                 generateInstructions(expression);
 
-                JetExpression subjectExpression = getSubjectExpression(condition);
+                KtExpression subjectExpression = getSubjectExpression(condition);
                 if (subjectExpression != null) {
                     // todo: this can be replaced by equals() invocation (when corresponding resolved call is recorded)
                     createNonSyntheticValue(condition, MagicKind.EQUALS_IN_WHEN_CONDITION, subjectExpression, expression);
@@ -169,7 +169,7 @@ public class JetControlFlowProcessor {
             }
 
             @Override
-            public void visitJetElement(@NotNull JetElement element) {
+            public void visitJetElement(@NotNull KtElement element) {
                 throw new UnsupportedOperationException("[JetControlFlowProcessor] " + element.toString());
             }
         };
@@ -178,57 +178,57 @@ public class JetControlFlowProcessor {
             this.builder = builder;
         }
 
-        private void mark(JetElement element) {
+        private void mark(KtElement element) {
             builder.mark(element);
         }
 
-        public void generateInstructions(@Nullable JetElement element) {
+        public void generateInstructions(@Nullable KtElement element) {
             if (element == null) return;
             element.accept(this);
             checkNothingType(element);
         }
 
-        private void checkNothingType(JetElement element) {
-            if (!(element instanceof JetExpression)) return;
+        private void checkNothingType(KtElement element) {
+            if (!(element instanceof KtExpression)) return;
 
-            JetExpression expression = JetPsiUtil.deparenthesize((JetExpression) element);
+            KtExpression expression = KtPsiUtil.deparenthesize((KtExpression) element);
             if (expression == null) return;
 
-            if (expression instanceof JetStatementExpression || expression instanceof JetTryExpression
-                    || expression instanceof JetIfExpression || expression instanceof JetWhenExpression) {
+            if (expression instanceof KtStatementExpression || expression instanceof KtTryExpression
+                || expression instanceof KtIfExpression || expression instanceof KtWhenExpression) {
                 return;
             }
 
-            JetType type = trace.getBindingContext().getType(expression);
+            KtType type = trace.getBindingContext().getType(expression);
             if (type != null && KotlinBuiltIns.isNothing(type)) {
                 builder.jumpToError(expression);
             }
         }
 
         @NotNull
-        private PseudoValue createSyntheticValue(@NotNull JetElement instructionElement, @NotNull MagicKind kind, JetElement... from) {
-            List<PseudoValue> values = elementsToValues(from.length > 0 ? Arrays.asList(from) : Collections.<JetElement>emptyList());
+        private PseudoValue createSyntheticValue(@NotNull KtElement instructionElement, @NotNull MagicKind kind, KtElement... from) {
+            List<PseudoValue> values = elementsToValues(from.length > 0 ? Arrays.asList(from) : Collections.<KtElement>emptyList());
             return builder.magic(instructionElement, null, values, kind).getOutputValue();
         }
 
         @NotNull
         private PseudoValue createNonSyntheticValue(
-                @NotNull JetElement to, @NotNull List<? extends JetElement> from, @NotNull MagicKind kind
+                @NotNull KtElement to, @NotNull List<? extends KtElement> from, @NotNull MagicKind kind
         ) {
             List<PseudoValue> values = elementsToValues(from);
             return builder.magic(to, to, values, kind).getOutputValue();
         }
 
         @NotNull
-        private PseudoValue createNonSyntheticValue(@NotNull JetElement to, @NotNull MagicKind kind, JetElement... from) {
+        private PseudoValue createNonSyntheticValue(@NotNull KtElement to, @NotNull MagicKind kind, KtElement... from) {
             return createNonSyntheticValue(to, Arrays.asList(from), kind);
         }
 
-        private void mergeValues(@NotNull List<JetExpression> from, @NotNull JetExpression to) {
+        private void mergeValues(@NotNull List<KtExpression> from, @NotNull KtExpression to) {
             builder.merge(to, elementsToValues(from));
         }
 
-        private void copyValue(@Nullable JetElement from, @NotNull JetElement to) {
+        private void copyValue(@Nullable KtElement from, @NotNull KtElement to) {
             PseudoValue value = getBoundOrUnreachableValue(from);
             if (value != null) {
                 builder.bindValue(value, to);
@@ -236,21 +236,21 @@ public class JetControlFlowProcessor {
         }
 
         @Nullable
-        private PseudoValue getBoundOrUnreachableValue(@Nullable JetElement element) {
+        private PseudoValue getBoundOrUnreachableValue(@Nullable KtElement element) {
             if (element == null) return null;
 
             PseudoValue value = builder.getBoundValue(element);
-            return value != null || element instanceof JetDeclaration ? value : builder.newValue(element);
+            return value != null || element instanceof KtDeclaration ? value : builder.newValue(element);
         }
 
-        private List<PseudoValue> elementsToValues(List<? extends JetElement> from) {
+        private List<PseudoValue> elementsToValues(List<? extends KtElement> from) {
             if (from.isEmpty()) return Collections.emptyList();
             return CollectionsKt.filterNotNull(
                     CollectionsKt.map(
                             from,
-                            new Function1<JetElement, PseudoValue>() {
+                            new Function1<KtElement, PseudoValue>() {
                                 @Override
-                                public PseudoValue invoke(JetElement element) {
+                                public PseudoValue invoke(KtElement element) {
                                     return getBoundOrUnreachableValue(element);
                                 }
                             }
@@ -258,7 +258,7 @@ public class JetControlFlowProcessor {
             );
         }
 
-        private void generateInitializer(@NotNull JetDeclaration declaration, @NotNull PseudoValue initValue) {
+        private void generateInitializer(@NotNull KtDeclaration declaration, @NotNull PseudoValue initValue) {
             builder.write(
                     declaration,
                     declaration,
@@ -269,13 +269,13 @@ public class JetControlFlowProcessor {
         }
 
         @NotNull
-        private AccessTarget getResolvedCallAccessTarget(JetElement element) {
+        private AccessTarget getResolvedCallAccessTarget(KtElement element) {
             ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(element, trace.getBindingContext());
             return resolvedCall != null ? new AccessTarget.Call(resolvedCall) : AccessTarget.BlackBox.INSTANCE$;
         }
 
         @NotNull
-        private AccessTarget getDeclarationAccessTarget(JetElement element) {
+        private AccessTarget getDeclarationAccessTarget(KtElement element) {
             DeclarationDescriptor descriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element);
             return descriptor instanceof VariableDescriptor
                    ? new AccessTarget.Declaration((VariableDescriptor) descriptor)
@@ -283,9 +283,9 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression) {
+        public void visitParenthesizedExpression(@NotNull KtParenthesizedExpression expression) {
             mark(expression);
-            JetExpression innerExpression = expression.getExpression();
+            KtExpression innerExpression = expression.getExpression();
             if (innerExpression != null) {
                 generateInstructions(innerExpression);
                 copyValue(innerExpression, expression);
@@ -293,8 +293,8 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitAnnotatedExpression(@NotNull JetAnnotatedExpression expression) {
-            JetExpression baseExpression = expression.getBaseExpression();
+        public void visitAnnotatedExpression(@NotNull KtAnnotatedExpression expression) {
+            KtExpression baseExpression = expression.getBaseExpression();
             if (baseExpression != null) {
                 generateInstructions(baseExpression);
                 copyValue(baseExpression, expression);
@@ -302,7 +302,7 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitThisExpression(@NotNull JetThisExpression expression) {
+        public void visitThisExpression(@NotNull KtThisExpression expression) {
             ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(expression, trace.getBindingContext());
             if (resolvedCall == null) {
                 createNonSyntheticValue(expression, MagicKind.UNRESOLVED_CALL);
@@ -318,27 +318,27 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitConstantExpression(@NotNull JetConstantExpression expression) {
+        public void visitConstantExpression(@NotNull KtConstantExpression expression) {
             CompileTimeConstant<?> constant = ConstantExpressionEvaluator.getConstant(expression, trace.getBindingContext());
             builder.loadConstant(expression, constant);
         }
 
         @Override
-        public void visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression) {
+        public void visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression) {
             ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(expression, trace.getBindingContext());
             if (resolvedCall instanceof VariableAsFunctionResolvedCall) {
                 VariableAsFunctionResolvedCall variableAsFunctionResolvedCall = (VariableAsFunctionResolvedCall) resolvedCall;
                 generateCall(variableAsFunctionResolvedCall.getVariableCall());
             }
-            else if (!generateCall(expression) && !(expression.getParent() instanceof JetCallExpression)) {
+            else if (!generateCall(expression) && !(expression.getParent() instanceof KtCallExpression)) {
                 createNonSyntheticValue(expression, MagicKind.UNRESOLVED_CALL, generateAndGetReceiverIfAny(expression));
             }
         }
 
         @Override
-        public void visitLabeledExpression(@NotNull JetLabeledExpression expression) {
+        public void visitLabeledExpression(@NotNull KtLabeledExpression expression) {
             mark(expression);
-            JetExpression baseExpression = expression.getBaseExpression();
+            KtExpression baseExpression = expression.getBaseExpression();
             if (baseExpression != null) {
                 generateInstructions(baseExpression);
                 copyValue(baseExpression, expression);
@@ -347,12 +347,12 @@ public class JetControlFlowProcessor {
 
         @SuppressWarnings("SuspiciousMethodCalls")
         @Override
-        public void visitBinaryExpression(@NotNull JetBinaryExpression expression) {
-            JetSimpleNameExpression operationReference = expression.getOperationReference();
+        public void visitBinaryExpression(@NotNull KtBinaryExpression expression) {
+            KtSimpleNameExpression operationReference = expression.getOperationReference();
             IElementType operationType = operationReference.getReferencedNameElementType();
 
-            JetExpression left = expression.getLeft();
-            JetExpression right = expression.getRight();
+            KtExpression left = expression.getLeft();
+            KtExpression right = expression.getRight();
             if (operationType == ANDAND || operationType == OROR) {
                 generateBooleanOperation(expression);
             }
@@ -363,7 +363,7 @@ public class JetControlFlowProcessor {
                 ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(expression, trace.getBindingContext());
                 if (resolvedCall != null) {
                     PseudoValue rhsValue = generateCall(resolvedCall).getOutputValue();
-                    Name assignMethodName = OperatorConventions.getNameForOperationSymbol((JetToken) expression.getOperationToken());
+                    Name assignMethodName = OperatorConventions.getNameForOperationSymbol((KtToken) expression.getOperationToken());
                     if (!resolvedCall.getResultingDescriptor().getName().equals(assignMethodName)) {
                         /* At this point assignment of the form a += b actually means a = a + b
                          * So we first generate call of "+" operation and then use its output pseudo-value
@@ -394,10 +394,10 @@ public class JetControlFlowProcessor {
             }
         }
 
-        private void generateBooleanOperation(JetBinaryExpression expression) {
+        private void generateBooleanOperation(KtBinaryExpression expression) {
             IElementType operationType = expression.getOperationReference().getReferencedNameElementType();
-            JetExpression left = expression.getLeft();
-            JetExpression right = expression.getRight();
+            KtExpression left = expression.getLeft();
+            KtExpression right = expression.getRight();
 
             Label resultLabel = builder.createUnboundLabel("result of boolean operation");
             generateInstructions(left);
@@ -424,7 +424,7 @@ public class JetControlFlowProcessor {
             };
         }
 
-        private Function0<PseudoValue> getDeferredValue(final JetExpression expression) {
+        private Function0<PseudoValue> getDeferredValue(final KtExpression expression) {
             return new Function0<PseudoValue>() {
                 @Override
                 public PseudoValue invoke() {
@@ -434,12 +434,12 @@ public class JetControlFlowProcessor {
             };
         }
 
-        private void generateBothArgumentsAndMark(JetBinaryExpression expression) {
-            JetExpression left = JetPsiUtil.deparenthesize(expression.getLeft());
+        private void generateBothArgumentsAndMark(KtBinaryExpression expression) {
+            KtExpression left = KtPsiUtil.deparenthesize(expression.getLeft());
             if (left != null) {
                 generateInstructions(left);
             }
-            JetExpression right = expression.getRight();
+            KtExpression right = expression.getRight();
             if (right != null) {
                 generateInstructions(right);
             }
@@ -448,35 +448,35 @@ public class JetControlFlowProcessor {
         }
 
         private void visitAssignment(
-                JetExpression lhs,
+                KtExpression lhs,
                 @NotNull Function0<PseudoValue> rhsDeferredValue,
-                JetExpression parentExpression
+                KtExpression parentExpression
         ) {
-            JetExpression left = JetPsiUtil.deparenthesize(lhs);
+            KtExpression left = KtPsiUtil.deparenthesize(lhs);
             if (left == null) {
                 List<PseudoValue> arguments = Collections.singletonList(rhsDeferredValue.invoke());
                 builder.magic(parentExpression, parentExpression, arguments, MagicKind.UNSUPPORTED_ELEMENT);
                 return;
             }
 
-            if (left instanceof JetArrayAccessExpression) {
-                generateArrayAssignment((JetArrayAccessExpression) left, rhsDeferredValue, parentExpression);
+            if (left instanceof KtArrayAccessExpression) {
+                generateArrayAssignment((KtArrayAccessExpression) left, rhsDeferredValue, parentExpression);
                 return;
             }
 
             Map<PseudoValue, ReceiverValue> receiverValues = SmartFMap.emptyMap();
             AccessTarget accessTarget = AccessTarget.BlackBox.INSTANCE$;
-            if (left instanceof JetSimpleNameExpression || left instanceof JetQualifiedExpression) {
+            if (left instanceof KtSimpleNameExpression || left instanceof KtQualifiedExpression) {
                 accessTarget = getResolvedCallAccessTarget(JetPsiUtilKt.getQualifiedElementSelector(left));
                 if (accessTarget instanceof AccessTarget.Call) {
                     receiverValues = getReceiverValues(((AccessTarget.Call) accessTarget).getResolvedCall());
                 }
             }
-            else if (left instanceof JetProperty) {
+            else if (left instanceof KtProperty) {
                 accessTarget = getDeclarationAccessTarget(left);
             }
 
-            if (accessTarget == AccessTarget.BlackBox.INSTANCE$ && !(left instanceof JetProperty)) {
+            if (accessTarget == AccessTarget.BlackBox.INSTANCE$ && !(left instanceof KtProperty)) {
                 generateInstructions(left);
                 createSyntheticValue(left, MagicKind.VALUE_CONSUMER, left);
             }
@@ -488,9 +488,9 @@ public class JetControlFlowProcessor {
         }
 
         private void generateArrayAssignment(
-                JetArrayAccessExpression lhs,
+                KtArrayAccessExpression lhs,
                 @NotNull Function0<PseudoValue> rhsDeferredValue,
-                @NotNull JetExpression parentExpression
+                @NotNull KtExpression parentExpression
         ) {
             ResolvedCall<FunctionDescriptor> setResolvedCall = trace.get(BindingContext.INDEXED_LVALUE_SET, lhs);
 
@@ -506,7 +506,7 @@ public class JetControlFlowProcessor {
             }
 
             // In case of simple ('=') array assignment mark instruction is not generated yet, so we put it before generating "set" call
-            if (((JetOperationExpression) parentExpression).getOperationReference().getReferencedNameElementType() == EQ) {
+            if (((KtOperationExpression) parentExpression).getOperationReference().getReferencedNameElementType() == EQ) {
                 mark(lhs);
             }
 
@@ -562,7 +562,7 @@ public class JetControlFlowProcessor {
             return argumentValues;
         }
 
-        private void generateArrayAccess(JetArrayAccessExpression arrayAccessExpression, @Nullable ResolvedCall<?> resolvedCall) {
+        private void generateArrayAccess(KtArrayAccessExpression arrayAccessExpression, @Nullable ResolvedCall<?> resolvedCall) {
             if (builder.getBoundValue(arrayAccessExpression) != null) return;
             mark(arrayAccessExpression);
             if (!checkAndGenerateCall(resolvedCall)) {
@@ -570,18 +570,18 @@ public class JetControlFlowProcessor {
             }
         }
 
-        private void generateArrayAccessWithoutCall(JetArrayAccessExpression arrayAccessExpression) {
+        private void generateArrayAccessWithoutCall(KtArrayAccessExpression arrayAccessExpression) {
             createNonSyntheticValue(arrayAccessExpression, generateArrayAccessArguments(arrayAccessExpression), MagicKind.UNRESOLVED_CALL);
         }
 
-        private List<JetExpression> generateArrayAccessArguments(JetArrayAccessExpression arrayAccessExpression) {
-            List<JetExpression> inputExpressions = new ArrayList<JetExpression>();
+        private List<KtExpression> generateArrayAccessArguments(KtArrayAccessExpression arrayAccessExpression) {
+            List<KtExpression> inputExpressions = new ArrayList<KtExpression>();
 
-            JetExpression arrayExpression = arrayAccessExpression.getArrayExpression();
+            KtExpression arrayExpression = arrayAccessExpression.getArrayExpression();
             inputExpressions.add(arrayExpression);
             generateInstructions(arrayExpression);
 
-            for (JetExpression index : arrayAccessExpression.getIndexExpressions()) {
+            for (KtExpression index : arrayAccessExpression.getIndexExpressions()) {
                 generateInstructions(index);
                 inputExpressions.add(index);
             }
@@ -590,12 +590,12 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitUnaryExpression(@NotNull JetUnaryExpression expression) {
-            JetSimpleNameExpression operationSign = expression.getOperationReference();
+        public void visitUnaryExpression(@NotNull KtUnaryExpression expression) {
+            KtSimpleNameExpression operationSign = expression.getOperationReference();
             IElementType operationType = operationSign.getReferencedNameElementType();
-            JetExpression baseExpression = expression.getBaseExpression();
+            KtExpression baseExpression = expression.getBaseExpression();
             if (baseExpression == null) return;
-            if (JetTokens.EXCLEXCL == operationType) {
+            if (KtTokens.EXCLEXCL == operationType) {
                 generateInstructions(baseExpression);
                 builder.predefinedOperation(expression, NOT_NULL_ASSERTION, elementsToValues(Collections.singletonList(baseExpression)));
                 return;
@@ -615,27 +615,27 @@ public class JetControlFlowProcessor {
 
             if (incrementOrDecrement) {
                 visitAssignment(baseExpression, getValueAsFunction(rhsValue), expression);
-                if (expression instanceof JetPostfixExpression) {
+                if (expression instanceof KtPostfixExpression) {
                     copyValue(baseExpression, expression);
                 }
             }
         }
 
         private boolean isIncrementOrDecrement(IElementType operationType) {
-            return operationType == JetTokens.PLUSPLUS || operationType == JetTokens.MINUSMINUS;
+            return operationType == KtTokens.PLUSPLUS || operationType == KtTokens.MINUSMINUS;
         }
 
         @Override
-        public void visitIfExpression(@NotNull JetIfExpression expression) {
+        public void visitIfExpression(@NotNull KtIfExpression expression) {
             mark(expression);
-            List<JetExpression> branches = new ArrayList<JetExpression>(2);
-            JetExpression condition = expression.getCondition();
+            List<KtExpression> branches = new ArrayList<KtExpression>(2);
+            KtExpression condition = expression.getCondition();
             if (condition != null) {
                 generateInstructions(condition);
             }
             Label elseLabel = builder.createUnboundLabel("else branch");
             builder.jumpOnFalse(elseLabel, expression, builder.getBoundValue(condition));
-            JetExpression thenBranch = expression.getThen();
+            KtExpression thenBranch = expression.getThen();
             if (thenBranch != null) {
                 branches.add(thenBranch);
                 generateInstructions(thenBranch);
@@ -646,7 +646,7 @@ public class JetControlFlowProcessor {
             Label resultLabel = builder.createUnboundLabel("'if' expression result");
             builder.jump(resultLabel, expression);
             builder.bindLabel(elseLabel);
-            JetExpression elseBranch = expression.getElse();
+            KtExpression elseBranch = expression.getElse();
             if (elseBranch != null) {
                 branches.add(elseBranch);
                 generateInstructions(elseBranch);
@@ -659,16 +659,16 @@ public class JetControlFlowProcessor {
         }
 
         private class FinallyBlockGenerator {
-            private final JetFinallySection finallyBlock;
+            private final KtFinallySection finallyBlock;
             private Label startFinally = null;
             private Label finishFinally = null;
 
-            private FinallyBlockGenerator(JetFinallySection block) {
+            private FinallyBlockGenerator(KtFinallySection block) {
                 finallyBlock = block;
             }
 
             public void generate() {
-                JetBlockExpression finalExpression = finallyBlock.getFinalExpression();
+                KtBlockExpression finalExpression = finallyBlock.getFinalExpression();
                 if (finalExpression == null) return;
                 if (startFinally != null) {
                     assert finishFinally != null;
@@ -684,10 +684,10 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitTryExpression(@NotNull JetTryExpression expression) {
+        public void visitTryExpression(@NotNull KtTryExpression expression) {
             mark(expression);
 
-            JetFinallySection finallyBlock = expression.getFinallyBlock();
+            KtFinallySection finallyBlock = expression.getFinallyBlock();
             final FinallyBlockGenerator finallyBlockGenerator = new FinallyBlockGenerator(finallyBlock);
             boolean hasFinally = finallyBlock != null;
             if (hasFinally) {
@@ -722,9 +722,9 @@ public class JetControlFlowProcessor {
                 finallyBlockGenerator.generate();
             }
 
-            List<JetExpression> branches = new ArrayList<JetExpression>();
+            List<KtExpression> branches = new ArrayList<KtExpression>();
             branches.add(expression.getTryBlock());
-            for (JetCatchClause catchClause : expression.getCatchClauses()) {
+            for (KtCatchClause catchClause : expression.getCatchClauses()) {
                 branches.add(catchClause.getCatchBody());
             }
             mergeValues(branches, expression);
@@ -732,8 +732,8 @@ public class JetControlFlowProcessor {
 
         // Returns label for 'finally' block
         @Nullable
-        private Label generateTryAndCatches(@NotNull JetTryExpression expression) {
-            List<JetCatchClause> catchClauses = expression.getCatchClauses();
+        private Label generateTryAndCatches(@NotNull KtTryExpression expression) {
+            List<KtCatchClause> catchClauses = expression.getCatchClauses();
             boolean hasCatches = !catchClauses.isEmpty();
 
             Label onException = null;
@@ -748,7 +748,7 @@ public class JetControlFlowProcessor {
                 builder.nondeterministicJump(onExceptionToFinallyBlock, expression, null);
             }
 
-            JetBlockExpression tryBlock = expression.getTryBlock();
+            KtBlockExpression tryBlock = expression.getTryBlock();
             generateInstructions(tryBlock);
 
             if (hasCatches) {
@@ -765,7 +765,7 @@ public class JetControlFlowProcessor {
                     builder.nondeterministicJump(catchLabels, expression);
                 }
                 boolean isFirst = true;
-                for (JetCatchClause catchClause : catchClauses) {
+                for (KtCatchClause catchClause : catchClauses) {
                     builder.enterLexicalScope(catchClause);
                     if (!isFirst) {
                         builder.bindLabel(catchLabels.remove());
@@ -773,12 +773,12 @@ public class JetControlFlowProcessor {
                     else {
                         isFirst = false;
                     }
-                    JetParameter catchParameter = catchClause.getCatchParameter();
+                    KtParameter catchParameter = catchClause.getCatchParameter();
                     if (catchParameter != null) {
                         builder.declareParameter(catchParameter);
                         generateInitializer(catchParameter, createSyntheticValue(catchParameter, MagicKind.FAKE_INITIALIZER));
                     }
-                    JetExpression catchBody = catchClause.getCatchBody();
+                    KtExpression catchBody = catchClause.getCatchBody();
                     if (catchBody != null) {
                         generateInstructions(catchBody);
                     }
@@ -793,11 +793,11 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitWhileExpression(@NotNull JetWhileExpression expression) {
+        public void visitWhileExpression(@NotNull KtWhileExpression expression) {
             LoopInfo loopInfo = builder.enterLoop(expression);
 
             builder.bindLabel(loopInfo.getConditionEntryPoint());
-            JetExpression condition = expression.getCondition();
+            KtExpression condition = expression.getCondition();
             if (condition != null) {
                 generateInstructions(condition);
             }
@@ -812,7 +812,7 @@ public class JetControlFlowProcessor {
             }
 
             builder.enterLoopBody(expression);
-            JetExpression body = expression.getBody();
+            KtExpression body = expression.getBody();
             if (body != null) {
                 generateInstructions(body);
             }
@@ -823,19 +823,19 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitDoWhileExpression(@NotNull JetDoWhileExpression expression) {
+        public void visitDoWhileExpression(@NotNull KtDoWhileExpression expression) {
             builder.enterLexicalScope(expression);
             mark(expression);
             LoopInfo loopInfo = builder.enterLoop(expression);
 
             builder.enterLoopBody(expression);
-            JetExpression body = expression.getBody();
+            KtExpression body = expression.getBody();
             if (body != null) {
                 generateInstructions(body);
             }
             builder.exitLoopBody(expression);
             builder.bindLabel(loopInfo.getConditionEntryPoint());
-            JetExpression condition = expression.getCondition();
+            KtExpression condition = expression.getCondition();
             if (condition != null) {
                 generateInstructions(condition);
             }
@@ -846,10 +846,10 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitForExpression(@NotNull JetForExpression expression) {
+        public void visitForExpression(@NotNull KtForExpression expression) {
             builder.enterLexicalScope(expression);
 
-            JetExpression loopRange = expression.getLoopRange();
+            KtExpression loopRange = expression.getLoopRange();
             if (loopRange != null) {
                 generateInstructions(loopRange);
             }
@@ -866,7 +866,7 @@ public class JetControlFlowProcessor {
 
             mark(expression);
             builder.enterLoopBody(expression);
-            JetExpression body = expression.getBody();
+            KtExpression body = expression.getBody();
             if (body != null) {
                 generateInstructions(body);
             }
@@ -878,9 +878,9 @@ public class JetControlFlowProcessor {
             builder.exitLexicalScope(expression);
         }
 
-        private void declareLoopParameter(JetForExpression expression) {
-            JetParameter loopParameter = expression.getLoopParameter();
-            JetMultiDeclaration multiDeclaration = expression.getMultiParameter();
+        private void declareLoopParameter(KtForExpression expression) {
+            KtParameter loopParameter = expression.getLoopParameter();
+            KtMultiDeclaration multiDeclaration = expression.getMultiParameter();
             if (loopParameter != null) {
                 builder.declareParameter(loopParameter);
             }
@@ -889,10 +889,10 @@ public class JetControlFlowProcessor {
             }
         }
 
-        private void writeLoopParameterAssignment(JetForExpression expression) {
-            JetParameter loopParameter = expression.getLoopParameter();
-            JetMultiDeclaration multiDeclaration = expression.getMultiParameter();
-            JetExpression loopRange = expression.getLoopRange();
+        private void writeLoopParameterAssignment(KtForExpression expression) {
+            KtParameter loopParameter = expression.getLoopParameter();
+            KtMultiDeclaration multiDeclaration = expression.getMultiParameter();
+            KtExpression loopRange = expression.getLoopRange();
 
             PseudoValue value = builder.magic(
                     loopRange != null ? loopRange : expression,
@@ -905,15 +905,15 @@ public class JetControlFlowProcessor {
                 generateInitializer(loopParameter, value);
             }
             else if (multiDeclaration != null) {
-                for (JetMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
+                for (KtMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
                     generateInitializer(entry, value);
                 }
             }
         }
 
         @Override
-        public void visitBreakExpression(@NotNull JetBreakExpression expression) {
-            JetElement loop = getCorrespondingLoop(expression);
+        public void visitBreakExpression(@NotNull KtBreakExpression expression) {
+            KtElement loop = getCorrespondingLoop(expression);
             if (loop != null) {
                 checkJumpDoesNotCrossFunctionBoundary(expression, loop);
                 builder.jump(builder.getExitPoint(loop), expression);
@@ -921,8 +921,8 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitContinueExpression(@NotNull JetContinueExpression expression) {
-            JetElement loop = getCorrespondingLoop(expression);
+        public void visitContinueExpression(@NotNull KtContinueExpression expression) {
+            KtElement loop = getCorrespondingLoop(expression);
             if (loop != null) {
                 checkJumpDoesNotCrossFunctionBoundary(expression, loop);
                 builder.jump(builder.getConditionEntryPoint(loop), expression);
@@ -930,15 +930,15 @@ public class JetControlFlowProcessor {
         }
 
         @Nullable
-        private JetElement getCorrespondingLoop(JetExpressionWithLabel expression) {
+        private KtElement getCorrespondingLoop(KtExpressionWithLabel expression) {
             String labelName = expression.getLabelName();
-            JetLoopExpression loop;
+            KtLoopExpression loop;
             if (labelName != null) {
-                JetSimpleNameExpression targetLabel = expression.getTargetLabel();
+                KtSimpleNameExpression targetLabel = expression.getTargetLabel();
                 assert targetLabel != null;
                 PsiElement labeledElement = trace.get(BindingContext.LABEL_TARGET, targetLabel);
-                if (labeledElement instanceof JetLoopExpression) {
-                    loop = (JetLoopExpression) labeledElement;
+                if (labeledElement instanceof KtLoopExpression) {
+                    loop = (KtLoopExpression) labeledElement;
                 }
                 else {
                     trace.report(NOT_A_LOOP_LABEL.on(expression, targetLabel.getText()));
@@ -950,8 +950,8 @@ public class JetControlFlowProcessor {
                 if (loop == null) {
                     trace.report(BREAK_OR_CONTINUE_OUTSIDE_A_LOOP.on(expression));
                 } else {
-                    JetWhenExpression whenExpression = PsiTreeUtil.getParentOfType(expression, JetWhenExpression.class, true,
-                                                                                   JetLoopExpression.class);
+                    KtWhenExpression whenExpression = PsiTreeUtil.getParentOfType(expression, KtWhenExpression.class, true,
+                                                                                  KtLoopExpression.class);
                     if (whenExpression != null) {
                         trace.report(BREAK_OR_CONTINUE_IN_WHEN.on(expression));
                     }
@@ -966,7 +966,7 @@ public class JetControlFlowProcessor {
             return loop;
         }
 
-        private void checkJumpDoesNotCrossFunctionBoundary(@NotNull JetExpressionWithLabel jumpExpression, @NotNull JetElement jumpTarget) {
+        private void checkJumpDoesNotCrossFunctionBoundary(@NotNull KtExpressionWithLabel jumpExpression, @NotNull KtElement jumpTarget) {
             BindingContext bindingContext = trace.getBindingContext();
 
             FunctionDescriptor labelExprEnclosingFunc = BindingContextUtils.getEnclosingFunctionDescriptor(bindingContext, jumpExpression);
@@ -977,19 +977,19 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitReturnExpression(@NotNull JetReturnExpression expression) {
-            JetExpression returnedExpression = expression.getReturnedExpression();
+        public void visitReturnExpression(@NotNull KtReturnExpression expression) {
+            KtExpression returnedExpression = expression.getReturnedExpression();
             if (returnedExpression != null) {
                 generateInstructions(returnedExpression);
             }
-            JetSimpleNameExpression labelElement = expression.getTargetLabel();
-            JetElement subroutine;
+            KtSimpleNameExpression labelElement = expression.getTargetLabel();
+            KtElement subroutine;
             String labelName = expression.getLabelName();
             if (labelElement != null && labelName != null) {
                 PsiElement labeledElement = trace.get(BindingContext.LABEL_TARGET, labelElement);
                 if (labeledElement != null) {
-                    assert labeledElement instanceof JetElement;
-                    subroutine = (JetElement) labeledElement;
+                    assert labeledElement instanceof KtElement;
+                    subroutine = (KtElement) labeledElement;
                 }
                 else {
                     subroutine = null;
@@ -1000,7 +1000,7 @@ public class JetControlFlowProcessor {
                 // TODO : a context check
             }
 
-            if (subroutine instanceof JetFunction || subroutine instanceof JetPropertyAccessor) {
+            if (subroutine instanceof KtFunction || subroutine instanceof KtPropertyAccessor) {
                 PseudoValue returnValue = returnedExpression != null ? builder.getBoundValue(returnedExpression) : null;
                 if (returnValue == null) {
                     builder.returnNoValue(expression, subroutine);
@@ -1015,9 +1015,9 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitParameter(@NotNull JetParameter parameter) {
+        public void visitParameter(@NotNull KtParameter parameter) {
             builder.declareParameter(parameter);
-            JetExpression defaultValue = parameter.getDefaultValue();
+            KtExpression defaultValue = parameter.getDefaultValue();
             if (defaultValue != null) {
                 Label skipDefaultValue = builder.createUnboundLabel("after default value for parameter " + parameter.getName());
                 builder.nondeterministicJump(skipDefaultValue, defaultValue, null);
@@ -1028,7 +1028,7 @@ public class JetControlFlowProcessor {
         }
 
         @NotNull
-        private PseudoValue computePseudoValueForParameter(@NotNull JetParameter parameter) {
+        private PseudoValue computePseudoValueForParameter(@NotNull KtParameter parameter) {
             PseudoValue syntheticValue = createSyntheticValue(parameter, MagicKind.FAKE_INITIALIZER);
             PseudoValue defaultValue = builder.getBoundValue(parameter.getDefaultValue());
             if (defaultValue == null) {
@@ -1038,14 +1038,14 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitBlockExpression(@NotNull JetBlockExpression expression) {
+        public void visitBlockExpression(@NotNull KtBlockExpression expression) {
             boolean declareLexicalScope = !isBlockInDoWhile(expression);
             if (declareLexicalScope) {
                 builder.enterLexicalScope(expression);
             }
             mark(expression);
-            List<JetExpression> statements = expression.getStatements();
-            for (JetExpression statement : statements) {
+            List<KtExpression> statements = expression.getStatements();
+            for (KtExpression statement : statements) {
                 generateInstructions(statement);
             }
             if (statements.isEmpty()) {
@@ -1059,41 +1059,41 @@ public class JetControlFlowProcessor {
             }
         }
 
-        private boolean isBlockInDoWhile(@NotNull JetBlockExpression expression) {
+        private boolean isBlockInDoWhile(@NotNull KtBlockExpression expression) {
             PsiElement parent = expression.getParent();
             if (parent == null) return false;
-            return parent.getParent() instanceof JetDoWhileExpression;
+            return parent.getParent() instanceof KtDoWhileExpression;
         }
 
-        private void visitFunction(@NotNull JetFunction function) {
+        private void visitFunction(@NotNull KtFunction function) {
             processLocalDeclaration(function);
-            boolean isAnonymousFunction = function instanceof JetFunctionLiteral || function.getName() == null;
-            if (isAnonymousFunction || (function.isLocal() && !(function.getParent() instanceof JetBlockExpression))) {
+            boolean isAnonymousFunction = function instanceof KtFunctionLiteral || function.getName() == null;
+            if (isAnonymousFunction || (function.isLocal() && !(function.getParent() instanceof KtBlockExpression))) {
                 builder.createLambda(function);
             }
         }
 
         @Override
-        public void visitNamedFunction(@NotNull JetNamedFunction function) {
+        public void visitNamedFunction(@NotNull KtNamedFunction function) {
             visitFunction(function);
         }
 
         @Override
-        public void visitFunctionLiteralExpression(@NotNull JetFunctionLiteralExpression expression) {
+        public void visitFunctionLiteralExpression(@NotNull KtFunctionLiteralExpression expression) {
             mark(expression);
-            JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
+            KtFunctionLiteral functionLiteral = expression.getFunctionLiteral();
             visitFunction(functionLiteral);
             copyValue(functionLiteral, expression);
         }
 
         @Override
-        public void visitQualifiedExpression(@NotNull JetQualifiedExpression expression) {
+        public void visitQualifiedExpression(@NotNull KtQualifiedExpression expression) {
             mark(expression);
-            JetExpression selectorExpression = expression.getSelectorExpression();
-            JetExpression receiverExpression = expression.getReceiverExpression();
+            KtExpression selectorExpression = expression.getSelectorExpression();
+            KtExpression receiverExpression = expression.getReceiverExpression();
 
             // todo: replace with selectorExpresion != null after parser is fixed
-            if (selectorExpression instanceof JetCallExpression || selectorExpression instanceof JetSimpleNameExpression) {
+            if (selectorExpression instanceof KtCallExpression || selectorExpression instanceof KtSimpleNameExpression) {
                 generateInstructions(selectorExpression);
                 copyValue(selectorExpression, expression);
             }
@@ -1104,17 +1104,17 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitCallExpression(@NotNull JetCallExpression expression) {
+        public void visitCallExpression(@NotNull KtCallExpression expression) {
             if (!generateCall(expression)) {
-                List<JetExpression> inputExpressions = new ArrayList<JetExpression>();
+                List<KtExpression> inputExpressions = new ArrayList<KtExpression>();
                 for (ValueArgument argument : expression.getValueArguments()) {
-                    JetExpression argumentExpression = argument.getArgumentExpression();
+                    KtExpression argumentExpression = argument.getArgumentExpression();
                     if (argumentExpression != null) {
                         generateInstructions(argumentExpression);
                         inputExpressions.add(argumentExpression);
                     }
                 }
-                JetExpression calleeExpression = expression.getCalleeExpression();
+                KtExpression calleeExpression = expression.getCalleeExpression();
                 generateInstructions(calleeExpression);
                 inputExpressions.add(calleeExpression);
                 inputExpressions.add(generateAndGetReceiverIfAny(expression));
@@ -1125,27 +1125,27 @@ public class JetControlFlowProcessor {
         }
 
         @Nullable
-        private JetExpression generateAndGetReceiverIfAny(JetExpression expression) {
+        private KtExpression generateAndGetReceiverIfAny(KtExpression expression) {
             PsiElement parent = expression.getParent();
-            if (!(parent instanceof JetQualifiedExpression)) return null;
+            if (!(parent instanceof KtQualifiedExpression)) return null;
 
-            JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) parent;
+            KtQualifiedExpression qualifiedExpression = (KtQualifiedExpression) parent;
             if (qualifiedExpression.getSelectorExpression() != expression) return null;
 
-            JetExpression receiverExpression = qualifiedExpression.getReceiverExpression();
+            KtExpression receiverExpression = qualifiedExpression.getReceiverExpression();
             generateInstructions(receiverExpression);
 
             return receiverExpression;
         }
 
         @Override
-        public void visitProperty(@NotNull JetProperty property) {
+        public void visitProperty(@NotNull KtProperty property) {
             builder.declareVariable(property);
-            JetExpression initializer = property.getInitializer();
+            KtExpression initializer = property.getInitializer();
             if (initializer != null) {
                 visitAssignment(property, getDeferredValue(initializer), property);
             }
-            JetExpression delegate = property.getDelegateExpression();
+            KtExpression delegate = property.getDelegateExpression();
             if (delegate != null) {
                 generateInstructions(delegate);
                 if (builder.getBoundValue(delegate) != null) {
@@ -1153,22 +1153,22 @@ public class JetControlFlowProcessor {
                 }
             }
 
-            if (JetPsiUtil.isLocal(property)) {
-                for (JetPropertyAccessor accessor : property.getAccessors()) {
+            if (KtPsiUtil.isLocal(property)) {
+                for (KtPropertyAccessor accessor : property.getAccessors()) {
                     generateInstructions(accessor);
                 }
             }
         }
 
         @Override
-        public void visitMultiDeclaration(@NotNull JetMultiDeclaration declaration) {
+        public void visitMultiDeclaration(@NotNull KtMultiDeclaration declaration) {
             visitMultiDeclaration(declaration, true);
         }
 
-        private void visitMultiDeclaration(@NotNull JetMultiDeclaration declaration, boolean generateWriteForEntries) {
-            JetExpression initializer = declaration.getInitializer();
+        private void visitMultiDeclaration(@NotNull KtMultiDeclaration declaration, boolean generateWriteForEntries) {
+            KtExpression initializer = declaration.getInitializer();
             generateInstructions(initializer);
-            for (JetMultiDeclarationEntry entry : declaration.getEntries()) {
+            for (KtMultiDeclarationEntry entry : declaration.getEntries()) {
                 builder.declareVariable(entry);
 
                 ResolvedCall<FunctionDescriptor> resolvedCall = trace.get(BindingContext.COMPONENT_RESOLVED_CALL, entry);
@@ -1193,17 +1193,17 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitPropertyAccessor(@NotNull JetPropertyAccessor accessor) {
+        public void visitPropertyAccessor(@NotNull KtPropertyAccessor accessor) {
             processLocalDeclaration(accessor);
         }
 
         @Override
-        public void visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS expression) {
+        public void visitBinaryWithTypeRHSExpression(@NotNull KtBinaryExpressionWithTypeRHS expression) {
             mark(expression);
 
             IElementType operationType = expression.getOperationReference().getReferencedNameElementType();
-            JetExpression left = expression.getLeft();
-            if (operationType == JetTokens.AS_KEYWORD || operationType == JetTokens.AS_SAFE) {
+            KtExpression left = expression.getLeft();
+            if (operationType == KtTokens.AS_KEYWORD || operationType == KtTokens.AS_SAFE) {
                 generateInstructions(left);
                 if (getBoundOrUnreachableValue(left) != null) {
                     createNonSyntheticValue(expression, MagicKind.CAST, left);
@@ -1216,10 +1216,10 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitThrowExpression(@NotNull JetThrowExpression expression) {
+        public void visitThrowExpression(@NotNull KtThrowExpression expression) {
             mark(expression);
 
-            JetExpression thrownExpression = expression.getThrownExpression();
+            KtExpression thrownExpression = expression.getThrownExpression();
             if (thrownExpression == null) return;
 
             generateInstructions(thrownExpression);
@@ -1231,34 +1231,34 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitArrayAccessExpression(@NotNull JetArrayAccessExpression expression) {
+        public void visitArrayAccessExpression(@NotNull KtArrayAccessExpression expression) {
             generateArrayAccess(expression, trace.get(BindingContext.INDEXED_LVALUE_GET, expression));
         }
 
         @Override
-        public void visitIsExpression(@NotNull JetIsExpression expression) {
+        public void visitIsExpression(@NotNull KtIsExpression expression) {
             mark(expression);
-            JetExpression left = expression.getLeftHandSide();
+            KtExpression left = expression.getLeftHandSide();
             generateInstructions(left);
             createNonSyntheticValue(expression, MagicKind.IS, left);
         }
 
         @Override
-        public void visitWhenExpression(@NotNull JetWhenExpression expression) {
+        public void visitWhenExpression(@NotNull KtWhenExpression expression) {
             mark(expression);
 
-            JetExpression subjectExpression = expression.getSubjectExpression();
+            KtExpression subjectExpression = expression.getSubjectExpression();
             if (subjectExpression != null) {
                 generateInstructions(subjectExpression);
             }
 
-            List<JetExpression> branches = new ArrayList<JetExpression>();
+            List<KtExpression> branches = new ArrayList<KtExpression>();
 
             Label doneLabel = builder.createUnboundLabel("after 'when' expression");
 
             Label nextLabel = null;
-            for (Iterator<JetWhenEntry> iterator = expression.getEntries().iterator(); iterator.hasNext(); ) {
-                JetWhenEntry whenEntry = iterator.next();
+            for (Iterator<KtWhenEntry> iterator = expression.getEntries().iterator(); iterator.hasNext(); ) {
+                KtWhenEntry whenEntry = iterator.next();
                 mark(whenEntry);
 
                 boolean isElse = whenEntry.isElse();
@@ -1269,9 +1269,9 @@ public class JetControlFlowProcessor {
                 }
                 Label bodyLabel = builder.createUnboundLabel("'when' entry body");
 
-                JetWhenCondition[] conditions = whenEntry.getConditions();
+                KtWhenCondition[] conditions = whenEntry.getConditions();
                 for (int i = 0; i < conditions.length; i++) {
-                    JetWhenCondition condition = conditions[i];
+                    KtWhenCondition condition = conditions[i];
                     condition.accept(conditionVisitor);
                     if (i + 1 < conditions.length) {
                         builder.nondeterministicJump(bodyLabel, expression, builder.getBoundValue(condition));
@@ -1280,12 +1280,12 @@ public class JetControlFlowProcessor {
 
                 if (!isElse) {
                     nextLabel = builder.createUnboundLabel("next 'when' entry");
-                    JetWhenCondition lastCondition = ArraysKt.lastOrNull(conditions);
+                    KtWhenCondition lastCondition = ArraysKt.lastOrNull(conditions);
                     builder.nondeterministicJump(nextLabel, expression, builder.getBoundValue(lastCondition));
                 }
 
                 builder.bindLabel(bodyLabel);
-                JetExpression whenEntryExpression = whenEntry.getExpression();
+                KtExpression whenEntryExpression = whenEntry.getExpression();
                 if (whenEntryExpression != null) {
                     generateInstructions(whenEntryExpression);
                     branches.add(whenEntryExpression);
@@ -1307,29 +1307,29 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitObjectLiteralExpression(@NotNull JetObjectLiteralExpression expression) {
+        public void visitObjectLiteralExpression(@NotNull KtObjectLiteralExpression expression) {
             mark(expression);
-            JetObjectDeclaration declaration = expression.getObjectDeclaration();
+            KtObjectDeclaration declaration = expression.getObjectDeclaration();
             generateInstructions(declaration);
 
             builder.createAnonymousObject(expression);
         }
 
         @Override
-        public void visitObjectDeclaration(@NotNull JetObjectDeclaration objectDeclaration) {
+        public void visitObjectDeclaration(@NotNull KtObjectDeclaration objectDeclaration) {
             generateHeaderDelegationSpecifiers(objectDeclaration);
             generateClassOrObjectInitializers(objectDeclaration);
             generateDeclarationForLocalClassOrObjectIfNeeded(objectDeclaration);
         }
 
         @Override
-        public void visitStringTemplateExpression(@NotNull JetStringTemplateExpression expression) {
+        public void visitStringTemplateExpression(@NotNull KtStringTemplateExpression expression) {
             mark(expression);
 
-            List<JetExpression> inputExpressions = new ArrayList<JetExpression>();
-            for (JetStringTemplateEntry entry : expression.getEntries()) {
-                if (entry instanceof JetStringTemplateEntryWithExpression) {
-                    JetExpression entryExpression = entry.getExpression();
+            List<KtExpression> inputExpressions = new ArrayList<KtExpression>();
+            for (KtStringTemplateEntry entry : expression.getEntries()) {
+                if (entry instanceof KtStringTemplateEntryWithExpression) {
+                    KtExpression entryExpression = entry.getExpression();
                     generateInstructions(entryExpression);
                     inputExpressions.add(entryExpression);
                 }
@@ -1338,31 +1338,31 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitTypeProjection(@NotNull JetTypeProjection typeProjection) {
+        public void visitTypeProjection(@NotNull KtTypeProjection typeProjection) {
             // TODO : Support Type Arguments. Companion object may be initialized at this point");
         }
 
         @Override
-        public void visitAnonymousInitializer(@NotNull JetClassInitializer classInitializer) {
+        public void visitAnonymousInitializer(@NotNull KtClassInitializer classInitializer) {
             generateInstructions(classInitializer.getBody());
         }
 
-        private void generateHeaderDelegationSpecifiers(@NotNull JetClassOrObject classOrObject) {
-            for (JetDelegationSpecifier specifier : classOrObject.getDelegationSpecifiers()) {
+        private void generateHeaderDelegationSpecifiers(@NotNull KtClassOrObject classOrObject) {
+            for (KtDelegationSpecifier specifier : classOrObject.getDelegationSpecifiers()) {
                 generateInstructions(specifier);
             }
         }
 
-        private void generateClassOrObjectInitializers(@NotNull JetClassOrObject classOrObject) {
-            for (JetDeclaration declaration : classOrObject.getDeclarations()) {
-                if (declaration instanceof JetProperty || declaration instanceof JetClassInitializer) {
+        private void generateClassOrObjectInitializers(@NotNull KtClassOrObject classOrObject) {
+            for (KtDeclaration declaration : classOrObject.getDeclarations()) {
+                if (declaration instanceof KtProperty || declaration instanceof KtClassInitializer) {
                     generateInstructions(declaration);
                 }
             }
         }
 
         @Override
-        public void visitClass(@NotNull JetClass klass) {
+        public void visitClass(@NotNull KtClass klass) {
             if (klass.hasPrimaryConstructor()) {
                 processParameters(klass.getPrimaryConstructorParameters());
 
@@ -1374,12 +1374,12 @@ public class JetControlFlowProcessor {
             generateDeclarationForLocalClassOrObjectIfNeeded(klass);
         }
 
-        private void generateDeclarationForLocalClassOrObjectIfNeeded(@NotNull JetClassOrObject classOrObject) {
+        private void generateDeclarationForLocalClassOrObjectIfNeeded(@NotNull KtClassOrObject classOrObject) {
             if (classOrObject.isLocal()) {
-                for (JetDeclaration declaration : classOrObject.getDeclarations()) {
-                    if (declaration instanceof JetSecondaryConstructor ||
-                        declaration instanceof JetProperty ||
-                        declaration instanceof JetClassInitializer) {
+                for (KtDeclaration declaration : classOrObject.getDeclarations()) {
+                    if (declaration instanceof KtSecondaryConstructor ||
+                        declaration instanceof KtProperty ||
+                        declaration instanceof KtClassInitializer) {
                         continue;
                     }
                     generateInstructions(declaration);
@@ -1387,15 +1387,15 @@ public class JetControlFlowProcessor {
             }
         }
 
-        private void processParameters(@NotNull List<JetParameter> parameters) {
-            for (JetParameter parameter : parameters) {
+        private void processParameters(@NotNull List<KtParameter> parameters) {
+            for (KtParameter parameter : parameters) {
                 generateInstructions(parameter);
             }
         }
 
         @Override
-        public void visitSecondaryConstructor(@NotNull JetSecondaryConstructor constructor) {
-            JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(constructor, JetClassOrObject.class);
+        public void visitSecondaryConstructor(@NotNull KtSecondaryConstructor constructor) {
+            KtClassOrObject classOrObject = PsiTreeUtil.getParentOfType(constructor, KtClassOrObject.class);
             assert classOrObject != null : "Guaranteed by parsing contract";
 
             processParameters(constructor.getValueParameters());
@@ -1409,24 +1409,24 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitDelegationToSuperCallSpecifier(@NotNull JetDelegatorToSuperCall call) {
+        public void visitDelegationToSuperCallSpecifier(@NotNull KtDelegatorToSuperCall call) {
             generateCallOrMarkUnresolved(call);
         }
 
-        private void generateCallOrMarkUnresolved(@Nullable JetCallElement call) {
+        private void generateCallOrMarkUnresolved(@Nullable KtCallElement call) {
             if (call == null) return;
             if (!generateCall(call)) {
-                List<JetExpression> arguments = CollectionsKt.map(
+                List<KtExpression> arguments = CollectionsKt.map(
                         call.getValueArguments(),
-                        new Function1<ValueArgument, JetExpression>() {
+                        new Function1<ValueArgument, KtExpression>() {
                             @Override
-                            public JetExpression invoke(ValueArgument valueArgument) {
+                            public KtExpression invoke(ValueArgument valueArgument) {
                                 return valueArgument.getArgumentExpression();
                             }
                         }
                 );
 
-                for (JetExpression argument : arguments) {
+                for (KtExpression argument : arguments) {
                     generateInstructions(argument);
                 }
                 createNonSyntheticValue(call, arguments, MagicKind.UNRESOLVED_CALL);
@@ -1434,43 +1434,43 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitDelegationByExpressionSpecifier(@NotNull JetDelegatorByExpressionSpecifier specifier) {
-            JetExpression delegateExpression = specifier.getDelegateExpression();
+        public void visitDelegationByExpressionSpecifier(@NotNull KtDelegatorByExpressionSpecifier specifier) {
+            KtExpression delegateExpression = specifier.getDelegateExpression();
             generateInstructions(delegateExpression);
             createSyntheticValue(specifier, MagicKind.VALUE_CONSUMER, delegateExpression);
         }
 
         @Override
-        public void visitDelegationToSuperClassSpecifier(@NotNull JetDelegatorToSuperClass specifier) {
+        public void visitDelegationToSuperClassSpecifier(@NotNull KtDelegatorToSuperClass specifier) {
             // Do not generate UNSUPPORTED_ELEMENT here
         }
 
         @Override
-        public void visitDelegationSpecifierList(@NotNull JetDelegationSpecifierList list) {
+        public void visitDelegationSpecifierList(@NotNull KtDelegationSpecifierList list) {
             list.acceptChildren(this);
         }
 
         @Override
-        public void visitJetFile(@NotNull JetFile file) {
-            for (JetDeclaration declaration : file.getDeclarations()) {
-                if (declaration instanceof JetProperty) {
+        public void visitJetFile(@NotNull KtFile file) {
+            for (KtDeclaration declaration : file.getDeclarations()) {
+                if (declaration instanceof KtProperty) {
                     generateInstructions(declaration);
                 }
             }
         }
 
         @Override
-        public void visitDoubleColonExpression(@NotNull JetDoubleColonExpression expression) {
+        public void visitDoubleColonExpression(@NotNull KtDoubleColonExpression expression) {
             mark(expression);
             createNonSyntheticValue(expression, MagicKind.CALLABLE_REFERENCE);
         }
 
         @Override
-        public void visitJetElement(@NotNull JetElement element) {
+        public void visitJetElement(@NotNull KtElement element) {
             createNonSyntheticValue(element, MagicKind.UNSUPPORTED_ELEMENT);
         }
 
-        private boolean generateCall(@Nullable JetElement callElement) {
+        private boolean generateCall(@Nullable KtElement callElement) {
             if (callElement == null) return false;
             return checkAndGenerateCall(CallUtilKt.getResolvedCall(callElement, trace.getBindingContext()));
         }
@@ -1483,14 +1483,14 @@ public class JetControlFlowProcessor {
 
         @NotNull
         private InstructionWithValue generateCall(@NotNull ResolvedCall<?> resolvedCall) {
-            JetElement callElement = resolvedCall.getCall().getCallElement();
+            KtElement callElement = resolvedCall.getCall().getCallElement();
 
             Map<PseudoValue, ReceiverValue> receivers = getReceiverValues(resolvedCall);
 
             SmartFMap<PseudoValue, ValueParameterDescriptor> parameterValues = SmartFMap.emptyMap();
             for (ValueArgument argument : resolvedCall.getCall().getValueArguments()) {
                 ArgumentMapping argumentMapping = resolvedCall.getArgumentMapping(argument);
-                JetExpression argumentExpression = argument.getArgumentExpression();
+                KtExpression argumentExpression = argument.getArgumentExpression();
                 if (argumentMapping instanceof ArgumentMatch) {
                     parameterValues = generateValueArgument(argument, ((ArgumentMatch) argumentMapping).getValueParameter(), parameterValues);
                 }
@@ -1503,7 +1503,7 @@ public class JetControlFlowProcessor {
             if (resolvedCall.getResultingDescriptor() instanceof VariableDescriptor) {
                 // If a callee of the call is just a variable (without 'invoke'), 'read variable' is generated.
                 // todo : process arguments for such a case (KT-5387)
-                JetExpression callExpression = callElement instanceof JetExpression ? (JetExpression) callElement : null;
+                KtExpression callExpression = callElement instanceof KtExpression ? (KtExpression) callElement : null;
                 assert callExpression != null
                         : "Variable-based call without callee expression: " + callElement.getText();
                 assert parameterValues.isEmpty()
@@ -1539,7 +1539,7 @@ public class JetControlFlowProcessor {
             if (explicitReceiver.exists() && varCallResult != null) {
                 receiverValues = receiverValues.plus(varCallResult, explicitReceiver);
             }
-            JetElement callElement = resolvedCall.getCall().getCallElement();
+            KtElement callElement = resolvedCall.getCall().getCallElement();
             receiverValues = getReceiverValues(callElement, resolvedCall.getDispatchReceiver(), receiverValues);
             receiverValues = getReceiverValues(callElement, resolvedCall.getExtensionReceiver(), receiverValues);
             return receiverValues;
@@ -1547,7 +1547,7 @@ public class JetControlFlowProcessor {
 
         @NotNull
         private SmartFMap<PseudoValue, ReceiverValue> getReceiverValues(
-                JetElement callElement,
+                KtElement callElement,
                 ReceiverValue receiver,
                 SmartFMap<PseudoValue, ReceiverValue> receiverValues
         ) {
@@ -1557,7 +1557,7 @@ public class JetControlFlowProcessor {
                 receiverValues = receiverValues.plus(createSyntheticValue(callElement, MagicKind.IMPLICIT_RECEIVER), receiver);
             }
             else if (receiver instanceof ExpressionReceiver) {
-                JetExpression expression = ((ExpressionReceiver) receiver).getExpression();
+                KtExpression expression = ((ExpressionReceiver) receiver).getExpression();
                 if (builder.getBoundValue(expression) == null) {
                     generateInstructions(expression);
                 }
@@ -1582,7 +1582,7 @@ public class JetControlFlowProcessor {
                 ValueArgument valueArgument,
                 ValueParameterDescriptor parameterDescriptor,
                 SmartFMap<PseudoValue, ValueParameterDescriptor> parameterValues) {
-            JetExpression expression = valueArgument.getArgumentExpression();
+            KtExpression expression = valueArgument.getArgumentExpression();
             if (expression != null) {
                 if (!valueArgument.isExternal()) {
                     generateInstructions(expression);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetFlowInformationProvider.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetFlowInformationProvider.java
index 954cc9984fe..223327c7b2f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetFlowInformationProvider.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetFlowInformationProvider.java
@@ -52,7 +52,7 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory;
 import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.idea.MainFunctionDetector;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilsKt;
@@ -60,7 +60,7 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.resolvedCallUtil.ResolvedCallUtilKt;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 
 import java.util.*;
@@ -76,13 +76,13 @@ import static org.jetbrains.kotlin.types.TypeUtils.noExpectedType;
 
 public class JetFlowInformationProvider {
 
-    private final JetElement subroutine;
+    private final KtElement subroutine;
     private final Pseudocode pseudocode;
     private final BindingTrace trace;
     private PseudocodeVariablesData pseudocodeVariablesData;
 
     private JetFlowInformationProvider(
-            @NotNull JetElement declaration,
+            @NotNull KtElement declaration,
             @NotNull BindingTrace trace,
             @NotNull Pseudocode pseudocode
     ) {
@@ -92,7 +92,7 @@ public class JetFlowInformationProvider {
     }
 
     public JetFlowInformationProvider(
-            @NotNull JetElement declaration,
+            @NotNull KtElement declaration,
             @NotNull BindingTrace trace
     ) {
         this(declaration, trace, new JetControlFlowProcessor(trace).generatePseudocode(declaration));
@@ -129,18 +129,18 @@ public class JetFlowInformationProvider {
         markWhenWithoutElse();
     }
 
-    public void checkFunction(@Nullable JetType expectedReturnType) {
+    public void checkFunction(@Nullable KtType expectedReturnType) {
         UnreachableCode unreachableCode = collectUnreachableCode();
         reportUnreachableCode(unreachableCode);
 
-        if (subroutine instanceof JetFunctionLiteral) return;
+        if (subroutine instanceof KtFunctionLiteral) return;
 
         checkDefiniteReturn(expectedReturnType != null ? expectedReturnType : NO_EXPECTED_TYPE, unreachableCode);
 
         markTailCalls();
     }
 
-    private void collectReturnExpressions(@NotNull final Collection<JetElement> returnedExpressions) {
+    private void collectReturnExpressions(@NotNull final Collection<KtElement> returnedExpressions) {
         final Set<Instruction> instructions = Sets.newHashSet(pseudocode.getInstructions());
         SubroutineExitInstruction exitInstruction = pseudocode.getExitInstruction();
         for (Instruction previousInstruction : exitInstruction.getPreviousInstructions()) {
@@ -202,13 +202,13 @@ public class JetFlowInformationProvider {
 
     private void checkLocalFunctions() {
         for (LocalFunctionDeclarationInstruction localDeclarationInstruction : pseudocode.getLocalDeclarations()) {
-            JetElement element = localDeclarationInstruction.getElement();
-            if (element instanceof JetDeclarationWithBody) {
-                JetDeclarationWithBody localDeclaration = (JetDeclarationWithBody) element;
+            KtElement element = localDeclarationInstruction.getElement();
+            if (element instanceof KtDeclarationWithBody) {
+                KtDeclarationWithBody localDeclaration = (KtDeclarationWithBody) element;
 
                 CallableDescriptor functionDescriptor =
                         (CallableDescriptor) trace.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, localDeclaration);
-                JetType expectedType = functionDescriptor != null ? functionDescriptor.getReturnType() : null;
+                KtType expectedType = functionDescriptor != null ? functionDescriptor.getReturnType() : null;
 
                 JetFlowInformationProvider providerForLocalDeclaration =
                         new JetFlowInformationProvider(localDeclaration, trace, localDeclarationInstruction.getBody());
@@ -218,30 +218,30 @@ public class JetFlowInformationProvider {
         }
     }
 
-    public void checkDefiniteReturn(final @NotNull JetType expectedReturnType, @NotNull final UnreachableCode unreachableCode) {
-        assert subroutine instanceof JetDeclarationWithBody;
-        JetDeclarationWithBody function = (JetDeclarationWithBody) subroutine;
+    public void checkDefiniteReturn(final @NotNull KtType expectedReturnType, @NotNull final UnreachableCode unreachableCode) {
+        assert subroutine instanceof KtDeclarationWithBody;
+        KtDeclarationWithBody function = (KtDeclarationWithBody) subroutine;
 
         if (!function.hasBody()) return;
 
-        List<JetElement> returnedExpressions = Lists.newArrayList();
+        List<KtElement> returnedExpressions = Lists.newArrayList();
         collectReturnExpressions(returnedExpressions);
 
         final boolean blockBody = function.hasBlockBody();
 
         final boolean[] noReturnError = new boolean[] { false };
-        for (JetElement returnedExpression : returnedExpressions) {
-            returnedExpression.accept(new JetVisitorVoid() {
+        for (KtElement returnedExpression : returnedExpressions) {
+            returnedExpression.accept(new KtVisitorVoid() {
                 @Override
-                public void visitReturnExpression(@NotNull JetReturnExpression expression) {
+                public void visitReturnExpression(@NotNull KtReturnExpression expression) {
                     if (!blockBody) {
                         trace.report(RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY.on(expression));
                     }
                 }
 
                 @Override
-                public void visitJetElement(@NotNull JetElement element) {
-                    if (!(element instanceof JetExpression || element instanceof JetWhenCondition)) return;
+                public void visitJetElement(@NotNull KtElement element) {
+                    if (!(element instanceof KtExpression || element instanceof KtWhenCondition)) return;
 
                     if (blockBody && !noExpectedType(expectedReturnType)
                             && !KotlinBuiltIns.isUnit(expectedReturnType)
@@ -257,7 +257,7 @@ public class JetFlowInformationProvider {
     }
 
     private void reportUnreachableCode(@NotNull UnreachableCode unreachableCode) {
-        for (JetElement element : unreachableCode.getElements()) {
+        for (KtElement element : unreachableCode.getElements()) {
             trace.report(UNREACHABLE_CODE.on(element, unreachableCode.getUnreachableTextRanges(element)));
             trace.record(BindingContext.UNREACHABLE_CODE, element, true);
         }
@@ -265,21 +265,21 @@ public class JetFlowInformationProvider {
 
     @NotNull
     private UnreachableCode collectUnreachableCode() {
-        Set<JetElement> reachableElements = Sets.newHashSet();
-        Set<JetElement> unreachableElements = Sets.newHashSet();
+        Set<KtElement> reachableElements = Sets.newHashSet();
+        Set<KtElement> unreachableElements = Sets.newHashSet();
         for (Instruction instruction : pseudocode.getInstructionsIncludingDeadCode()) {
             if (!(instruction instanceof JetElementInstruction)
                     || instruction instanceof LoadUnitValueInstruction
                     || instruction instanceof MergeInstruction
                     || (instruction instanceof MagicInstruction && ((MagicInstruction) instruction).getSynthetic())) continue;
 
-            JetElement element = ((JetElementInstruction) instruction).getElement();
+            KtElement element = ((JetElementInstruction) instruction).getElement();
 
             if (instruction instanceof JumpInstruction) {
-                boolean isJumpElement = element instanceof JetBreakExpression
-                                        || element instanceof JetContinueExpression
-                                        || element instanceof JetReturnExpression
-                                        || element instanceof JetThrowExpression;
+                boolean isJumpElement = element instanceof KtBreakExpression
+                                        || element instanceof KtContinueExpression
+                                        || element instanceof KtReturnExpression
+                                        || element instanceof KtThrowExpression;
                 if (!isJumpElement) continue;
             }
 
@@ -299,7 +299,7 @@ public class JetFlowInformationProvider {
     public void markUninitializedVariables() {
         final Collection<VariableDescriptor> varWithUninitializedErrorGenerated = Sets.newHashSet();
         final Collection<VariableDescriptor> varWithValReassignErrorGenerated = Sets.newHashSet();
-        final boolean processClassOrObject = subroutine instanceof JetClassOrObject;
+        final boolean processClassOrObject = subroutine instanceof KtClassOrObject;
 
         PseudocodeVariablesData pseudocodeVariablesData = getPseudocodeVariablesData();
         Map<Instruction, Edges<Map<VariableDescriptor, VariableControlFlowState>>> initializers =
@@ -324,7 +324,7 @@ public class JetFlowInformationProvider {
                         if (ctxt.variableDescriptor == null) return;
                         if (instruction instanceof ReadValueInstruction) {
                             ReadValueInstruction readValueInstruction = (ReadValueInstruction) instruction;
-                            JetElement element = readValueInstruction.getElement();
+                            KtElement element = readValueInstruction.getElement();
                             boolean error = checkBackingField(ctxt, element);
                             if (!error &&
                                 PseudocodeUtil.isThisOrNoDispatchReceiver(readValueInstruction, trace.getBindingContext()) &&
@@ -335,18 +335,18 @@ public class JetFlowInformationProvider {
                         }
                         if (!(instruction instanceof WriteValueInstruction)) return;
                         WriteValueInstruction writeValueInstruction = (WriteValueInstruction) instruction;
-                        JetElement element = writeValueInstruction.getLValue();
+                        KtElement element = writeValueInstruction.getLValue();
                         boolean error = checkBackingField(ctxt, element);
-                        if (!(element instanceof JetExpression)) return;
+                        if (!(element instanceof KtExpression)) return;
                         if (!error) {
-                            error = checkValReassignment(ctxt, (JetExpression) element, writeValueInstruction,
+                            error = checkValReassignment(ctxt, (KtExpression) element, writeValueInstruction,
                                                          varWithValReassignErrorGenerated);
                         }
                         if (!error && processClassOrObject) {
-                            error = checkAssignmentBeforeDeclaration(ctxt, (JetExpression) element);
+                            error = checkAssignmentBeforeDeclaration(ctxt, (KtExpression) element);
                         }
                         if (!error && processClassOrObject) {
-                            checkInitializationUsingBackingField(ctxt, (JetExpression) element);
+                            checkInitializationUsingBackingField(ctxt, (KtExpression) element);
                         }
                     }
                 }
@@ -366,10 +366,10 @@ public class JetFlowInformationProvider {
 
     private void checkIsInitialized(
             @NotNull VariableInitContext ctxt,
-            @NotNull JetElement element,
+            @NotNull KtElement element,
             @NotNull Collection<VariableDescriptor> varWithUninitializedErrorGenerated
     ) {
-        if (!(element instanceof JetSimpleNameExpression)) return;
+        if (!(element instanceof KtSimpleNameExpression)) return;
 
 
         boolean isDefinitelyInitialized = ctxt.exitInitState.definitelyInitialized();
@@ -385,25 +385,25 @@ public class JetFlowInformationProvider {
                 varWithUninitializedErrorGenerated.add(variableDescriptor);
             }
             if (variableDescriptor instanceof ValueParameterDescriptor) {
-                report(Errors.UNINITIALIZED_PARAMETER.on((JetSimpleNameExpression) element,
+                report(Errors.UNINITIALIZED_PARAMETER.on((KtSimpleNameExpression) element,
                                                          (ValueParameterDescriptor) variableDescriptor), ctxt);
             }
             else {
-                report(Errors.UNINITIALIZED_VARIABLE.on((JetSimpleNameExpression) element, variableDescriptor), ctxt);
+                report(Errors.UNINITIALIZED_VARIABLE.on((KtSimpleNameExpression) element, variableDescriptor), ctxt);
             }
         }
     }
 
     private boolean checkValReassignment(
             @NotNull VariableInitContext ctxt,
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             @NotNull WriteValueInstruction writeValueInstruction,
             @NotNull Collection<VariableDescriptor> varWithValReassignErrorGenerated
     ) {
         VariableDescriptor variableDescriptor = ctxt.variableDescriptor;
         PropertyDescriptor propertyDescriptor = SyntheticFieldDescriptorKt.getReferencedProperty(variableDescriptor);
-        if (JetPsiUtil.isBackingFieldReference(expression, variableDescriptor) && propertyDescriptor != null) {
-            JetPropertyAccessor accessor = PsiTreeUtil.getParentOfType(expression, JetPropertyAccessor.class);
+        if (KtPsiUtil.isBackingFieldReference(expression, variableDescriptor) && propertyDescriptor != null) {
+            KtPropertyAccessor accessor = PsiTreeUtil.getParentOfType(expression, KtPropertyAccessor.class);
             if (accessor != null) {
                 DeclarationDescriptor accessorDescriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, accessor);
                 if (propertyDescriptor.getGetter() == accessorDescriptor) {
@@ -440,13 +440,13 @@ public class JetFlowInformationProvider {
                 PseudocodeUtil.isThisOrNoDispatchReceiver(writeValueInstruction, trace.getBindingContext());
         if ((mayBeInitializedNotHere || !hasBackingField || !isThisOrNoDispatchReceiver) && !variableDescriptor.isVar()) {
             boolean hasReassignMethodReturningUnit = false;
-            JetSimpleNameExpression operationReference = null;
+            KtSimpleNameExpression operationReference = null;
             PsiElement parent = expression.getParent();
-            if (parent instanceof JetBinaryExpression) {
-                operationReference = ((JetBinaryExpression) parent).getOperationReference();
+            if (parent instanceof KtBinaryExpression) {
+                operationReference = ((KtBinaryExpression) parent).getOperationReference();
             }
-            else if (parent instanceof JetUnaryExpression) {
-                operationReference = ((JetUnaryExpression) parent).getOperationReference();
+            else if (parent instanceof KtUnaryExpression) {
+                operationReference = ((KtUnaryExpression) parent).getOperationReference();
             }
             if (operationReference != null) {
                 DeclarationDescriptor descriptor = trace.get(BindingContext.REFERENCE_TARGET, operationReference);
@@ -482,7 +482,7 @@ public class JetFlowInformationProvider {
         return false;
     }
 
-    private boolean checkAssignmentBeforeDeclaration(@NotNull VariableInitContext ctxt, @NotNull JetExpression expression) {
+    private boolean checkAssignmentBeforeDeclaration(@NotNull VariableInitContext ctxt, @NotNull KtExpression expression) {
         if (!ctxt.enterInitState.isDeclared && !ctxt.exitInitState.isDeclared
             && !ctxt.enterInitState.mayBeInitialized() && ctxt.exitInitState.mayBeInitialized()) {
             report(Errors.INITIALIZATION_BEFORE_DECLARATION.on(expression, ctxt.variableDescriptor), ctxt);
@@ -491,7 +491,7 @@ public class JetFlowInformationProvider {
         return false;
     }
 
-    private boolean checkInitializationUsingBackingField(@NotNull VariableInitContext ctxt, @NotNull JetExpression expression) {
+    private boolean checkInitializationUsingBackingField(@NotNull VariableInitContext ctxt, @NotNull KtExpression expression) {
         VariableDescriptor variableDescriptor = ctxt.variableDescriptor;
         if (variableDescriptor instanceof PropertyDescriptor
             && !ctxt.enterInitState.mayBeInitialized()
@@ -499,20 +499,20 @@ public class JetFlowInformationProvider {
             if (!variableDescriptor.isVar()) return false;
             if (!trace.get(BindingContext.BACKING_FIELD_REQUIRED, (PropertyDescriptor) variableDescriptor)) return false;
             PsiElement property = DescriptorToSourceUtils.descriptorToDeclaration(variableDescriptor);
-            assert property instanceof JetProperty;
-            JetPropertyAccessor setter = ((JetProperty) property).getSetter();
+            assert property instanceof KtProperty;
+            KtPropertyAccessor setter = ((KtProperty) property).getSetter();
             if (((PropertyDescriptor) variableDescriptor).getModality() == Modality.FINAL && (setter == null || !setter.hasBody())) {
                 return false;
             }
-            JetExpression variable = expression;
-            if (expression instanceof JetDotQualifiedExpression) {
-                if (((JetDotQualifiedExpression) expression).getReceiverExpression() instanceof JetThisExpression) {
-                    variable = ((JetDotQualifiedExpression) expression).getSelectorExpression();
+            KtExpression variable = expression;
+            if (expression instanceof KtDotQualifiedExpression) {
+                if (((KtDotQualifiedExpression) expression).getReceiverExpression() instanceof KtThisExpression) {
+                    variable = ((KtDotQualifiedExpression) expression).getSelectorExpression();
                 }
             }
-            if (variable instanceof JetSimpleNameExpression) {
-                JetSimpleNameExpression simpleNameExpression = (JetSimpleNameExpression) variable;
-                if (simpleNameExpression.getReferencedNameElementType() != JetTokens.FIELD_IDENTIFIER) {
+            if (variable instanceof KtSimpleNameExpression) {
+                KtSimpleNameExpression simpleNameExpression = (KtSimpleNameExpression) variable;
+                if (simpleNameExpression.getReferencedNameElementType() != KtTokens.FIELD_IDENTIFIER) {
                     trace.record(IS_UNINITIALIZED, (PropertyDescriptor) variableDescriptor);
                     return true;
                 }
@@ -521,7 +521,7 @@ public class JetFlowInformationProvider {
         return false;
     }
 
-    private boolean checkBackingField(@NotNull VariableContext cxtx, @NotNull JetElement element) {
+    private boolean checkBackingField(@NotNull VariableContext cxtx, @NotNull KtElement element) {
         VariableDescriptor variableDescriptor = cxtx.variableDescriptor;
         boolean[] error = new boolean[1];
         if (!isCorrectBackingFieldReference(element, cxtx, error, true)) return false;
@@ -551,8 +551,8 @@ public class JetFlowInformationProvider {
         DeclarationDescriptor containingDeclaration = variableDescriptor.getContainingDeclaration();
         if ((containingDeclaration instanceof ClassDescriptor)
                 && DescriptorUtils.isAncestor(containingDeclaration, declarationDescriptor, false)) {
-            if (element instanceof JetSimpleNameExpression) {
-                report(Errors.BACKING_FIELD_USAGE_FORBIDDEN.on((JetSimpleNameExpression) element), cxtx);
+            if (element instanceof KtSimpleNameExpression) {
+                report(Errors.BACKING_FIELD_USAGE_FORBIDDEN.on((KtSimpleNameExpression) element), cxtx);
             }
             return false;
         }
@@ -561,18 +561,18 @@ public class JetFlowInformationProvider {
     }
 
     private boolean isCorrectBackingFieldReference(
-            @Nullable JetElement element,
+            @Nullable KtElement element,
             VariableContext ctxt,
             boolean[] error,
             boolean reportError
     ) {
         error[0] = false;
-        if (JetPsiUtil.isBackingFieldReference(element, null)) {
+        if (KtPsiUtil.isBackingFieldReference(element, null)) {
             return true;
         }
-        if (element instanceof JetDotQualifiedExpression && isCorrectBackingFieldReference(
-                ((JetDotQualifiedExpression) element).getSelectorExpression(), ctxt, error, false)) {
-            if (((JetDotQualifiedExpression) element).getReceiverExpression() instanceof JetThisExpression) {
+        if (element instanceof KtDotQualifiedExpression && isCorrectBackingFieldReference(
+                ((KtDotQualifiedExpression) element).getSelectorExpression(), ctxt, error, false)) {
+            if (((KtDotQualifiedExpression) element).getReceiverExpression() instanceof KtThisExpression) {
                 return true;
             }
             error[0] = true;
@@ -629,50 +629,50 @@ public class JetFlowInformationProvider {
                         PseudocodeVariablesData.VariableUseState variableUseState = in.get(variableDescriptor);
                         if (instruction instanceof WriteValueInstruction) {
                             if (trace.get(CAPTURED_IN_CLOSURE, variableDescriptor) != null) return;
-                            JetElement element = ((WriteValueInstruction) instruction).getElement();
+                            KtElement element = ((WriteValueInstruction) instruction).getElement();
                             if (variableUseState != READ) {
-                                if (element instanceof JetBinaryExpression &&
-                                    ((JetBinaryExpression) element).getOperationToken() == JetTokens.EQ) {
-                                    JetExpression right = ((JetBinaryExpression) element).getRight();
+                                if (element instanceof KtBinaryExpression &&
+                                    ((KtBinaryExpression) element).getOperationToken() == KtTokens.EQ) {
+                                    KtExpression right = ((KtBinaryExpression) element).getRight();
                                     if (right != null) {
-                                        report(Errors.UNUSED_VALUE.on((JetBinaryExpression) element, right, variableDescriptor), ctxt);
+                                        report(Errors.UNUSED_VALUE.on((KtBinaryExpression) element, right, variableDescriptor), ctxt);
                                     }
                                 }
-                                else if (element instanceof JetPostfixExpression) {
+                                else if (element instanceof KtPostfixExpression) {
                                     IElementType operationToken =
-                                            ((JetPostfixExpression) element).getOperationReference().getReferencedNameElementType();
-                                    if (operationToken == JetTokens.PLUSPLUS || operationToken == JetTokens.MINUSMINUS) {
+                                            ((KtPostfixExpression) element).getOperationReference().getReferencedNameElementType();
+                                    if (operationToken == KtTokens.PLUSPLUS || operationToken == KtTokens.MINUSMINUS) {
                                         report(Errors.UNUSED_CHANGED_VALUE.on(element, element), ctxt);
                                     }
                                 }
                             }
                         }
                         else if (instruction instanceof VariableDeclarationInstruction) {
-                            JetDeclaration element = ((VariableDeclarationInstruction) instruction).getVariableDeclarationElement();
-                            if (!(element instanceof JetNamedDeclaration)) return;
-                            PsiElement nameIdentifier = ((JetNamedDeclaration) element).getNameIdentifier();
+                            KtDeclaration element = ((VariableDeclarationInstruction) instruction).getVariableDeclarationElement();
+                            if (!(element instanceof KtNamedDeclaration)) return;
+                            PsiElement nameIdentifier = ((KtNamedDeclaration) element).getNameIdentifier();
                             if (nameIdentifier == null) return;
                             if (!VariableUseState.isUsed(variableUseState)) {
-                                if (JetPsiUtil.isVariableNotParameterDeclaration(element)) {
-                                    report(Errors.UNUSED_VARIABLE.on((JetNamedDeclaration) element, variableDescriptor), ctxt);
+                                if (KtPsiUtil.isVariableNotParameterDeclaration(element)) {
+                                    report(Errors.UNUSED_VARIABLE.on((KtNamedDeclaration) element, variableDescriptor), ctxt);
                                 }
-                                else if (element instanceof JetParameter) {
+                                else if (element instanceof KtParameter) {
                                     PsiElement owner = element.getParent().getParent();
-                                    if (owner instanceof JetPrimaryConstructor) {
-                                        if (!((JetParameter) element).hasValOrVar()) {
-                                            JetClassOrObject containingClass = ((JetPrimaryConstructor) owner).getContainingClassOrObject();
+                                    if (owner instanceof KtPrimaryConstructor) {
+                                        if (!((KtParameter) element).hasValOrVar()) {
+                                            KtClassOrObject containingClass = ((KtPrimaryConstructor) owner).getContainingClassOrObject();
                                             DeclarationDescriptor containingClassDescriptor = trace.get(
                                                     BindingContext.DECLARATION_TO_DESCRIPTOR, containingClass
                                             );
                                             if (!DescriptorUtils.isAnnotationClass(containingClassDescriptor)) {
-                                                report(Errors.UNUSED_PARAMETER.on((JetParameter) element, variableDescriptor), ctxt);
+                                                report(Errors.UNUSED_PARAMETER.on((KtParameter) element, variableDescriptor), ctxt);
                                             }
                                         }
                                     }
-                                    else if (owner instanceof JetFunction) {
+                                    else if (owner instanceof KtFunction) {
                                         MainFunctionDetector mainFunctionDetector = new MainFunctionDetector(trace.getBindingContext());
-                                        boolean isMain = (owner instanceof JetNamedFunction) && mainFunctionDetector.isMain((JetNamedFunction) owner);
-                                        if (owner instanceof JetFunctionLiteral) return;
+                                        boolean isMain = (owner instanceof KtNamedFunction) && mainFunctionDetector.isMain((KtNamedFunction) owner);
+                                        if (owner instanceof KtFunctionLiteral) return;
                                         DeclarationDescriptor descriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, owner);
                                         assert descriptor instanceof FunctionDescriptor : owner.getText();
                                         FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor;
@@ -685,21 +685,21 @@ public class JetFlowInformationProvider {
                                                 ) {
                                             return;
                                         }
-                                        report(Errors.UNUSED_PARAMETER.on((JetParameter) element, variableDescriptor), ctxt);
+                                        report(Errors.UNUSED_PARAMETER.on((KtParameter) element, variableDescriptor), ctxt);
                                     }
                                 }
                             }
-                            else if (variableUseState == ONLY_WRITTEN_NEVER_READ && JetPsiUtil.isVariableNotParameterDeclaration(element)) {
-                                report(Errors.ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE.on((JetNamedDeclaration) element, variableDescriptor), ctxt);
+                            else if (variableUseState == ONLY_WRITTEN_NEVER_READ && KtPsiUtil.isVariableNotParameterDeclaration(element)) {
+                                report(Errors.ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE.on((KtNamedDeclaration) element, variableDescriptor), ctxt);
                             }
-                            else if (variableUseState == WRITTEN_AFTER_READ && element instanceof JetVariableDeclaration) {
-                                if (element instanceof JetProperty) {
-                                    JetExpression initializer = ((JetProperty) element).getInitializer();
+                            else if (variableUseState == WRITTEN_AFTER_READ && element instanceof KtVariableDeclaration) {
+                                if (element instanceof KtProperty) {
+                                    KtExpression initializer = ((KtProperty) element).getInitializer();
                                     if (initializer != null) {
                                         report(Errors.VARIABLE_WITH_REDUNDANT_INITIALIZER.on(initializer, variableDescriptor), ctxt);
                                     }
                                 }
-                                else if (element instanceof JetMultiDeclarationEntry) {
+                                else if (element instanceof KtMultiDeclarationEntry) {
                                     report(VARIABLE_WITH_REDUNDANT_INITIALIZER.on(element, variableDescriptor), ctxt);
                                 }
                             }
@@ -720,15 +720,15 @@ public class JetFlowInformationProvider {
                     public void execute(@NotNull Instruction instruction) {
                         if (!(instruction instanceof JetElementInstruction)) return;
 
-                        JetElement element = ((JetElementInstruction)instruction).getElement();
-                        if (!(element instanceof JetExpression)) return;
+                        KtElement element = ((JetElementInstruction)instruction).getElement();
+                        if (!(element instanceof KtExpression)) return;
 
-                        if (BindingContextUtilsKt.isUsedAsStatement((JetExpression) element, trace.getBindingContext())
+                        if (BindingContextUtilsKt.isUsedAsStatement((KtExpression) element, trace.getBindingContext())
                             && PseudocodeUtilsKt.getSideEffectFree(instruction)) {
                             VariableContext ctxt = new VariableContext(instruction, reportedDiagnosticMap);
                             report(
-                                    element instanceof JetFunctionLiteralExpression
-                                        ? Errors.UNUSED_FUNCTION_LITERAL.on((JetFunctionLiteralExpression) element)
+                                    element instanceof KtFunctionLiteralExpression
+                                        ? Errors.UNUSED_FUNCTION_LITERAL.on((KtFunctionLiteralExpression) element)
                                         : Errors.UNUSED_EXPRESSION.on(element),
                                     ctxt
                             );
@@ -751,7 +751,7 @@ public class JetFlowInformationProvider {
                                             : null;
                         Pseudocode pseudocode = instruction.getOwner();
                         boolean isUsedAsExpression = !pseudocode.getUsages(value).isEmpty();
-                        for (JetElement element : pseudocode.getValueElements(value)) {
+                        for (KtElement element : pseudocode.getValueElements(value)) {
                             trace.record(BindingContext.USED_AS_EXPRESSION, element, isUsedAsExpression);
                         }
                     }
@@ -767,9 +767,9 @@ public class JetFlowInformationProvider {
                         PseudoValue value = instruction instanceof InstructionWithValue
                                             ? ((InstructionWithValue) instruction).getOutputValue()
                                             : null;
-                        for (JetElement element : instruction.getOwner().getValueElements(value)) {
-                            if (!(element instanceof JetWhenExpression)) continue;
-                            JetWhenExpression whenExpression = (JetWhenExpression) element;
+                        for (KtElement element : instruction.getOwner().getValueElements(value)) {
+                            if (!(element instanceof KtWhenExpression)) continue;
+                            KtWhenExpression whenExpression = (KtWhenExpression) element;
                             if (whenExpression.getElseExpression() != null) continue;
 
                             if (WhenChecker.mustHaveElse(whenExpression, trace)) {
@@ -807,7 +807,7 @@ public class JetFlowInformationProvider {
                 this.call = call;
             }
         }
-        final Map<JetElement, KindAndCall> calls = new HashMap<JetElement, KindAndCall>();
+        final Map<KtElement, KindAndCall> calls = new HashMap<KtElement, KindAndCall>();
         PseudocodeTraverserKt.traverse(
                 pseudocode,
                 FORWARD,
@@ -823,14 +823,14 @@ public class JetFlowInformationProvider {
                         CallableDescriptor functionDescriptor = resolvedCall.getResultingDescriptor();
                         if (!functionDescriptor.getOriginal().equals(subroutineDescriptor)) return;
 
-                        JetElement element = callInstruction.getElement();
+                        KtElement element = callInstruction.getElement();
                         //noinspection unchecked
-                        JetExpression parent = PsiTreeUtil.getParentOfType(
+                        KtExpression parent = PsiTreeUtil.getParentOfType(
                                 element,
-                                JetTryExpression.class, JetFunction.class, JetClassInitializer.class
+                                KtTryExpression.class, KtFunction.class, KtClassInitializer.class
                         );
 
-                        if (parent instanceof JetTryExpression) {
+                        if (parent instanceof KtTryExpression) {
                             // We do not support tail calls Collections.singletonMap() try-catch-finally, for simplicity of the mental model
                             // very few cases there would be real tail-calls, and it's often not so easy for the user to see why
                             calls.put(element, new KindAndCall(IN_TRY, resolvedCall));
@@ -866,8 +866,8 @@ public class JetFlowInformationProvider {
                 }
         );
         boolean hasTailCalls = false;
-        for (Map.Entry<JetElement, KindAndCall> entry : calls.entrySet()) {
-            JetElement element = entry.getKey();
+        for (Map.Entry<KtElement, KindAndCall> entry : calls.entrySet()) {
+            KtElement element = entry.getKey();
             KindAndCall kindAndCall = entry.getValue();
             switch (kindAndCall.kind) {
                 case TAIL_CALL:
@@ -884,7 +884,7 @@ public class JetFlowInformationProvider {
         }
 
         if (!hasTailCalls) {
-            trace.report(Errors.NO_TAIL_CALLS_FOUND.on((JetNamedFunction) subroutine));
+            trace.report(Errors.NO_TAIL_CALLS_FOUND.on((KtNamedFunction) subroutine));
         }
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/LoopInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/LoopInfo.java
index 99759a62ee6..b6435a941f1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/LoopInfo.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/LoopInfo.java
@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.cfg;
 
-import org.jetbrains.kotlin.psi.JetLoopExpression;
+import org.jetbrains.kotlin.psi.KtLoopExpression;
 
 public class LoopInfo extends BreakableBlockInfo {
     private final Label bodyEntryPoint;
@@ -24,7 +24,7 @@ public class LoopInfo extends BreakableBlockInfo {
     private final Label conditionEntryPoint;
 
     public LoopInfo(
-            JetLoopExpression loopExpression,
+            KtLoopExpression loopExpression,
             Label entryPoint,
             Label exitPoint,
             Label bodyEntryPoint,
@@ -39,8 +39,8 @@ public class LoopInfo extends BreakableBlockInfo {
     }
 
     @Override
-    public JetLoopExpression getElement() {
-        return (JetLoopExpression) super.getElement();
+    public KtLoopExpression getElement() {
+        return (KtLoopExpression) super.getElement();
     }
 
     public Label getBodyEntryPoint() {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariablesData.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariablesData.java
index 4b6843918c0..9798d3d54e8 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariablesData.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariablesData.java
@@ -31,8 +31,8 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.VariableDeclarat
 import org.jetbrains.kotlin.cfg.pseudocodeTraverser.Edges;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.VariableDescriptor;
-import org.jetbrains.kotlin.psi.JetDeclaration;
-import org.jetbrains.kotlin.psi.JetProperty;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtProperty;
 import org.jetbrains.kotlin.resolve.BindingContext;
 
 import java.util.Collection;
@@ -98,7 +98,7 @@ public class PseudocodeVariablesData {
         Set<VariableDescriptor> declaredVariables = Sets.newHashSet();
         for (Instruction instruction : pseudocode.getInstructions()) {
             if (instruction instanceof VariableDeclarationInstruction) {
-                JetDeclaration variableDeclarationElement = ((VariableDeclarationInstruction) instruction).getVariableDeclarationElement();
+                KtDeclaration variableDeclarationElement = ((VariableDeclarationInstruction) instruction).getVariableDeclarationElement();
                 DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, variableDeclarationElement);
                 if (descriptor != null) {
                     assert descriptor instanceof VariableDescriptor;
@@ -211,7 +211,7 @@ public class PseudocodeVariablesData {
             VariableControlFlowState enterInitState = enterInstructionData.get(variable);
             VariableControlFlowState initializationAtThisElement =
                     VariableControlFlowState
-                            .create(((WriteValueInstruction) instruction).getElement() instanceof JetProperty, enterInitState);
+                            .create(((WriteValueInstruction) instruction).getElement() instanceof KtProperty, enterInitState);
             exitInstructionData.put(variable, initializationAtThisElement);
         }
         else { // instruction instanceof VariableDeclarationInstruction
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/TailRecursionDetector.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/TailRecursionDetector.java
index 60dd84faf4f..96bced33dd5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/TailRecursionDetector.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/TailRecursionDetector.java
@@ -27,13 +27,13 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.jumps.ThrowExceptionInst
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.MarkInstruction;
 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.KtElement;
 
 public class TailRecursionDetector extends InstructionVisitorWithResult<Boolean> implements Function1<Instruction, Boolean> {
-    private final JetElement subroutine;
+    private final KtElement subroutine;
     private final Instruction start;
 
-    public TailRecursionDetector(@NotNull JetElement subroutine, @NotNull Instruction start) {
+    public TailRecursionDetector(@NotNull KtElement subroutine, @NotNull Instruction start) {
         this.subroutine = subroutine;
         this.start = start;
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/UnreachableCode.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/UnreachableCode.kt
index 8d7ea3c4106..80fd2e7cdb1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/UnreachableCode.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/UnreachableCode.kt
@@ -22,25 +22,25 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiWhiteSpace
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetPsiUtil
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtPsiUtil
 import java.util.*
 
 interface UnreachableCode {
-    val elements: Set<JetElement>
-    fun getUnreachableTextRanges(element: JetElement): List<TextRange>
+    val elements: Set<KtElement>
+    fun getUnreachableTextRanges(element: KtElement): List<TextRange>
 }
 
 class UnreachableCodeImpl(
-        private val reachableElements: Set<JetElement>,
-        private val unreachableElements: Set<JetElement>
+        private val reachableElements: Set<KtElement>,
+        private val unreachableElements: Set<KtElement>
 ) : UnreachableCode {
 
     // This is needed in order to highlight only '1 < 2' and not '1', '<' and '2' as well
-    override val elements = JetPsiUtil.findRootExpressions(unreachableElements)
+    override val elements = KtPsiUtil.findRootExpressions(unreachableElements)
 
-    override fun getUnreachableTextRanges(element: JetElement): List<TextRange> {
+    override fun getUnreachableTextRanges(element: KtElement): List<TextRange> {
         return if (element.hasChildrenInSet(reachableElements)) {
             element.getLeavesOrReachableChildren().removeReachableElementsWithMeaninglessSiblings().mergeAdjacentTextRanges()
         }
@@ -49,15 +49,15 @@ class UnreachableCodeImpl(
         }
     }
 
-    private fun JetElement.hasChildrenInSet(set: Set<JetElement>): Boolean {
+    private fun KtElement.hasChildrenInSet(set: Set<KtElement>): Boolean {
         return PsiTreeUtil.collectElements(this) { it != this }.any { it in set }
     }
 
-    private fun JetElement.getLeavesOrReachableChildren(): List<PsiElement> {
+    private fun KtElement.getLeavesOrReachableChildren(): List<PsiElement> {
         val children = ArrayList<PsiElement>()
         acceptChildren(object : PsiElementVisitor() {
             override fun visitElement(element: PsiElement) {
-                val isReachable = element is JetElement && reachableElements.contains(element) && !element.hasChildrenInSet(unreachableElements)
+                val isReachable = element is KtElement && reachableElements.contains(element) && !element.hasChildrenInSet(unreachableElements)
                 if (isReachable || element.getChildren().size() == 0) {
                     children.add(element)
                 }
@@ -71,7 +71,7 @@ class UnreachableCodeImpl(
 
     fun List<PsiElement>.removeReachableElementsWithMeaninglessSiblings(): List<PsiElement> {
         fun PsiElement.isMeaningless() = this is PsiWhiteSpace
-                || this.getNode()?.getElementType() == JetTokens.COMMA
+                || this.getNode()?.getElementType() == KtTokens.COMMA
                 || this is PsiComment
 
         val childrenToRemove = HashSet<PsiElement>()
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/WhenChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/WhenChecker.java
index 99f536dbbce..9d3847d9500 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/WhenChecker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/WhenChecker.java
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.resolve.CompileTimeConstantUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilsKt;
 import org.jetbrains.kotlin.types.FlexibleTypesKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 
 import java.util.HashSet;
@@ -40,8 +40,8 @@ public final class WhenChecker {
     private WhenChecker() {
     }
 
-    public static boolean mustHaveElse(@NotNull JetWhenExpression expression, @NotNull BindingTrace trace) {
-        JetType expectedType = trace.get(BindingContext.EXPECTED_EXPRESSION_TYPE, expression);
+    public static boolean mustHaveElse(@NotNull KtWhenExpression expression, @NotNull BindingTrace trace) {
+        KtType expectedType = trace.get(BindingContext.EXPECTED_EXPRESSION_TYPE, expression);
         boolean isUnit = expectedType != null && KotlinBuiltIns.isUnit(expectedType);
         // Some "statements" are actually expressions returned from lambdas, their expected types are non-null
         boolean isStatement = BindingContextUtilsKt.isUsedAsStatement(expression, trace.getBindingContext()) && expectedType == null;
@@ -49,12 +49,12 @@ public final class WhenChecker {
         return !isUnit && !isStatement && !isWhenExhaustive(expression, trace);
     }
 
-    public static boolean isWhenByEnum(@NotNull JetWhenExpression expression, @NotNull BindingContext context) {
+    public static boolean isWhenByEnum(@NotNull KtWhenExpression expression, @NotNull BindingContext context) {
         return getClassDescriptorOfTypeIfEnum(whenSubjectType(expression, context)) != null;
     }
 
     @Nullable
-    public static ClassDescriptor getClassDescriptorOfTypeIfEnum(@Nullable JetType type) {
+    public static ClassDescriptor getClassDescriptorOfTypeIfEnum(@Nullable KtType type) {
         if (type == null) return null;
         ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(type);
         if (classDescriptor == null) return null;
@@ -64,19 +64,19 @@ public final class WhenChecker {
     }
 
     @Nullable
-    private static JetType whenSubjectType(@NotNull JetWhenExpression expression, @NotNull BindingContext context) {
-        JetExpression subjectExpression = expression.getSubjectExpression();
+    private static KtType whenSubjectType(@NotNull KtWhenExpression expression, @NotNull BindingContext context) {
+        KtExpression subjectExpression = expression.getSubjectExpression();
         return subjectExpression == null ? null : context.getType(subjectExpression);
     }
 
-    private static boolean isWhenOnBooleanExhaustive(@NotNull JetWhenExpression expression, @NotNull BindingTrace trace) {
+    private static boolean isWhenOnBooleanExhaustive(@NotNull KtWhenExpression expression, @NotNull BindingTrace trace) {
         // It's assumed (and not checked) that expression is of the boolean type
         boolean containsFalse = false;
         boolean containsTrue = false;
-        for (JetWhenEntry whenEntry: expression.getEntries()) {
-            for (JetWhenCondition whenCondition : whenEntry.getConditions()) {
-                if (whenCondition instanceof JetWhenConditionWithExpression) {
-                    JetExpression whenExpression = ((JetWhenConditionWithExpression) whenCondition).getExpression();
+        for (KtWhenEntry whenEntry: expression.getEntries()) {
+            for (KtWhenCondition whenCondition : whenEntry.getConditions()) {
+                if (whenCondition instanceof KtWhenConditionWithExpression) {
+                    KtExpression whenExpression = ((KtWhenConditionWithExpression) whenCondition).getExpression();
                     if (CompileTimeConstantUtils.canBeReducedToBooleanConstant(whenExpression, trace, true)) containsTrue = true;
                     if (CompileTimeConstantUtils.canBeReducedToBooleanConstant(whenExpression, trace, false)) containsFalse = true;
                 }
@@ -86,7 +86,7 @@ public final class WhenChecker {
     }
 
     public static boolean isWhenOnEnumExhaustive(
-            @NotNull JetWhenExpression expression,
+            @NotNull KtWhenExpression expression,
             @NotNull BindingTrace trace,
             @NotNull ClassDescriptor enumClassDescriptor
     ) {
@@ -118,7 +118,7 @@ public final class WhenChecker {
     }
 
     private static boolean isWhenOnSealedClassExhaustive(
-            @NotNull JetWhenExpression expression,
+            @NotNull KtWhenExpression expression,
             @NotNull BindingTrace trace,
             @NotNull ClassDescriptor classDescriptor
     ) {
@@ -135,8 +135,8 @@ public final class WhenChecker {
      * @return true if type is nullable, and cannot be smart casted
      */
     private static boolean isNullableTypeWithoutPossibleSmartCast(
-            @Nullable JetExpression expression,
-            @NotNull JetType type,
+            @Nullable KtExpression expression,
+            @NotNull KtType type,
             @NotNull BindingContext context
     ) {
         if (expression == null) return false; // Normally should not happen
@@ -151,8 +151,8 @@ public final class WhenChecker {
         return true;
     }
 
-    public static boolean isWhenExhaustive(@NotNull JetWhenExpression expression, @NotNull BindingTrace trace) {
-        JetType type = whenSubjectType(expression, trace.getBindingContext());
+    public static boolean isWhenExhaustive(@NotNull KtWhenExpression expression, @NotNull BindingTrace trace) {
+        KtType type = whenSubjectType(expression, trace.getBindingContext());
         if (type == null) return false;
         ClassDescriptor enumClassDescriptor = getClassDescriptorOfTypeIfEnum(type);
 
@@ -185,27 +185,27 @@ public final class WhenChecker {
     }
 
     private static boolean containsAllClassCases(
-            @NotNull JetWhenExpression whenExpression,
+            @NotNull KtWhenExpression whenExpression,
             @NotNull Set<ClassDescriptor> memberDescriptors,
             @NotNull BindingTrace trace
     ) {
         Set<ClassDescriptor> checkedDescriptors = new HashSet<ClassDescriptor>();
-        for (JetWhenEntry whenEntry : whenExpression.getEntries()) {
-            for (JetWhenCondition condition : whenEntry.getConditions()) {
+        for (KtWhenEntry whenEntry : whenExpression.getEntries()) {
+            for (KtWhenCondition condition : whenEntry.getConditions()) {
                 boolean negated = false;
                 ClassDescriptor checkedDescriptor = null;
-                if (condition instanceof JetWhenConditionIsPattern) {
-                    JetWhenConditionIsPattern conditionIsPattern = (JetWhenConditionIsPattern) condition;
-                    JetType checkedType = trace.get(BindingContext.TYPE, conditionIsPattern.getTypeReference());
+                if (condition instanceof KtWhenConditionIsPattern) {
+                    KtWhenConditionIsPattern conditionIsPattern = (KtWhenConditionIsPattern) condition;
+                    KtType checkedType = trace.get(BindingContext.TYPE, conditionIsPattern.getTypeReference());
                     if (checkedType != null) {
                         checkedDescriptor = TypeUtils.getClassDescriptor(checkedType);
                     }
                     negated = conditionIsPattern.isNegated();
                 }
-                else if (condition instanceof JetWhenConditionWithExpression) {
-                    JetWhenConditionWithExpression conditionWithExpression = (JetWhenConditionWithExpression) condition;
+                else if (condition instanceof KtWhenConditionWithExpression) {
+                    KtWhenConditionWithExpression conditionWithExpression = (KtWhenConditionWithExpression) condition;
                     if (conditionWithExpression.getExpression() != null) {
-                        JetSimpleNameExpression reference = getReference(conditionWithExpression.getExpression());
+                        KtSimpleNameExpression reference = getReference(conditionWithExpression.getExpression());
                         if (reference != null) {
                             DeclarationDescriptor target = trace.get(BindingContext.REFERENCE_TARGET, reference);
                             if (target instanceof ClassDescriptor) {
@@ -219,7 +219,7 @@ public final class WhenChecker {
                 // In additional, check without "is" is important only for objects
                 if (checkedDescriptor == null
                     || !memberDescriptors.contains(checkedDescriptor)
-                    || (condition instanceof JetWhenConditionWithExpression
+                    || (condition instanceof KtWhenConditionWithExpression
                         && !DescriptorUtils.isObject(checkedDescriptor)
                         && !DescriptorUtils.isEnumEntry(checkedDescriptor))) {
                     continue;
@@ -237,13 +237,13 @@ public final class WhenChecker {
         return checkedDescriptors.containsAll(memberDescriptors);
     }
 
-    public static boolean containsNullCase(@NotNull JetWhenExpression expression, @NotNull BindingTrace trace) {
-        for (JetWhenEntry entry : expression.getEntries()) {
-            for (JetWhenCondition condition : entry.getConditions()) {
-                if (condition instanceof JetWhenConditionWithExpression) {
-                    JetWhenConditionWithExpression conditionWithExpression = (JetWhenConditionWithExpression) condition;
+    public static boolean containsNullCase(@NotNull KtWhenExpression expression, @NotNull BindingTrace trace) {
+        for (KtWhenEntry entry : expression.getEntries()) {
+            for (KtWhenCondition condition : entry.getConditions()) {
+                if (condition instanceof KtWhenConditionWithExpression) {
+                    KtWhenConditionWithExpression conditionWithExpression = (KtWhenConditionWithExpression) condition;
                     if (conditionWithExpression.getExpression() != null) {
-                        JetType type = trace.getBindingContext().getType(conditionWithExpression.getExpression());
+                        KtType type = trace.getBindingContext().getType(conditionWithExpression.getExpression());
                         if (type != null && KotlinBuiltIns.isNothingOrNullableNothing(type)) {
                             return true;
                         }
@@ -255,15 +255,15 @@ public final class WhenChecker {
     }
 
     @Nullable
-    private static JetSimpleNameExpression getReference(@Nullable JetExpression expression) {
+    private static KtSimpleNameExpression getReference(@Nullable KtExpression expression) {
         if (expression == null) {
             return null;
         }
-        if (expression instanceof JetSimpleNameExpression) {
-            return (JetSimpleNameExpression) expression;
+        if (expression instanceof KtSimpleNameExpression) {
+            return (KtSimpleNameExpression) expression;
         }
-        if (expression instanceof JetQualifiedExpression) {
-            return getReference(((JetQualifiedExpression) expression).getSelectorExpression());
+        if (expression instanceof KtQualifiedExpression) {
+            return getReference(((KtQualifiedExpression) expression).getSelectorExpression());
         }
         return null;
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/JetControlFlowInstructionsGenerator.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/JetControlFlowInstructionsGenerator.java
index c4c87faaa32..c51115db25f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/JetControlFlowInstructionsGenerator.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/JetControlFlowInstructionsGenerator.java
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.*;
 
@@ -40,7 +40,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
 
     private final Stack<LoopInfo> loopInfo = new Stack<LoopInfo>();
     private final Stack<LexicalScope> lexicalScopes = new Stack<LexicalScope>();
-    private final Map<JetElement, BreakableBlockInfo> elementToBlockInfo = new HashMap<JetElement, BreakableBlockInfo>();
+    private final Map<KtElement, BreakableBlockInfo> elementToBlockInfo = new HashMap<KtElement, BreakableBlockInfo>();
     private int labelCount = 0;
 
     private final Stack<JetControlFlowInstructionsGeneratorWorker> builders = new Stack<JetControlFlowInstructionsGeneratorWorker>();
@@ -53,13 +53,13 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         return builder;
     }
 
-    private void pushBuilder(JetElement scopingElement, JetElement subroutine) {
+    private void pushBuilder(KtElement scopingElement, KtElement subroutine) {
         JetControlFlowInstructionsGeneratorWorker worker = new JetControlFlowInstructionsGeneratorWorker(scopingElement, subroutine);
         builders.push(worker);
         builder = worker;
     }
 
-    private JetControlFlowInstructionsGeneratorWorker popBuilder(@NotNull JetElement element) {
+    private JetControlFlowInstructionsGeneratorWorker popBuilder(@NotNull KtElement element) {
         JetControlFlowInstructionsGeneratorWorker worker = builders.pop();
         if (!builders.isEmpty()) {
             builder = builders.peek();
@@ -71,8 +71,8 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
     }
 
     @Override
-    public void enterSubroutine(@NotNull JetElement subroutine) {
-        if (builder != null && subroutine instanceof JetFunctionLiteral) {
+    public void enterSubroutine(@NotNull KtElement subroutine) {
+        if (builder != null && subroutine instanceof KtFunctionLiteral) {
             pushBuilder(subroutine, builder.getReturnSubroutine());
         }
         else {
@@ -85,7 +85,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
 
     @NotNull
     @Override
-    public Pseudocode exitSubroutine(@NotNull JetElement subroutine) {
+    public Pseudocode exitSubroutine(@NotNull KtElement subroutine) {
         super.exitSubroutine(subroutine);
         builder.exitLexicalScope(subroutine);
         JetControlFlowInstructionsGeneratorWorker worker = popBuilder(subroutine);
@@ -101,12 +101,12 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         private final PseudocodeImpl pseudocode;
         private final Label error;
         private final Label sink;
-        private final JetElement returnSubroutine;
+        private final KtElement returnSubroutine;
 
         private final PseudoValueFactory valueFactory = new PseudoValueFactoryImpl() {
             @NotNull
             @Override
-            public PseudoValue newValue(@Nullable JetElement element, @Nullable InstructionWithValue instruction) {
+            public PseudoValue newValue(@Nullable KtElement element, @Nullable InstructionWithValue instruction) {
                 PseudoValue value = super.newValue(element, instruction);
                 if (element != null) {
                     bindValue(value, element);
@@ -115,7 +115,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
             }
         };
 
-        private JetControlFlowInstructionsGeneratorWorker(@NotNull JetElement scopingElement, @NotNull JetElement returnSubroutine) {
+        private JetControlFlowInstructionsGeneratorWorker(@NotNull KtElement scopingElement, @NotNull KtElement returnSubroutine) {
             this.pseudocode = new PseudocodeImpl(scopingElement);
             this.error = pseudocode.createLabel("error", null);
             this.sink = pseudocode.createLabel("sink", null);
@@ -144,7 +144,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
 
         @NotNull
         @Override
-        public final LoopInfo enterLoop(@NotNull JetLoopExpression expression) {
+        public final LoopInfo enterLoop(@NotNull KtLoopExpression expression) {
             LoopInfo info = new LoopInfo(
                     expression,
                     createUnboundLabel("loop entry point"),
@@ -158,7 +158,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         }
 
         @Override
-        public void enterLoopBody(@NotNull JetLoopExpression expression) {
+        public void enterLoopBody(@NotNull KtLoopExpression expression) {
             LoopInfo info = (LoopInfo) elementToBlockInfo.get(expression);
             bindLabel(info.getBodyEntryPoint());
             loopInfo.push(info);
@@ -166,7 +166,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         }
 
         @Override
-        public final void exitLoopBody(@NotNull JetLoopExpression expression) {
+        public final void exitLoopBody(@NotNull KtLoopExpression expression) {
             LoopInfo info = loopInfo.pop();
             elementToBlockInfo.remove(expression);
             allBlocks.pop();
@@ -174,12 +174,12 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         }
 
         @Override
-        public JetLoopExpression getCurrentLoop() {
+        public KtLoopExpression getCurrentLoop() {
             return loopInfo.empty() ? null : loopInfo.peek().getElement();
         }
 
         @Override
-        public void enterSubroutine(@NotNull JetElement subroutine) {
+        public void enterSubroutine(@NotNull KtElement subroutine) {
             BreakableBlockInfo blockInfo = new BreakableBlockInfo(
                     subroutine,
                     /* entry point */ createUnboundLabel(),
@@ -192,24 +192,24 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
 
         @NotNull
         @Override
-        public JetElement getCurrentSubroutine() {
+        public KtElement getCurrentSubroutine() {
             return pseudocode.getCorrespondingElement();
         }
 
         @Override
-        public JetElement getReturnSubroutine() {
+        public KtElement getReturnSubroutine() {
             return returnSubroutine;// subroutineInfo.empty() ? null : subroutineInfo.peek().getElement();
         }
 
         @NotNull
         @Override
-        public Label getEntryPoint(@NotNull JetElement labelElement) {
+        public Label getEntryPoint(@NotNull KtElement labelElement) {
             return elementToBlockInfo.get(labelElement).getEntryPoint();
         }
 
         @NotNull
         @Override
-        public Label getConditionEntryPoint(@NotNull JetElement labelElement) {
+        public Label getConditionEntryPoint(@NotNull KtElement labelElement) {
             BreakableBlockInfo blockInfo = elementToBlockInfo.get(labelElement);
             assert blockInfo instanceof LoopInfo : "expected LoopInfo for " + labelElement.getText() ;
             return ((LoopInfo)blockInfo).getConditionEntryPoint();
@@ -217,7 +217,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
 
         @NotNull
         @Override
-        public Label getExitPoint(@NotNull JetElement labelElement) {
+        public Label getExitPoint(@NotNull KtElement labelElement) {
             BreakableBlockInfo blockInfo = elementToBlockInfo.get(labelElement);
             assert blockInfo != null : labelElement.getText();
             return blockInfo.getExitPoint();
@@ -229,14 +229,14 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         }
 
         @Override
-        public void enterLexicalScope(@NotNull JetElement element) {
+        public void enterLexicalScope(@NotNull KtElement element) {
             LexicalScope current = lexicalScopes.isEmpty() ? null : getCurrentScope();
             LexicalScope scope = new LexicalScope(current, element);
             lexicalScopes.push(scope);
         }
 
         @Override
-        public void exitLexicalScope(@NotNull JetElement element) {
+        public void exitLexicalScope(@NotNull KtElement element) {
             LexicalScope currentScope = getCurrentScope();
             assert currentScope.getElement() == element : "Exit from not the current lexical scope.\n" +
                     "Current scope is for: " + currentScope.getElement() + ".\n" +
@@ -269,7 +269,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
 
         @NotNull
         @Override
-        public Pseudocode exitSubroutine(@NotNull JetElement subroutine) {
+        public Pseudocode exitSubroutine(@NotNull KtElement subroutine) {
             bindLabel(getExitPoint(subroutine));
             pseudocode.addExitInstruction(new SubroutineExitInstruction(subroutine, getCurrentScope(), false));
             bindLabel(error);
@@ -282,36 +282,36 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         }
 
         @Override
-        public void mark(@NotNull JetElement element) {
+        public void mark(@NotNull KtElement element) {
             add(new MarkInstruction(element, getCurrentScope()));
         }
 
         @Nullable
         @Override
-        public PseudoValue getBoundValue(@Nullable JetElement element) {
+        public PseudoValue getBoundValue(@Nullable KtElement element) {
             return pseudocode.getElementValue(element);
         }
 
         @Override
-        public void bindValue(@NotNull PseudoValue value, @NotNull JetElement element) {
+        public void bindValue(@NotNull PseudoValue value, @NotNull KtElement element) {
             pseudocode.bindElementToValue(element, value);
         }
 
         @NotNull
         @Override
-        public PseudoValue newValue(@Nullable JetElement element) {
+        public PseudoValue newValue(@Nullable KtElement element) {
             return valueFactory.newValue(element, null);
         }
 
         @Override
-        public void returnValue(@NotNull JetExpression returnExpression, @NotNull PseudoValue returnValue, @NotNull JetElement subroutine) {
+        public void returnValue(@NotNull KtExpression returnExpression, @NotNull PseudoValue returnValue, @NotNull KtElement subroutine) {
             Label exitPoint = getExitPoint(subroutine);
             handleJumpInsideTryFinally(exitPoint);
             add(new ReturnValueInstruction(returnExpression, getCurrentScope(), exitPoint, returnValue));
         }
 
         @Override
-        public void returnNoValue(@NotNull JetReturnExpression returnExpression, @NotNull JetElement subroutine) {
+        public void returnNoValue(@NotNull KtReturnExpression returnExpression, @NotNull KtElement subroutine) {
             Label exitPoint = getExitPoint(subroutine);
             handleJumpInsideTryFinally(exitPoint);
             add(new ReturnNoValueInstruction(returnExpression, getCurrentScope(), exitPoint));
@@ -319,8 +319,8 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
 
         @Override
         public void write(
-                @NotNull JetElement assignment,
-                @NotNull JetElement lValue,
+                @NotNull KtElement assignment,
+                @NotNull KtElement lValue,
                 @NotNull PseudoValue rValue,
                 @NotNull AccessTarget target,
                 @NotNull Map<PseudoValue, ReceiverValue> receiverValues) {
@@ -328,39 +328,39 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         }
 
         @Override
-        public void declareParameter(@NotNull JetParameter parameter) {
+        public void declareParameter(@NotNull KtParameter parameter) {
             add(new VariableDeclarationInstruction(parameter, getCurrentScope()));
         }
 
         @Override
-        public void declareVariable(@NotNull JetVariableDeclaration property) {
+        public void declareVariable(@NotNull KtVariableDeclaration property) {
             add(new VariableDeclarationInstruction(property, getCurrentScope()));
         }
 
         @Override
-        public void declareFunction(@NotNull JetElement subroutine, @NotNull Pseudocode pseudocode) {
+        public void declareFunction(@NotNull KtElement subroutine, @NotNull Pseudocode pseudocode) {
             add(new LocalFunctionDeclarationInstruction(subroutine, pseudocode, getCurrentScope()));
         }
 
         @Override
-        public void loadUnit(@NotNull JetExpression expression) {
+        public void loadUnit(@NotNull KtExpression expression) {
             add(new LoadUnitValueInstruction(expression, getCurrentScope()));
         }
 
         @Override
-        public void jump(@NotNull Label label, @NotNull JetElement element) {
+        public void jump(@NotNull Label label, @NotNull KtElement element) {
             handleJumpInsideTryFinally(label);
             add(new UnconditionalJumpInstruction(element, label, getCurrentScope()));
         }
 
         @Override
-        public void jumpOnFalse(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue conditionValue) {
+        public void jumpOnFalse(@NotNull Label label, @NotNull KtElement element, @Nullable PseudoValue conditionValue) {
             handleJumpInsideTryFinally(label);
             add(new ConditionalJumpInstruction(element, false, getCurrentScope(), label, conditionValue));
         }
 
         @Override
-        public void jumpOnTrue(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue conditionValue) {
+        public void jumpOnTrue(@NotNull Label label, @NotNull KtElement element, @Nullable PseudoValue conditionValue) {
             handleJumpInsideTryFinally(label);
             add(new ConditionalJumpInstruction(element, true, getCurrentScope(), label, conditionValue));
         }
@@ -371,20 +371,20 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         }
 
         @Override
-        public void nondeterministicJump(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue inputValue) {
+        public void nondeterministicJump(@NotNull Label label, @NotNull KtElement element, @Nullable PseudoValue inputValue) {
             handleJumpInsideTryFinally(label);
             add(new NondeterministicJumpInstruction(element, Collections.singletonList(label), getCurrentScope(), inputValue));
         }
 
         @Override
-        public void nondeterministicJump(@NotNull List<Label> labels, @NotNull JetElement element) {
+        public void nondeterministicJump(@NotNull List<Label> labels, @NotNull KtElement element) {
             //todo
             //handleJumpInsideTryFinally(label);
             add(new NondeterministicJumpInstruction(element, labels, getCurrentScope(), null));
         }
 
         @Override
-        public void jumpToError(@NotNull JetElement element) {
+        public void jumpToError(@NotNull KtElement element) {
             handleJumpInsideTryFinally(error);
             add(new UnconditionalJumpInstruction(element, error, getCurrentScope()));
         }
@@ -395,7 +395,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         }
 
         @Override
-        public void throwException(@NotNull JetThrowExpression expression, @NotNull PseudoValue thrownValue) {
+        public void throwException(@NotNull KtThrowExpression expression, @NotNull PseudoValue thrownValue) {
             handleJumpInsideTryFinally(error);
             add(new ThrowExceptionInstruction(expression, getCurrentScope(), error, thrownValue));
         }
@@ -413,33 +413,33 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
 
         @NotNull
         @Override
-        public InstructionWithValue loadConstant(@NotNull JetExpression expression, @Nullable CompileTimeConstant<?> constant) {
+        public InstructionWithValue loadConstant(@NotNull KtExpression expression, @Nullable CompileTimeConstant<?> constant) {
             return read(expression);
         }
 
         @NotNull
         @Override
-        public InstructionWithValue createAnonymousObject(@NotNull JetObjectLiteralExpression expression) {
+        public InstructionWithValue createAnonymousObject(@NotNull KtObjectLiteralExpression expression) {
             return read(expression);
         }
 
         @NotNull
         @Override
-        public InstructionWithValue createLambda(@NotNull JetFunction expression) {
-            return read(expression instanceof JetFunctionLiteral ? (JetFunctionLiteralExpression) expression.getParent() : expression);
+        public InstructionWithValue createLambda(@NotNull KtFunction expression) {
+            return read(expression instanceof KtFunctionLiteral ? (KtFunctionLiteralExpression) expression.getParent() : expression);
         }
 
         @NotNull
         @Override
-        public InstructionWithValue loadStringTemplate(@NotNull JetStringTemplateExpression expression, @NotNull List<PseudoValue> inputValues) {
+        public InstructionWithValue loadStringTemplate(@NotNull KtStringTemplateExpression expression, @NotNull List<PseudoValue> inputValues) {
             return inputValues.isEmpty() ? read(expression) : magic(expression, expression, inputValues, MagicKind.STRING_TEMPLATE);
         }
 
         @NotNull
         @Override
         public MagicInstruction magic(
-                @NotNull JetElement instructionElement,
-                @Nullable JetElement valueElement,
+                @NotNull KtElement instructionElement,
+                @Nullable KtElement valueElement,
                 @NotNull List<PseudoValue> inputValues,
                 @NotNull MagicKind kind
         ) {
@@ -452,7 +452,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
 
         @NotNull
         @Override
-        public MergeInstruction merge(@NotNull JetExpression expression, @NotNull List<PseudoValue> inputValues) {
+        public MergeInstruction merge(@NotNull KtExpression expression, @NotNull List<PseudoValue> inputValues) {
             MergeInstruction instruction = new MergeInstruction(expression, getCurrentScope(), inputValues, valueFactory);
             add(instruction);
             return instruction;
@@ -461,7 +461,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         @NotNull
         @Override
         public ReadValueInstruction readVariable(
-                @NotNull JetExpression expression,
+                @NotNull KtExpression expression,
                 @NotNull ResolvedCall<?> resolvedCall,
                 @NotNull Map<PseudoValue, ReceiverValue> receiverValues
         ) {
@@ -471,12 +471,12 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         @NotNull
         @Override
         public CallInstruction call(
-                @NotNull JetElement valueElement,
+                @NotNull KtElement valueElement,
                 @NotNull ResolvedCall<?> resolvedCall,
                 @NotNull Map<PseudoValue, ReceiverValue> receiverValues,
                 @NotNull Map<PseudoValue, ValueParameterDescriptor> arguments
         ) {
-            JetType returnType = resolvedCall.getResultingDescriptor().getReturnType();
+            KtType returnType = resolvedCall.getResultingDescriptor().getReturnType();
             CallInstruction instruction = new CallInstruction(
                     valueElement,
                     getCurrentScope(),
@@ -492,7 +492,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         @NotNull
         @Override
         public OperationInstruction predefinedOperation(
-                @NotNull JetExpression expression,
+                @NotNull KtExpression expression,
                 @NotNull PredefinedOperation operation,
                 @NotNull List<PseudoValue> inputValues
         ) {
@@ -515,7 +515,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
 
         @NotNull
         private ReadValueInstruction read(
-                @NotNull JetExpression expression,
+                @NotNull KtExpression expression,
                 @Nullable ResolvedCall<?> resolvedCall,
                 @NotNull Map<PseudoValue, ReceiverValue> receiverValues
         ) {
@@ -528,7 +528,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         }
 
         @NotNull
-        private ReadValueInstruction read(@NotNull JetExpression expression) {
+        private ReadValueInstruction read(@NotNull KtExpression expression) {
             return read(expression, null, Collections.<PseudoValue, ReceiverValue>emptyMap());
         }
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudoValue.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudoValue.kt
index 908bbfa0cde..2b1fc1d591d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudoValue.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudoValue.kt
@@ -16,15 +16,15 @@
 
 package org.jetbrains.kotlin.cfg.pseudocode
 
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.InstructionWithValue
 
 public interface PseudoValue {
     public val debugName: String
-    public val element: JetElement?
+    public val element: KtElement?
     public val createdAt: InstructionWithValue?
 }
 
 public interface PseudoValueFactory {
-    public fun newValue(element: JetElement?, instruction: InstructionWithValue?): PseudoValue
+    public fun newValue(element: KtElement?, instruction: InstructionWithValue?): PseudoValue
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudoValueImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudoValueImpl.kt
index a5e9d8c43ed..6b095cf3292 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudoValueImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudoValueImpl.kt
@@ -16,12 +16,12 @@
 
 package org.jetbrains.kotlin.cfg.pseudocode
 
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.InstructionWithValue
 
 class PseudoValueImpl(
         override val debugName: String,
-        override val element: JetElement?,
+        override val element: KtElement?,
         override val createdAt: InstructionWithValue?
 ) : PseudoValue {
     override fun toString(): String = debugName
@@ -30,7 +30,7 @@ class PseudoValueImpl(
 open class PseudoValueFactoryImpl: PseudoValueFactory {
     private var lastIndex: Int = 0
 
-    override fun newValue(element: JetElement?, instruction: InstructionWithValue?): PseudoValue {
+    override fun newValue(element: KtElement?, instruction: InstructionWithValue?): PseudoValue {
         return PseudoValueImpl((instruction?.let { "" } ?: "!") + "<v${lastIndex++}>", element, instruction)
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/Pseudocode.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/Pseudocode.java
index b4366d9eeb0..fb206a7b945 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/Pseudocode.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/Pseudocode.java
@@ -23,14 +23,14 @@ 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.KtElement;
 
 import java.util.List;
 import java.util.Set;
 
 public interface Pseudocode {
     @NotNull
-    JetElement getCorrespondingElement();
+    KtElement getCorrespondingElement();
 
     @Nullable
     Pseudocode getParent();
@@ -57,10 +57,10 @@ public interface Pseudocode {
     SubroutineEnterInstruction getEnterInstruction();
 
     @Nullable
-    PseudoValue getElementValue(@Nullable JetElement element);
+    PseudoValue getElementValue(@Nullable KtElement element);
 
     @NotNull
-    List<? extends JetElement> getValueElements(@Nullable PseudoValue value);
+    List<? extends KtElement> getValueElements(@Nullable PseudoValue value);
 
     @NotNull
     List<? extends Instruction> getUsages(@Nullable PseudoValue value);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudocodeImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudocodeImpl.java
index 7b8c3538c88..533507e75aa 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudocodeImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudocodeImpl.java
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.SubroutineEnterI
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.SubroutineExitInstruction;
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.SubroutineSinkInstruction;
 import org.jetbrains.kotlin.cfg.pseudocodeTraverser.PseudocodeTraverserKt;
-import org.jetbrains.kotlin.psi.JetElement;
+import org.jetbrains.kotlin.psi.KtElement;
 
 import java.util.*;
 
@@ -95,7 +95,7 @@ public class PseudocodeImpl implements Pseudocode {
     private final List<Instruction> mutableInstructionList = new ArrayList<Instruction>();
     private final List<Instruction> instructions = new ArrayList<Instruction>();
 
-    private final BidirectionalMap<JetElement, PseudoValue> elementsToValues = new BidirectionalMap<JetElement, PseudoValue>();
+    private final BidirectionalMap<KtElement, PseudoValue> elementsToValues = new BidirectionalMap<KtElement, PseudoValue>();
 
     private final Map<PseudoValue, List<Instruction>> valueUsages = Maps.newHashMap();
     private final Map<PseudoValue, Set<PseudoValue>> mergedValues = Maps.newHashMap();
@@ -104,23 +104,23 @@ public class PseudocodeImpl implements Pseudocode {
     private Pseudocode parent = null;
     private Set<LocalFunctionDeclarationInstruction> localDeclarations = null;
     //todo getters
-    private final Map<JetElement, Instruction> representativeInstructions = new HashMap<JetElement, Instruction>();
+    private final Map<KtElement, Instruction> representativeInstructions = new HashMap<KtElement, Instruction>();
 
     private final List<PseudocodeLabel> labels = new ArrayList<PseudocodeLabel>();
 
-    private final JetElement correspondingElement;
+    private final KtElement correspondingElement;
     private SubroutineExitInstruction exitInstruction;
     private SubroutineSinkInstruction sinkInstruction;
     private SubroutineExitInstruction errorInstruction;
     private boolean postPrecessed = false;
 
-    public PseudocodeImpl(JetElement correspondingElement) {
+    public PseudocodeImpl(KtElement correspondingElement) {
         this.correspondingElement = correspondingElement;
     }
 
     @NotNull
     @Override
-    public JetElement getCorrespondingElement() {
+    public KtElement getCorrespondingElement() {
         return correspondingElement;
     }
 
@@ -268,15 +268,15 @@ public class PseudocodeImpl implements Pseudocode {
 
     @Nullable
     @Override
-    public PseudoValue getElementValue(@Nullable JetElement element) {
+    public PseudoValue getElementValue(@Nullable KtElement element) {
         return elementsToValues.get(element);
     }
 
     @NotNull
     @Override
-    public List<? extends JetElement> getValueElements(@Nullable PseudoValue value) {
-        List<? extends JetElement> result = elementsToValues.getKeysByValue(value);
-        return result != null ? result : Collections.<JetElement>emptyList();
+    public List<? extends KtElement> getValueElements(@Nullable PseudoValue value) {
+        List<? extends KtElement> result = elementsToValues.getKeysByValue(value);
+        return result != null ? result : Collections.<KtElement>emptyList();
     }
 
     @NotNull
@@ -291,7 +291,7 @@ public class PseudocodeImpl implements Pseudocode {
         return sideEffectFree.contains(instruction);
     }
 
-    /*package*/ void bindElementToValue(@NotNull JetElement element, @NotNull PseudoValue value) {
+    /*package*/ void bindElementToValue(@NotNull KtElement element, @NotNull PseudoValue value) {
         elementsToValues.put(element, value);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudocodeUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudocodeUtil.java
index 134d90039bc..d3c64603ab1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudocodeUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudocodeUtil.java
@@ -27,15 +27,15 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.WriteValueInstructi
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.VariableDeclarationInstruction;
 import org.jetbrains.kotlin.descriptors.VariableDescriptor;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
-import org.jetbrains.kotlin.psi.JetDeclaration;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtElement;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.resolvedCallUtil.ResolvedCallUtilKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice;
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
 
@@ -43,7 +43,7 @@ import java.util.Collection;
 
 public class PseudocodeUtil {
     @NotNull
-    public static Pseudocode generatePseudocode(@NotNull JetDeclaration declaration, @NotNull final BindingContext bindingContext) {
+    public static Pseudocode generatePseudocode(@NotNull KtDeclaration declaration, @NotNull final BindingContext bindingContext) {
         BindingTrace mockTrace = new BindingTrace() {
             @NotNull
             @Override
@@ -72,12 +72,12 @@ public class PseudocodeUtil {
 
             @Nullable
             @Override
-            public JetType getType(@NotNull JetExpression expression) {
+            public KtType getType(@NotNull KtExpression expression) {
                 return bindingContext.getType(expression);
             }
 
             @Override
-            public void recordType(@NotNull JetExpression expression, @Nullable JetType type) {
+            public void recordType(@NotNull KtExpression expression, @Nullable KtType type) {
             }
 
             @Override
@@ -89,7 +89,7 @@ public class PseudocodeUtil {
 
     @Nullable
     public static VariableDescriptor extractVariableDescriptorIfAny(@NotNull Instruction instruction, boolean onlyReference, @NotNull BindingContext bindingContext) {
-        JetElement element = null;
+        KtElement element = null;
         if (instruction instanceof ReadValueInstruction) {
             element = ((ReadValueInstruction) instruction).getElement();
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/TypePredicate.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/TypePredicate.kt
index 5448e91650f..29d231b3b0a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/TypePredicate.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/TypePredicate.kt
@@ -19,39 +19,39 @@ package org.jetbrains.kotlin.cfg.pseudocode
 import com.intellij.util.SmartFMap
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 
-public interface TypePredicate: (JetType) -> Boolean {
-    override fun invoke(typeToCheck: JetType): Boolean
+public interface TypePredicate: (KtType) -> Boolean {
+    override fun invoke(typeToCheck: KtType): Boolean
 }
 
-public data class SingleType(val targetType: JetType): TypePredicate {
-    override fun invoke(typeToCheck: JetType): Boolean = JetTypeChecker.DEFAULT.equalTypes(typeToCheck, targetType)
+public data class SingleType(val targetType: KtType): TypePredicate {
+    override fun invoke(typeToCheck: KtType): Boolean = KotlinTypeChecker.DEFAULT.equalTypes(typeToCheck, targetType)
     override fun toString(): String = targetType.render()
 }
 
-public data class AllSubtypes(val upperBound: JetType): TypePredicate {
-    override fun invoke(typeToCheck: JetType): Boolean = JetTypeChecker.DEFAULT.isSubtypeOf(typeToCheck, upperBound)
+public data class AllSubtypes(val upperBound: KtType): TypePredicate {
+    override fun invoke(typeToCheck: KtType): Boolean = KotlinTypeChecker.DEFAULT.isSubtypeOf(typeToCheck, upperBound)
 
     override fun toString(): String = "{<: ${upperBound.render()}}"
 }
 
 public data class ForAllTypes(val typeSets: List<TypePredicate>): TypePredicate {
-    override fun invoke(typeToCheck: JetType): Boolean = typeSets.all { it(typeToCheck) }
+    override fun invoke(typeToCheck: KtType): Boolean = typeSets.all { it(typeToCheck) }
 
     override fun toString(): String = "AND{${typeSets.joinToString(", ")}}"
 }
 
 public data class ForSomeType(val typeSets: List<TypePredicate>): TypePredicate {
-    override fun invoke(typeToCheck: JetType): Boolean = typeSets.any { it(typeToCheck) }
+    override fun invoke(typeToCheck: KtType): Boolean = typeSets.any { it(typeToCheck) }
 
     override fun toString(): String = "OR{${typeSets.joinToString(", ")}}"
 }
 
 public object AllTypes : TypePredicate {
-    override fun invoke(typeToCheck: JetType): Boolean = true
+    override fun invoke(typeToCheck: KtType): Boolean = true
 
     override fun toString(): String = "*"
 }
@@ -71,16 +71,16 @@ public fun or(predicates: Collection<TypePredicate>): TypePredicate? =
             else -> ForSomeType(predicates.toList())
         }
 
-fun JetType.getSubtypesPredicate(): TypePredicate {
+fun KtType.getSubtypesPredicate(): TypePredicate {
     return when {
         KotlinBuiltIns.isAnyOrNullableAny(this) && isMarkedNullable() -> AllTypes
-        TypeUtils.canHaveSubtypes(JetTypeChecker.DEFAULT, this) -> AllSubtypes(this)
+        TypeUtils.canHaveSubtypes(KotlinTypeChecker.DEFAULT, this) -> AllSubtypes(this)
         else -> SingleType(this)
     }
 }
 
 
-private fun JetType.render(): String = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(this)
+private fun KtType.render(): String = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(this)
 
 public fun <T> TypePredicate.expectedTypeFor(keys: Iterable<T>): Map<T, TypePredicate> =
         keys.fold(SmartFMap.emptyMap<T, TypePredicate>()) { map, key -> map.plus(key, this) }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/InstructionWithNext.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/InstructionWithNext.kt
index 5480d4cd95f..c3c3999ba61 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/InstructionWithNext.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/InstructionWithNext.kt
@@ -16,11 +16,11 @@
 
 package org.jetbrains.kotlin.cfg.pseudocode.instructions
 
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.utils.emptyOrSingletonList
 
 public abstract class InstructionWithNext(
-        element: JetElement,
+        element: KtElement,
         lexicalScope: LexicalScope
 ) : JetElementInstructionImpl(element, lexicalScope) {
     public var next: Instruction? = null
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/JetElementInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/JetElementInstruction.kt
index 6e0e14d10d3..1554a13e3ef 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/JetElementInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/JetElementInstruction.kt
@@ -16,8 +16,8 @@
 
 package org.jetbrains.kotlin.cfg.pseudocode.instructions
 
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 
 public interface JetElementInstruction : Instruction {
-    public val element: JetElement
+    public val element: KtElement
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/JetElementInstructionImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/JetElementInstructionImpl.kt
index 2761eb7a2d7..79bb47797e3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/JetElementInstructionImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/JetElementInstructionImpl.kt
@@ -17,10 +17,10 @@
 package org.jetbrains.kotlin.cfg.pseudocode.instructions
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 
 public abstract class JetElementInstructionImpl(
-        override val element: JetElement,
+        override val element: KtElement,
         lexicalScope: LexicalScope
 ) : InstructionImpl(lexicalScope), JetElementInstruction {
     protected fun render(element: PsiElement): String =
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/LexicalScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/LexicalScope.kt
index 727d1eee166..086bca9b715 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/LexicalScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/LexicalScope.kt
@@ -16,10 +16,10 @@
 
 package org.jetbrains.kotlin.cfg.pseudocode.instructions
 
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtElement
 
-public class LexicalScope(val parentScope: LexicalScope?, val element: JetElement) {
+public class LexicalScope(val parentScope: LexicalScope?, val element: KtElement) {
     //todo remove after KT-4126
     private val d = (parentScope?.depth ?: 0) + 1
     val depth: Int get() = d
@@ -27,7 +27,7 @@ public class LexicalScope(val parentScope: LexicalScope?, val element: JetElemen
     val lexicalScopeForContainingDeclaration: LexicalScope? by lazy {
         var scope: LexicalScope? = this
         while (scope != null) {
-            if (scope.element is JetDeclaration) {
+            if (scope.element is KtDeclaration) {
                 return@lazy scope
             }
             scope = scope.parentScope
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/LoadUnitValueInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/LoadUnitValueInstruction.kt
index 6b125c57705..3991db4a618 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/LoadUnitValueInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/LoadUnitValueInstruction.kt
@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.cfg.pseudocode.instructions.eval
 
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionWithNext
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitor
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.LexicalScope
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionImpl
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitorWithResult
 
 public class LoadUnitValueInstruction(
-        expression: JetExpression,
+        expression: KtExpression,
         lexicalScope: LexicalScope
 ) : InstructionWithNext(expression, lexicalScope) {
     override fun accept(visitor: InstructionVisitor) {
@@ -39,5 +39,5 @@ public class LoadUnitValueInstruction(
             "read (Unit)"
 
     override fun createCopy(): InstructionImpl =
-            LoadUnitValueInstruction(element as JetExpression, lexicalScope)
+            LoadUnitValueInstruction(element as KtExpression, lexicalScope)
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/accessInstructions.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/accessInstructions.kt
index 5a3cb9ceb0e..7c3f0ecb9db 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/accessInstructions.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/accessInstructions.kt
@@ -20,8 +20,8 @@ import org.jetbrains.kotlin.cfg.pseudocode.PseudoValue
 import org.jetbrains.kotlin.cfg.pseudocode.PseudoValueFactory
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.*
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
-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.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 
@@ -40,21 +40,21 @@ public sealed class AccessTarget {
 }
 
 public abstract class AccessValueInstruction protected constructor(
-        element: JetElement,
+        element: KtElement,
         lexicalScope: LexicalScope,
         public val target: AccessTarget,
         override val receiverValues: Map<PseudoValue, ReceiverValue>
 ) : InstructionWithNext(element, lexicalScope), InstructionWithReceivers
 
 public class ReadValueInstruction private constructor(
-        element: JetElement,
+        element: KtElement,
         lexicalScope: LexicalScope,
         target: AccessTarget,
         receiverValues: Map<PseudoValue, ReceiverValue>,
         private var _outputValue: PseudoValue?
 ) : AccessValueInstruction(element, lexicalScope, target, receiverValues), InstructionWithValue {
     public constructor(
-            element: JetElement,
+            element: KtElement,
             lexicalScope: LexicalScope,
             target: AccessTarget,
             receiverValues: Map<PseudoValue, ReceiverValue>,
@@ -95,11 +95,11 @@ public class ReadValueInstruction private constructor(
 }
 
 public class WriteValueInstruction(
-        assignment: JetElement,
+        assignment: KtElement,
         lexicalScope: LexicalScope,
         target: AccessTarget,
         receiverValues: Map<PseudoValue, ReceiverValue>,
-        public val lValue: JetElement,
+        public val lValue: KtElement,
         public val rValue: PseudoValue
 ) : AccessValueInstruction(assignment, lexicalScope, target, receiverValues) {
     override val inputValues: List<PseudoValue>
@@ -114,7 +114,7 @@ public class WriteValueInstruction(
     }
 
     override fun toString(): String {
-        val lhs = (lValue as? JetNamedDeclaration)?.getName() ?: render(lValue)
+        val lhs = (lValue as? KtNamedDeclaration)?.getName() ?: render(lValue)
         return "w($lhs|${inputValues.joinToString(", ")})"
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/operationInstructions.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/operationInstructions.kt
index 436d43f16b9..60d34d8e0bb 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/operationInstructions.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/operationInstructions.kt
@@ -24,12 +24,12 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitorWithRe
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionWithNext
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.LexicalScope
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 
 public abstract class OperationInstruction protected constructor(
-        element: JetElement,
+        element: KtElement,
         lexicalScope: LexicalScope,
         override val inputValues: List<PseudoValue>
 ) : InstructionWithNext(element, lexicalScope), InstructionWithValue {
@@ -48,20 +48,20 @@ public abstract class OperationInstruction protected constructor(
         return this
     }
 
-    protected fun setResult(factory: PseudoValueFactory?, valueElement: JetElement? = element): OperationInstruction {
+    protected fun setResult(factory: PseudoValueFactory?, valueElement: KtElement? = element): OperationInstruction {
         return setResult(factory?.newValue(valueElement, this))
     }
 }
 
 public class CallInstruction private constructor(
-        element: JetElement,
+        element: KtElement,
         lexicalScope: LexicalScope,
         val resolvedCall: ResolvedCall<*>,
         override val receiverValues: Map<PseudoValue, ReceiverValue>,
         public val arguments: Map<PseudoValue, ValueParameterDescriptor>
 ) : OperationInstruction(element, lexicalScope, (receiverValues.keySet() as Collection<PseudoValue>) + arguments.keySet()), InstructionWithReceivers {
     public constructor (
-            element: JetElement,
+            element: KtElement,
             lexicalScope: LexicalScope,
             resolvedCall: ResolvedCall<*>,
             receiverValues: Map<PseudoValue, ReceiverValue>,
@@ -92,14 +92,14 @@ public class CallInstruction private constructor(
 //      denote value transformation which can't be expressed by other instructions (such as call or read)
 //      pass more than one value to instruction which formally requires only one (e.g. jump)
 public class MagicInstruction(
-        element: JetElement,
+        element: KtElement,
         lexicalScope: LexicalScope,
         inputValues: List<PseudoValue>,
         val kind: MagicKind
 ) : OperationInstruction(element, lexicalScope, inputValues) {
     public constructor (
-            element: JetElement,
-            valueElement: JetElement?,
+            element: KtElement,
+            valueElement: KtElement?,
             lexicalScope: LexicalScope,
             inputValues: List<PseudoValue>,
             kind: MagicKind,
@@ -146,12 +146,12 @@ public enum class MagicKind(val sideEffectFree: Boolean = false) {
 
 // Merges values produced by alternative control-flow paths (such as 'if' branches)
 class MergeInstruction private constructor(
-        element: JetElement,
+        element: KtElement,
         lexicalScope: LexicalScope,
         inputValues: List<PseudoValue>
 ): OperationInstruction(element, lexicalScope, inputValues) {
     public constructor (
-            element: JetElement,
+            element: KtElement,
             lexicalScope: LexicalScope,
             inputValues: List<PseudoValue>,
             factory: PseudoValueFactory
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/AbstractJumpInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/AbstractJumpInstruction.kt
index f78d3371924..64f1951ae92 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/AbstractJumpInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/AbstractJumpInstruction.kt
@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.cfg.pseudocode.instructions.jumps
 
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.cfg.Label
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.LexicalScope
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.JetElementInstructionImpl
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.Instruction
 import org.jetbrains.kotlin.utils.emptyOrSingletonList
 
 public abstract class AbstractJumpInstruction(
-        element: JetElement,
+        element: KtElement,
         public val targetLabel: Label,
         lexicalScope: LexicalScope
 ) : JetElementInstructionImpl(element, lexicalScope), JumpInstruction {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ConditionalJumpInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ConditionalJumpInstruction.kt
index d3f2835895b..097acb94ab4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ConditionalJumpInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ConditionalJumpInstruction.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.cfg.pseudocode.instructions.jumps
 
 import org.jetbrains.kotlin.cfg.pseudocode.PseudoValue
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.cfg.Label
 import java.util.Arrays
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.LexicalScope
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitor
 import org.jetbrains.kotlin.utils.emptyOrSingletonList
 
 public class ConditionalJumpInstruction(
-        element: JetElement,
+        element: KtElement,
         public val onTrue: Boolean,
         lexicalScope: LexicalScope,
         targetLabel: Label,
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/NondeterministicJumpInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/NondeterministicJumpInstruction.kt
index 265dca00663..42d1660dd75 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/NondeterministicJumpInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/NondeterministicJumpInstruction.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.cfg.pseudocode.instructions.jumps
 
 import org.jetbrains.kotlin.cfg.pseudocode.PseudoValue
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.cfg.Label
 import com.google.common.collect.Maps
 import com.google.common.collect.Lists
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionImpl
 import org.jetbrains.kotlin.utils.emptyOrSingletonList
 
 public class NondeterministicJumpInstruction(
-        element: JetElement,
+        element: KtElement,
         targetLabels: List<Label>,
         lexicalScope: LexicalScope,
         public val inputValue: PseudoValue?
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ReturnNoValueInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ReturnNoValueInstruction.kt
index 2209a2a85a6..b594722ef0b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ReturnNoValueInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ReturnNoValueInstruction.kt
@@ -16,14 +16,14 @@
 
 package org.jetbrains.kotlin.cfg.pseudocode.instructions.jumps
 
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.cfg.Label
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.LexicalScope
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitor
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitorWithResult
 
 public class ReturnNoValueInstruction(
-        element: JetElement,
+        element: KtElement,
         lexicalScope: LexicalScope,
         targetLabel: Label
 ) : AbstractJumpInstruction(element, targetLabel, lexicalScope) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ReturnValueInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ReturnValueInstruction.kt
index 73fe535251b..5cf0058924c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ReturnValueInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ReturnValueInstruction.kt
@@ -17,16 +17,16 @@
 package org.jetbrains.kotlin.cfg.pseudocode.instructions.jumps
 
 import org.jetbrains.kotlin.cfg.pseudocode.PseudoValue
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.cfg.Label
 import java.util.Collections
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.LexicalScope
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitor
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitorWithResult
-import org.jetbrains.kotlin.psi.JetReturnExpression
+import org.jetbrains.kotlin.psi.KtReturnExpression
 
 public class ReturnValueInstruction(
-        returnExpression: JetExpression,
+        returnExpression: KtExpression,
         lexicalScope: LexicalScope,
         targetLabel: Label,
         public val returnedValue: PseudoValue
@@ -46,8 +46,8 @@ public class ReturnValueInstruction(
     }
 
     override fun createCopy(newLabel: Label, lexicalScope: LexicalScope): AbstractJumpInstruction {
-        return ReturnValueInstruction((element as JetExpression), lexicalScope, newLabel, returnedValue)
+        return ReturnValueInstruction((element as KtExpression), lexicalScope, newLabel, returnedValue)
     }
 
-    public val returnExpressionIfAny: JetReturnExpression? = element as? JetReturnExpression
+    public val returnExpressionIfAny: KtReturnExpression? = element as? KtReturnExpression
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ThrowExceptionInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ThrowExceptionInstruction.kt
index f651026c3b2..2789d309f17 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ThrowExceptionInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/ThrowExceptionInstruction.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.cfg.pseudocode.instructions.jumps
 
 import org.jetbrains.kotlin.cfg.pseudocode.PseudoValue
-import org.jetbrains.kotlin.psi.JetThrowExpression
+import org.jetbrains.kotlin.psi.KtThrowExpression
 import org.jetbrains.kotlin.cfg.Label
 import java.util.Collections
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.LexicalScope
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitor
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitorWithResult
 
 public class ThrowExceptionInstruction(
-        expression: JetThrowExpression,
+        expression: KtThrowExpression,
         lexicalScope: LexicalScope,
         errorLabel: Label,
         public val thrownValue: PseudoValue
@@ -45,6 +45,6 @@ public class ThrowExceptionInstruction(
     }
 
     override fun createCopy(newLabel: Label, lexicalScope: LexicalScope): AbstractJumpInstruction {
-        return ThrowExceptionInstruction((element as JetThrowExpression), lexicalScope, newLabel, thrownValue)
+        return ThrowExceptionInstruction((element as KtThrowExpression), lexicalScope, newLabel, thrownValue)
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/UnconditionalJumpInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/UnconditionalJumpInstruction.kt
index 7379b081513..7ba612a9872 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/UnconditionalJumpInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/UnconditionalJumpInstruction.kt
@@ -17,11 +17,11 @@
 package org.jetbrains.kotlin.cfg.pseudocode.instructions.jumps
 
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.*
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.cfg.Label
 
 public class UnconditionalJumpInstruction(
-        element: JetElement,
+        element: KtElement,
         targetLabel: Label,
         lexicalScope: LexicalScope
 ) : AbstractJumpInstruction(element, targetLabel, lexicalScope) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/LocalFunctionDeclarationInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/LocalFunctionDeclarationInstruction.kt
index 08f600c545c..f923aa57cce 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/LocalFunctionDeclarationInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/LocalFunctionDeclarationInstruction.kt
@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.cfg.pseudocode.instructions.special
 
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.cfg.pseudocode.Pseudocode
 import com.google.common.collect.Lists
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.LexicalScope
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitorWithRe
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionImpl
 
 public class LocalFunctionDeclarationInstruction(
-        element: JetElement,
+        element: KtElement,
         public val body: Pseudocode,
         lexicalScope: LexicalScope
 ) : InstructionWithNext(element, lexicalScope) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/MarkInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/MarkInstruction.kt
index 47b0c442cdf..29e6a1a0723 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/MarkInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/MarkInstruction.kt
@@ -16,14 +16,14 @@
 
 package org.jetbrains.kotlin.cfg.pseudocode.instructions.special
 
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.LexicalScope
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionWithNext
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitor
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitorWithResult
 
 public class MarkInstruction(
-        element: JetElement,
+        element: KtElement,
         lexicalScope: LexicalScope
 ) : InstructionWithNext(element, lexicalScope) {
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/SubroutineEnterInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/SubroutineEnterInstruction.kt
index b514b7195c0..ba50a36a024 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/SubroutineEnterInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/SubroutineEnterInstruction.kt
@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.cfg.pseudocode.instructions.special
 
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.LexicalScope
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionWithNext
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitor
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitorWithRe
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionImpl
 
 public class SubroutineEnterInstruction(
-        public val subroutine: JetElement,
+        public val subroutine: KtElement,
         lexicalScope: LexicalScope
 ) : InstructionWithNext(subroutine, lexicalScope) {
     override fun accept(visitor: InstructionVisitor) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/SubroutineExitInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/SubroutineExitInstruction.kt
index 9eb7f05f1d2..58abcccf740 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/SubroutineExitInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/SubroutineExitInstruction.kt
@@ -17,11 +17,11 @@
 package org.jetbrains.kotlin.cfg.pseudocode.instructions.special
 
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.*
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import java.util.*
 
 public class SubroutineExitInstruction(
-        public val subroutine: JetElement,
+        public val subroutine: KtElement,
         lexicalScope: LexicalScope,
         public val isError: Boolean
 ) : InstructionImpl(lexicalScope) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/SubroutineSinkInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/SubroutineSinkInstruction.kt
index be1d029ed81..7d83c1e19db 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/SubroutineSinkInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/SubroutineSinkInstruction.kt
@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.cfg.pseudocode.instructions.special
 
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import java.util.Collections
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.LexicalScope
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionImpl
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitor
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitorWithResult
 
 public class SubroutineSinkInstruction(
-        public val subroutine: JetElement,
+        public val subroutine: KtElement,
         lexicalScope: LexicalScope,
         private val debugLabel: String) : InstructionImpl(lexicalScope) {
     override val nextInstructions: Collection<Instruction>
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/VariableDeclarationInstruction.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/VariableDeclarationInstruction.kt
index 8d0a485665d..415f1dc948c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/VariableDeclarationInstruction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/special/VariableDeclarationInstruction.kt
@@ -16,9 +16,9 @@
 
 package org.jetbrains.kotlin.cfg.pseudocode.instructions.special
 
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetVariableDeclaration
-import org.jetbrains.kotlin.psi.JetParameter
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtVariableDeclaration
+import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionWithNext
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.LexicalScope
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitor
@@ -26,15 +26,15 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitorWithRe
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionImpl
 
 public class VariableDeclarationInstruction(
-        element: JetDeclaration,
+        element: KtDeclaration,
         lexicalScope: LexicalScope
 ) : InstructionWithNext(element, lexicalScope) {
     init {
-        assert(element is JetVariableDeclaration || element is JetParameter) { "Invalid element: ${render(element)}}" }
+        assert(element is KtVariableDeclaration || element is KtParameter) { "Invalid element: ${render(element)}}" }
     }
 
-    public val variableDeclarationElement: JetDeclaration
-        get() = element as JetDeclaration
+    public val variableDeclarationElement: KtDeclaration
+        get() = element as KtDeclaration
 
     override fun accept(visitor: InstructionVisitor) {
         visitor.visitVariableDeclarationInstruction(this)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtils.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtils.kt
index 9c42fa676e9..b362feaf087 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtils.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtils.kt
@@ -46,7 +46,7 @@ import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
 import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionCandidate
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import java.util.*
 
@@ -77,14 +77,14 @@ public fun getExpectedTypePredicate(
     val pseudocode = value.createdAt?.owner ?: return AllTypes
     val typePredicates = LinkedHashSet<TypePredicate?>()
 
-    fun addSubtypesOf(jetType: JetType?) = typePredicates.add(jetType?.getSubtypesPredicate())
+    fun addSubtypesOf(jetType: KtType?) = typePredicates.add(jetType?.getSubtypesPredicate())
 
     fun addByExplicitReceiver(resolvedCall: ResolvedCall<*>?) {
         val receiverValue = (resolvedCall ?: return).getExplicitReceiverValue()
         if (receiverValue.exists()) typePredicates.add(getReceiverTypePredicate(resolvedCall, receiverValue))
     }
 
-    fun getTypePredicateForUnresolvedCallArgument(to: JetElement, inputValueIndex: Int): TypePredicate? {
+    fun getTypePredicateForUnresolvedCallArgument(to: KtElement, inputValueIndex: Int): TypePredicate? {
         if (inputValueIndex < 0) return null
         val call = to.getCall(bindingContext) ?: return null
         val callee = call.getCalleeExpression() ?: return null
@@ -147,7 +147,7 @@ public fun getExpectedTypePredicate(
                 is ReturnValueInstruction -> {
                     val returnElement = it.element
                     val functionDescriptor = when(returnElement) {
-                        is JetReturnExpression -> returnElement.getTargetFunctionDescriptor(bindingContext)
+                        is KtReturnExpression -> returnElement.getTargetFunctionDescriptor(bindingContext)
                         else -> bindingContext[DECLARATION_TO_DESCRIPTOR, pseudocode.getCorrespondingElement()]
                     }
                     addSubtypesOf((functionDescriptor as? CallableDescriptor)?.getReturnType())
@@ -204,22 +204,22 @@ public fun getExpectedTypePredicate(
                         addSubtypesOf(builtIns.getBooleanType())
 
                     LOOP_RANGE_ITERATION ->
-                        addByExplicitReceiver(bindingContext[LOOP_RANGE_ITERATOR_RESOLVED_CALL, value.element as? JetExpression])
+                        addByExplicitReceiver(bindingContext[LOOP_RANGE_ITERATOR_RESOLVED_CALL, value.element as? KtExpression])
 
                     VALUE_CONSUMER -> {
                         val element = it.element
                         when {
-                            element.getStrictParentOfType<JetWhileExpression>()?.getCondition() == element ->
+                            element.getStrictParentOfType<KtWhileExpression>()?.getCondition() == element ->
                                 addSubtypesOf(builtIns.getBooleanType())
 
-                            element is JetProperty -> {
+                            element is KtProperty -> {
                                 val propertyDescriptor = bindingContext[DECLARATION_TO_DESCRIPTOR, element] as? PropertyDescriptor
                                 propertyDescriptor?.getAccessors()?.map {
                                     addByExplicitReceiver(bindingContext[DELEGATED_PROPERTY_RESOLVED_CALL, it])
                                 }
                             }
 
-                            element is JetDelegatorByExpressionSpecifier ->
+                            element is KtDelegatorByExpressionSpecifier ->
                                 addSubtypesOf(bindingContext[TYPE, element.getTypeReference()])
                         }
                     }
@@ -260,7 +260,7 @@ fun Instruction.calcSideEffectFree(): Boolean {
                 }
 
                 else -> when (element) {
-                    is JetConstantExpression, is JetFunctionLiteralExpression, is JetStringTemplateExpression -> true
+                    is KtConstantExpression, is KtFunctionLiteralExpression, is KtStringTemplateExpression -> true
                     else -> false
                 }
             }
@@ -272,7 +272,7 @@ fun Instruction.calcSideEffectFree(): Boolean {
     }
 }
 
-fun Pseudocode.getElementValuesRecursively(element: JetElement): List<PseudoValue> {
+fun Pseudocode.getElementValuesRecursively(element: KtElement): List<PseudoValue> {
     val results = ArrayList<PseudoValue>()
 
     fun Pseudocode.collectValues() {
@@ -286,14 +286,14 @@ fun Pseudocode.getElementValuesRecursively(element: JetElement): List<PseudoValu
     return results
 }
 
-public fun JetElement.getContainingPseudocode(context: BindingContext): Pseudocode? {
+public fun KtElement.getContainingPseudocode(context: BindingContext): Pseudocode? {
     val pseudocodeDeclaration =
-            PsiTreeUtil.getParentOfType(this, javaClass<JetDeclarationWithBody>(), javaClass<JetClassOrObject>())
-            ?: getNonStrictParentOfType<JetProperty>()
+            PsiTreeUtil.getParentOfType(this, javaClass<KtDeclarationWithBody>(), javaClass<KtClassOrObject>())
+            ?: getNonStrictParentOfType<KtProperty>()
             ?: return null
 
-    val enclosingPseudocodeDeclaration = (pseudocodeDeclaration as? JetFunctionLiteral)?.let {
-        it.parents.firstOrNull { it is JetDeclaration && it !is JetFunctionLiteral } as? JetDeclaration
+    val enclosingPseudocodeDeclaration = (pseudocodeDeclaration as? KtFunctionLiteral)?.let {
+        it.parents.firstOrNull { it is KtDeclaration && it !is KtFunctionLiteral } as? KtDeclaration
     } ?: pseudocodeDeclaration
 
     val enclosingPseudocode = PseudocodeUtil.generatePseudocode(enclosingPseudocodeDeclaration, context)
@@ -301,7 +301,7 @@ public fun JetElement.getContainingPseudocode(context: BindingContext): Pseudoco
            ?: throw AssertionError("Can't find nested pseudocode for element: ${pseudocodeDeclaration.getElementTextWithContext()}")
 }
 
-public fun Pseudocode.getPseudocodeByElement(element: JetElement): Pseudocode? {
+public fun Pseudocode.getPseudocodeByElement(element: KtElement): Pseudocode? {
     if (getCorrespondingElement() == element) return this
 
     getLocalDeclarations().forEach { decl -> decl.body.getPseudocodeByElement(element)?.let { return it } }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/checkers/CheckerTestUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/checkers/CheckerTestUtil.java
index ed34b487053..f606ba745b6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/checkers/CheckerTestUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/checkers/CheckerTestUtil.java
@@ -39,9 +39,9 @@ import org.jetbrains.kotlin.diagnostics.Severity;
 import org.jetbrains.kotlin.diagnostics.rendering.AbstractDiagnosticWithParametersRenderer;
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages;
 import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticRenderer;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetReferenceExpression;
+import org.jetbrains.kotlin.psi.KtElement;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtReferenceExpression;
 import org.jetbrains.kotlin.resolve.AnalyzingUtils;
 import org.jetbrains.kotlin.resolve.BindingContext;
 
@@ -119,22 +119,22 @@ public class CheckerTestUtil {
         final List<Diagnostic> debugAnnotations = Lists.newArrayList();
         DebugInfoUtil.markDebugAnnotations(root, bindingContext, new DebugInfoUtil.DebugInfoReporter() {
             @Override
-            public void reportElementWithErrorType(@NotNull JetReferenceExpression expression) {
+            public void reportElementWithErrorType(@NotNull KtReferenceExpression expression) {
                 newDiagnostic(expression, DebugInfoDiagnosticFactory.ELEMENT_WITH_ERROR_TYPE);
             }
 
             @Override
-            public void reportMissingUnresolved(@NotNull JetReferenceExpression expression) {
+            public void reportMissingUnresolved(@NotNull KtReferenceExpression expression) {
                 newDiagnostic(expression, DebugInfoDiagnosticFactory.MISSING_UNRESOLVED);
             }
 
             @Override
-            public void reportUnresolvedWithTarget(@NotNull JetReferenceExpression expression, @NotNull String target) {
+            public void reportUnresolvedWithTarget(@NotNull KtReferenceExpression expression, @NotNull String target) {
                 newDiagnostic(expression, DebugInfoDiagnosticFactory.UNRESOLVED_WITH_TARGET);
             }
 
             @Override
-            public void reportDynamicCall(@NotNull JetElement element, DeclarationDescriptor declarationDescriptor) {
+            public void reportDynamicCall(@NotNull KtElement element, DeclarationDescriptor declarationDescriptor) {
                 if (dynamicCallDescriptors != null) {
                     dynamicCallDescriptors.add(declarationDescriptor);
                 }
@@ -144,13 +144,13 @@ public class CheckerTestUtil {
                 }
             }
 
-            private void newDiagnostic(JetElement element, DebugInfoDiagnosticFactory factory) {
+            private void newDiagnostic(KtElement element, DebugInfoDiagnosticFactory factory) {
                 debugAnnotations.add(new DebugInfoDiagnostic(element, factory));
             }
         });
         // this code is used in tests and in internal action 'copy current file as diagnostic test'
         //noinspection TestOnlyProblems
-        for (JetExpression expression : bindingContext.getSliceContents(BindingContext.SMARTCAST).keySet()) {
+        for (KtExpression expression : bindingContext.getSliceContents(BindingContext.SMARTCAST).keySet()) {
             if (PsiTreeUtil.isAncestor(root, expression, false)) {
                 debugAnnotations.add(new DebugInfoDiagnostic(expression, DebugInfoDiagnosticFactory.SMARTCAST));
             }
@@ -533,7 +533,7 @@ public class CheckerTestUtil {
     }
 
     public static class DebugInfoDiagnostic extends AbstractDiagnosticForTests {
-        public DebugInfoDiagnostic(@NotNull JetElement element, @NotNull DebugInfoDiagnosticFactory factory) {
+        public DebugInfoDiagnostic(@NotNull KtElement element, @NotNull DebugInfoDiagnosticFactory factory) {
             super(element, factory);
         }
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/checkers/DebugInfoUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/checkers/DebugInfoUtil.java
index 4099fe2a433..f8ba829c6f9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/checkers/DebugInfoUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/checkers/DebugInfoUtil.java
@@ -22,7 +22,7 @@ import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.TokenSet;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.descriptors.VariableDescriptor;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory;
 import org.jetbrains.kotlin.diagnostics.Errors;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
@@ -38,13 +38,13 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.tasks.DynamicCallsKt;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
 
 import java.util.Collection;
 import java.util.Map;
 
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
+import static org.jetbrains.kotlin.lexer.KtTokens.*;
 import static org.jetbrains.kotlin.resolve.BindingContext.*;
 
 public class DebugInfoUtil {
@@ -54,17 +54,17 @@ public class DebugInfoUtil {
 
     public abstract static class DebugInfoReporter {
 
-        public void preProcessReference(@NotNull JetReferenceExpression expression) {
+        public void preProcessReference(@NotNull KtReferenceExpression expression) {
             // do nothing
         }
 
-        public abstract void reportElementWithErrorType(@NotNull JetReferenceExpression expression);
+        public abstract void reportElementWithErrorType(@NotNull KtReferenceExpression expression);
 
-        public abstract void reportMissingUnresolved(@NotNull JetReferenceExpression expression);
+        public abstract void reportMissingUnresolved(@NotNull KtReferenceExpression expression);
 
-        public abstract void reportUnresolvedWithTarget(@NotNull JetReferenceExpression expression, @NotNull String target);
+        public abstract void reportUnresolvedWithTarget(@NotNull KtReferenceExpression expression, @NotNull String target);
 
-        public void reportDynamicCall(@NotNull JetElement element, DeclarationDescriptor declarationDescriptor) { }
+        public void reportDynamicCall(@NotNull KtElement element, DeclarationDescriptor declarationDescriptor) { }
     }
 
     public static void markDebugAnnotations(
@@ -72,33 +72,33 @@ public class DebugInfoUtil {
             @NotNull final BindingContext bindingContext,
             @NotNull final DebugInfoReporter debugInfoReporter
     ) {
-        final Map<JetReferenceExpression, DiagnosticFactory<?>> markedWithErrorElements = Maps.newHashMap();
+        final Map<KtReferenceExpression, DiagnosticFactory<?>> markedWithErrorElements = Maps.newHashMap();
         for (Diagnostic diagnostic : bindingContext.getDiagnostics()) {
             DiagnosticFactory<?> factory = diagnostic.getFactory();
             if (Errors.UNRESOLVED_REFERENCE_DIAGNOSTICS.contains(diagnostic.getFactory())) {
-                markedWithErrorElements.put((JetReferenceExpression) diagnostic.getPsiElement(), factory);
+                markedWithErrorElements.put((KtReferenceExpression) diagnostic.getPsiElement(), factory);
             }
             else if (factory == Errors.SUPER_IS_NOT_AN_EXPRESSION
                     || factory == Errors.SUPER_NOT_AVAILABLE) {
-                JetSuperExpression superExpression = (JetSuperExpression) diagnostic.getPsiElement();
+                KtSuperExpression superExpression = (KtSuperExpression) diagnostic.getPsiElement();
                 markedWithErrorElements.put(superExpression.getInstanceReference(), factory);
             }
             else if (factory == Errors.EXPRESSION_EXPECTED_PACKAGE_FOUND) {
-                markedWithErrorElements.put((JetSimpleNameExpression) diagnostic.getPsiElement(), factory);
+                markedWithErrorElements.put((KtSimpleNameExpression) diagnostic.getPsiElement(), factory);
             }
             else if (factory == Errors.UNSUPPORTED) {
-                for (JetReferenceExpression reference : PsiTreeUtil.findChildrenOfType(diagnostic.getPsiElement(),
-                                                                                       JetReferenceExpression.class)) {
+                for (KtReferenceExpression reference : PsiTreeUtil.findChildrenOfType(diagnostic.getPsiElement(),
+                                                                                      KtReferenceExpression.class)) {
                     markedWithErrorElements.put(reference, factory);
                 }
             }
         }
 
-        root.acceptChildren(new JetTreeVisitorVoid() {
+        root.acceptChildren(new KtTreeVisitorVoid() {
 
             @Override
-            public void visitForExpression(@NotNull JetForExpression expression) {
-                JetExpression range = expression.getLoopRange();
+            public void visitForExpression(@NotNull KtForExpression expression) {
+                KtExpression range = expression.getLoopRange();
                 reportIfDynamicCall(range, range, LOOP_RANGE_ITERATOR_RESOLVED_CALL);
                 reportIfDynamicCall(range, range, LOOP_RANGE_HAS_NEXT_RESOLVED_CALL);
                 reportIfDynamicCall(range, range, LOOP_RANGE_NEXT_RESOLVED_CALL);
@@ -106,15 +106,15 @@ public class DebugInfoUtil {
             }
 
             @Override
-            public void visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration) {
-                for (JetMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
+            public void visitMultiDeclaration(@NotNull KtMultiDeclaration multiDeclaration) {
+                for (KtMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
                     reportIfDynamicCall(entry, entry, COMPONENT_RESOLVED_CALL);
                 }
                 super.visitMultiDeclaration(multiDeclaration);
             }
 
             @Override
-            public void visitProperty(@NotNull JetProperty property) {
+            public void visitProperty(@NotNull KtProperty property) {
                 VariableDescriptor descriptor = bindingContext.get(VARIABLE, property);
                 if (descriptor instanceof PropertyDescriptor && property.getDelegate() != null) {
                     PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
@@ -126,7 +126,7 @@ public class DebugInfoUtil {
             }
 
             @Override
-            public void visitThisExpression(@NotNull JetThisExpression expression) {
+            public void visitThisExpression(@NotNull KtThisExpression expression) {
                 ResolvedCall<? extends CallableDescriptor> resolvedCall = CallUtilKt.getResolvedCall(expression, bindingContext);
                 if (resolvedCall != null) {
                     reportIfDynamic(expression, resolvedCall.getResultingDescriptor(), debugInfoReporter);
@@ -135,23 +135,23 @@ public class DebugInfoUtil {
             }
 
             @Override
-            public void visitReferenceExpression(@NotNull JetReferenceExpression expression) {
+            public void visitReferenceExpression(@NotNull KtReferenceExpression expression) {
                 super.visitReferenceExpression(expression);
                 if (!BindingContextUtils.isExpressionWithValidReference(expression, bindingContext)){
                     return;
                 }
                 IElementType referencedNameElementType = null;
-                if (expression instanceof JetSimpleNameExpression) {
-                    JetSimpleNameExpression nameExpression = (JetSimpleNameExpression) expression;
+                if (expression instanceof KtSimpleNameExpression) {
+                    KtSimpleNameExpression nameExpression = (KtSimpleNameExpression) expression;
                     IElementType elementType = expression.getNode().getElementType();
-                    if (elementType == JetNodeTypes.OPERATION_REFERENCE) {
+                    if (elementType == KtNodeTypes.OPERATION_REFERENCE) {
                         referencedNameElementType = nameExpression.getReferencedNameElementType();
                         if (EXCLUDED.contains(referencedNameElementType)) {
                             return;
                         }
                     }
-                    if (elementType == JetNodeTypes.LABEL ||
-                            nameExpression.getReferencedNameElementType() == JetTokens.THIS_KEYWORD) {
+                    if (elementType == KtNodeTypes.LABEL ||
+                        nameExpression.getReferencedNameElementType() == KtTokens.THIS_KEYWORD) {
                         return;
                     }
                 }
@@ -191,12 +191,12 @@ public class DebugInfoUtil {
 
                 boolean resolved = target != null;
                 boolean markedWithError = markedWithErrorElements.containsKey(expression);
-                if (expression instanceof JetArrayAccessExpression &&
-                    markedWithErrorElements.containsKey(((JetArrayAccessExpression) expression).getArrayExpression())) {
+                if (expression instanceof KtArrayAccessExpression &&
+                    markedWithErrorElements.containsKey(((KtArrayAccessExpression) expression).getArrayExpression())) {
                     // if 'foo' in 'foo[i]' is unresolved it means 'foo[i]' is unresolved (otherwise 'foo[i]' is marked as 'missing unresolved')
                     markedWithError = true;
                 }
-                JetType expressionType = bindingContext.getType(expression);
+                KtType expressionType = bindingContext.getType(expression);
                 DiagnosticFactory<?> factory = markedWithErrorElements.get(expression);
                 if (declarationDescriptor != null &&
                     (ErrorUtils.isError(declarationDescriptor) || ErrorUtils.containsErrorType(expressionType))) {
@@ -214,7 +214,7 @@ public class DebugInfoUtil {
                 }
             }
 
-            private <E extends JetElement, K, D extends CallableDescriptor> boolean reportIfDynamicCall(E element, K key, WritableSlice<K, ResolvedCall<D>> slice) {
+            private <E extends KtElement, K, D extends CallableDescriptor> boolean reportIfDynamicCall(E element, K key, WritableSlice<K, ResolvedCall<D>> slice) {
                 ResolvedCall<D> resolvedCall = bindingContext.get(slice, key);
                 if (resolvedCall != null) {
                     return reportIfDynamic(element, resolvedCall.getResultingDescriptor(), debugInfoReporter);
@@ -224,7 +224,7 @@ public class DebugInfoUtil {
         });
     }
 
-    private static boolean reportIfDynamic(JetElement element, DeclarationDescriptor declarationDescriptor, DebugInfoReporter debugInfoReporter) {
+    private static boolean reportIfDynamic(KtElement element, DeclarationDescriptor declarationDescriptor, DebugInfoReporter debugInfoReporter) {
         if (declarationDescriptor != null && DynamicCallsKt.isDynamic(declarationDescriptor)) {
             debugInfoReporter.reportDynamicCall(element, declarationDescriptor);
             return true;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/LocalVariableDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/LocalVariableDescriptor.java
index b5677bea330..0c14ddc010d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/LocalVariableDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/LocalVariableDescriptor.java
@@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 
 public class LocalVariableDescriptor extends VariableDescriptorWithInitializerImpl {
@@ -29,7 +29,7 @@ public class LocalVariableDescriptor extends VariableDescriptorWithInitializerIm
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull Annotations annotations,
             @NotNull Name name,
-            @Nullable JetType type,
+            @Nullable KtType type,
             boolean mutable,
             @NotNull SourceElement source
     ) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/MutablePackageFragmentDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/MutablePackageFragmentDescriptor.java
index c6a36b5214e..fcc9b68c973 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/MutablePackageFragmentDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/MutablePackageFragmentDescriptor.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.descriptors.impl;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.name.FqName;
-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;
@@ -30,7 +30,7 @@ public class MutablePackageFragmentDescriptor extends PackageFragmentDescriptorI
     public MutablePackageFragmentDescriptor(@NotNull ModuleDescriptor module, @NotNull FqName fqName) {
         super(module, fqName);
 
-        scope = new WritableScopeImpl(JetScope.Empty.INSTANCE$, this, RedeclarationHandler.DO_NOTHING, "Members of " + fqName + " in " + module);
+        scope = new WritableScopeImpl(KtScope.Empty.INSTANCE$, this, RedeclarationHandler.DO_NOTHING, "Members of " + fqName + " in " + module);
         scope.changeLockLevel(WritableScope.LockLevel.BOTH);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/SyntheticFieldDescriptor.kt b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/SyntheticFieldDescriptor.kt
index b06f6faa702..e456fd34e91 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/SyntheticFieldDescriptor.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/SyntheticFieldDescriptor.kt
@@ -21,18 +21,18 @@ import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.resolve.source.toSourceElement
 
 class SyntheticFieldDescriptor private constructor(
         val propertyDescriptor: PropertyDescriptor,
         accessorDescriptor: PropertyAccessorDescriptor,
-        property: JetProperty
+        property: KtProperty
 ): LocalVariableDescriptor(accessorDescriptor, Annotations.EMPTY, SyntheticFieldDescriptor.NAME,
                            propertyDescriptor.type, propertyDescriptor.isVar, property.toSourceElement()) {
 
     constructor(accessorDescriptor: PropertyAccessorDescriptor,
-                property: JetProperty): this(accessorDescriptor.correspondingProperty, accessorDescriptor, property)
+                property: KtProperty): this(accessorDescriptor.correspondingProperty, accessorDescriptor, property)
 
     override fun getDispatchReceiverParameter() = propertyDescriptor.dispatchReceiverParameter
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticUtils.java
index c9827c98462..528d7dceb0f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticUtils.java
@@ -27,7 +27,7 @@ import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
 
@@ -66,7 +66,7 @@ public class DiagnosticUtils {
         }
     }
 
-    public static String atLocation(JetExpression expression) {
+    public static String atLocation(KtExpression expression) {
         return atLocation(expression.getNode());
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
index 10c2997c8a5..68b75c1bb20 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
@@ -22,15 +22,15 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.impl.source.tree.LeafPsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.lexer.JetKeywordToken;
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtKeywordToken;
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.calls.inference.InferenceErrorData;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker.VarianceConflictDiagnosticData;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
@@ -63,25 +63,25 @@ public interface Errors {
 
     DiagnosticFactory1<PsiElement, String> REDECLARATION = DiagnosticFactory1.create(ERROR, FOR_REDECLARATION);
 
-    DiagnosticFactory1<JetReferenceExpression, JetReferenceExpression> UNRESOLVED_REFERENCE =
+    DiagnosticFactory1<KtReferenceExpression, KtReferenceExpression> UNRESOLVED_REFERENCE =
             DiagnosticFactory1.create(ERROR, FOR_UNRESOLVED_REFERENCE);
 
     //Elements with "INVISIBLE_REFERENCE" error are marked as unresolved, unlike elements with "INVISIBLE_MEMBER" error
     //"INVISIBLE_REFERENCE" is used for invisible classes references and references in import
-    DiagnosticFactory3<JetSimpleNameExpression, DeclarationDescriptor, Visibility, DeclarationDescriptor> INVISIBLE_REFERENCE =
+    DiagnosticFactory3<KtSimpleNameExpression, DeclarationDescriptor, Visibility, DeclarationDescriptor> INVISIBLE_REFERENCE =
             DiagnosticFactory3.create(ERROR);
     DiagnosticFactory3<PsiElement, DeclarationDescriptor, Visibility, DeclarationDescriptor> INVISIBLE_MEMBER = DiagnosticFactory3.create(ERROR, CALL_ELEMENT);
 
     // Exposed visibility group
-    DiagnosticFactory2<JetProperty, EffectiveVisibility, EffectiveVisibility> EXPOSED_PROPERTY_TYPE = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<KtProperty, EffectiveVisibility, EffectiveVisibility> EXPOSED_PROPERTY_TYPE = DiagnosticFactory2.create(WARNING);
     DiagnosticFactory2<PsiElement, EffectiveVisibility, EffectiveVisibility> EXPOSED_FUNCTION_RETURN_TYPE = DiagnosticFactory2.create(WARNING);
-    DiagnosticFactory2<JetParameter, EffectiveVisibility, EffectiveVisibility> EXPOSED_PARAMETER_TYPE = DiagnosticFactory2.create(WARNING);
-    DiagnosticFactory2<JetTypeReference, EffectiveVisibility, EffectiveVisibility> EXPOSED_RECEIVER_TYPE = DiagnosticFactory2.create(WARNING);
-    DiagnosticFactory2<JetTypeParameter, EffectiveVisibility, EffectiveVisibility> EXPOSED_TYPE_PARAMETER_BOUND = DiagnosticFactory2.create(WARNING);
-    DiagnosticFactory2<JetDelegationSpecifier, EffectiveVisibility, EffectiveVisibility> EXPOSED_SUPER_CLASS = DiagnosticFactory2.create(WARNING);
-    DiagnosticFactory2<JetDelegationSpecifier, EffectiveVisibility, EffectiveVisibility> EXPOSED_SUPER_INTERFACE = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<KtParameter, EffectiveVisibility, EffectiveVisibility> EXPOSED_PARAMETER_TYPE = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<KtTypeReference, EffectiveVisibility, EffectiveVisibility> EXPOSED_RECEIVER_TYPE = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<KtTypeParameter, EffectiveVisibility, EffectiveVisibility> EXPOSED_TYPE_PARAMETER_BOUND = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<KtDelegationSpecifier, EffectiveVisibility, EffectiveVisibility> EXPOSED_SUPER_CLASS = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<KtDelegationSpecifier, EffectiveVisibility, EffectiveVisibility> EXPOSED_SUPER_INTERFACE = DiagnosticFactory2.create(WARNING);
 
-    DiagnosticFactory1<JetElement, Collection<ClassDescriptor>> PLATFORM_CLASS_MAPPED_TO_KOTLIN = DiagnosticFactory1.create(WARNING);
+    DiagnosticFactory1<KtElement, Collection<ClassDescriptor>> PLATFORM_CLASS_MAPPED_TO_KOTLIN = DiagnosticFactory1.create(WARNING);
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -90,13 +90,13 @@ public interface Errors {
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-    DiagnosticFactory0<JetTypeProjection> PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT = DiagnosticFactory0.create(ERROR, VARIANCE_IN_PROJECTION);
-    DiagnosticFactory2<JetTypeReference, JetType, JetType> UPPER_BOUND_VIOLATED = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory0<JetNullableType> REDUNDANT_NULLABLE = DiagnosticFactory0.create(WARNING, NULLABLE_TYPE);
-    DiagnosticFactory1<JetElement, Integer> WRONG_NUMBER_OF_TYPE_ARGUMENTS = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory2<JetTypeReference, Integer, String> NO_TYPE_ARGUMENTS_ON_RHS = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory1<JetTypeProjection, ClassifierDescriptor> CONFLICTING_PROJECTION = DiagnosticFactory1.create(ERROR, VARIANCE_IN_PROJECTION);
-    DiagnosticFactory1<JetTypeProjection, ClassifierDescriptor> REDUNDANT_PROJECTION = DiagnosticFactory1.create(WARNING, VARIANCE_IN_PROJECTION);
+    DiagnosticFactory0<KtTypeProjection> PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT = DiagnosticFactory0.create(ERROR, VARIANCE_IN_PROJECTION);
+    DiagnosticFactory2<KtTypeReference, KtType, KtType> UPPER_BOUND_VIOLATED = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory0<KtNullableType> REDUNDANT_NULLABLE = DiagnosticFactory0.create(WARNING, NULLABLE_TYPE);
+    DiagnosticFactory1<KtElement, Integer> WRONG_NUMBER_OF_TYPE_ARGUMENTS = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory2<KtTypeReference, Integer, String> NO_TYPE_ARGUMENTS_ON_RHS = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory1<KtTypeProjection, ClassifierDescriptor> CONFLICTING_PROJECTION = DiagnosticFactory1.create(ERROR, VARIANCE_IN_PROJECTION);
+    DiagnosticFactory1<KtTypeProjection, ClassifierDescriptor> REDUNDANT_PROJECTION = DiagnosticFactory1.create(WARNING, VARIANCE_IN_PROJECTION);
     DiagnosticFactory1<PsiElement, VarianceConflictDiagnosticData> TYPE_VARIANCE_CONFLICT =
             DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
 
@@ -108,51 +108,51 @@ public interface Errors {
 
     // Imports
 
-    DiagnosticFactory1<JetSimpleNameExpression, ClassDescriptor> CANNOT_ALL_UNDER_IMPORT_FROM_SINGLETON = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetSimpleNameExpression, Name> CANNOT_BE_IMPORTED = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory0<JetSimpleNameExpression> PACKAGE_CANNOT_BE_IMPORTED = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory1<KtSimpleNameExpression, ClassDescriptor> CANNOT_ALL_UNDER_IMPORT_FROM_SINGLETON = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtSimpleNameExpression, Name> CANNOT_BE_IMPORTED = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory0<KtSimpleNameExpression> PACKAGE_CANNOT_BE_IMPORTED = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory1<JetImportDirective, String> CONFLICTING_IMPORT = DiagnosticFactory1.create(ERROR, PositioningStrategies.IMPORT_ALIAS);
+    DiagnosticFactory1<KtImportDirective, String> CONFLICTING_IMPORT = DiagnosticFactory1.create(ERROR, PositioningStrategies.IMPORT_ALIAS);
 
     // Modifiers
 
-    DiagnosticFactory2<PsiElement, JetModifierKeywordToken, JetModifierKeywordToken> INCOMPATIBLE_MODIFIERS = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory2<PsiElement, JetModifierKeywordToken, JetModifierKeywordToken> DEPRECATED_MODIFIER_PAIR = DiagnosticFactory2.create(WARNING);
-    DiagnosticFactory1<PsiElement, JetModifierKeywordToken> REPEATED_MODIFIER = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory2<PsiElement, JetModifierKeywordToken, JetModifierKeywordToken> REDUNDANT_MODIFIER = DiagnosticFactory2.create(WARNING);
-    DiagnosticFactory2<PsiElement, JetModifierKeywordToken, String> WRONG_MODIFIER_TARGET = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory2<PsiElement, JetModifierKeywordToken, String> REDUNDANT_MODIFIER_FOR_TARGET = DiagnosticFactory2.create(WARNING);
-    DiagnosticFactory2<PsiElement, JetModifierKeywordToken, String> WRONG_MODIFIER_CONTAINING_DECLARATION = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory2<PsiElement, JetModifierKeywordToken, String> DEPRECATED_MODIFIER_CONTAINING_DECLARATION = DiagnosticFactory2.create(WARNING);
-    DiagnosticFactory1<PsiElement, JetModifierKeywordToken> ILLEGAL_INLINE_PARAMETER_MODIFIER = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetAnnotationEntry, String> WRONG_ANNOTATION_TARGET = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory2<JetAnnotationEntry, String, String> WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory0<JetAnnotationEntry> REPEATED_ANNOTATION = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetAnnotationEntry> NON_SOURCE_ANNOTATION_ON_INLINED_FUNCTION_LITERAL = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory2<PsiElement, KtModifierKeywordToken, KtModifierKeywordToken> INCOMPATIBLE_MODIFIERS = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory2<PsiElement, KtModifierKeywordToken, KtModifierKeywordToken> DEPRECATED_MODIFIER_PAIR = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory1<PsiElement, KtModifierKeywordToken> REPEATED_MODIFIER = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory2<PsiElement, KtModifierKeywordToken, KtModifierKeywordToken> REDUNDANT_MODIFIER = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<PsiElement, KtModifierKeywordToken, String> WRONG_MODIFIER_TARGET = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory2<PsiElement, KtModifierKeywordToken, String> REDUNDANT_MODIFIER_FOR_TARGET = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<PsiElement, KtModifierKeywordToken, String> WRONG_MODIFIER_CONTAINING_DECLARATION = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory2<PsiElement, KtModifierKeywordToken, String> DEPRECATED_MODIFIER_CONTAINING_DECLARATION = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory1<PsiElement, KtModifierKeywordToken> ILLEGAL_INLINE_PARAMETER_MODIFIER = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtAnnotationEntry, String> WRONG_ANNOTATION_TARGET = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory2<KtAnnotationEntry, String, String> WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory0<KtAnnotationEntry> REPEATED_ANNOTATION = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtAnnotationEntry> NON_SOURCE_ANNOTATION_ON_INLINED_FUNCTION_LITERAL = DiagnosticFactory0.create(ERROR);
 
     // Annotations
 
-    DiagnosticFactory0<JetDelegationSpecifierList> SUPERTYPES_FOR_ANNOTATION_CLASS = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetParameter> MISSING_VAL_ON_ANNOTATION_PARAMETER = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetCallExpression> ANNOTATION_CLASS_CONSTRUCTOR_CALL = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory1<JetAnnotationEntry, DeclarationDescriptor> NOT_AN_ANNOTATION_CLASS = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory0<KtDelegationSpecifierList> SUPERTYPES_FOR_ANNOTATION_CLASS = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtParameter> MISSING_VAL_ON_ANNOTATION_PARAMETER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtCallExpression> ANNOTATION_CLASS_CONSTRUCTOR_CALL = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory1<KtAnnotationEntry, DeclarationDescriptor> NOT_AN_ANNOTATION_CLASS = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory0<PsiElement> ANNOTATION_CLASS_WITH_BODY = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetTypeReference> INVALID_TYPE_OF_ANNOTATION_MEMBER = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetTypeReference> NULLABLE_TYPE_OF_ANNOTATION_MEMBER = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetExpression> ANNOTATION_PARAMETER_MUST_BE_CONST = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetExpression> ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetExpression> ANNOTATION_PARAMETER_MUST_BE_ENUM_CONST = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetExpression> ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeReference> INVALID_TYPE_OF_ANNOTATION_MEMBER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeReference> NULLABLE_TYPE_OF_ANNOTATION_MEMBER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> ANNOTATION_PARAMETER_MUST_BE_CONST = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> ANNOTATION_PARAMETER_MUST_BE_ENUM_CONST = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT = DiagnosticFactory0.create(ERROR);
 
     // Const
     DiagnosticFactory0<PsiElement> CONST_VAL_NOT_TOP_LEVEL_OR_OBJECT = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<PsiElement> CONST_VAL_WITH_GETTER = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<PsiElement> CONST_VAL_WITH_DELEGATE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory1<PsiElement, JetType> TYPE_CANT_BE_USED_FOR_CONST_VAL = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<PsiElement, KtType> TYPE_CANT_BE_USED_FOR_CONST_VAL = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory0<PsiElement> CONST_VAL_WITHOUT_INITIALIZER = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetExpression> CONST_VAL_WITH_NON_CONST_INITIALIZER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> CONST_VAL_WITH_NON_CONST_INITIALIZER = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetExpression> NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory1<PsiElement, String> INAPPLICABLE_TARGET_ON_PROPERTY = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory0<PsiElement> INAPPLICABLE_FIELD_TARGET_NO_BACKING_FIELD = DiagnosticFactory0.create(ERROR);
@@ -163,257 +163,257 @@ public interface Errors {
 
     // Classes and interfaces
 
-    DiagnosticFactory0<JetTypeProjection> PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE =
+    DiagnosticFactory0<KtTypeProjection> PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE =
             DiagnosticFactory0.create(ERROR, VARIANCE_IN_PROJECTION);
 
     DiagnosticFactory0<PsiElement> CYCLIC_INHERITANCE_HIERARCHY = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetDelegatorToSuperClass> SUPERTYPE_NOT_INITIALIZED = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtDelegatorToSuperClass> SUPERTYPE_NOT_INITIALIZED = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetTypeReference> DELEGATION_NOT_TO_INTERFACE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetTypeReference> SUPERTYPE_NOT_A_CLASS_OR_INTERFACE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetTypeReference> SUPERTYPE_IS_EXTENSION_FUNCTION_TYPE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeReference> DELEGATION_NOT_TO_INTERFACE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeReference> SUPERTYPE_NOT_A_CLASS_OR_INTERFACE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeReference> SUPERTYPE_IS_EXTENSION_FUNCTION_TYPE = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory0<PsiElement> NO_GENERICS_IN_SUPERTYPE_SPECIFIER = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory0<PsiElement> GENERICS_IN_CONTAINING_TYPE_NOT_ALLOWED = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetTypeReference> MANY_CLASSES_IN_SUPERTYPE_LIST = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetTypeReference> SUPERTYPE_APPEARS_TWICE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory3<JetDelegationSpecifierList, TypeParameterDescriptor, ClassDescriptor, Collection<JetType>>
+    DiagnosticFactory0<KtTypeReference> MANY_CLASSES_IN_SUPERTYPE_LIST = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeReference> SUPERTYPE_APPEARS_TWICE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory3<KtDelegationSpecifierList, TypeParameterDescriptor, ClassDescriptor, Collection<KtType>>
             INCONSISTENT_TYPE_PARAMETER_VALUES = DiagnosticFactory3.create(ERROR);
 
 
-    DiagnosticFactory0<JetTypeReference> FINAL_SUPERTYPE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetTypeReference> DATA_CLASS_CANNOT_HAVE_CLASS_SUPERTYPES = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetTypeReference> SINGLETON_IN_SUPERTYPE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetNullableType> NULLABLE_SUPERTYPE = DiagnosticFactory0.create(ERROR, NULLABLE_TYPE);
-    DiagnosticFactory0<JetTypeReference> DYNAMIC_SUPERTYPE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeReference> FINAL_SUPERTYPE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeReference> DATA_CLASS_CANNOT_HAVE_CLASS_SUPERTYPES = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeReference> SINGLETON_IN_SUPERTYPE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtNullableType> NULLABLE_SUPERTYPE = DiagnosticFactory0.create(ERROR, NULLABLE_TYPE);
+    DiagnosticFactory0<KtTypeReference> DYNAMIC_SUPERTYPE = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetElement> MISSING_CONSTRUCTOR_KEYWORD = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtElement> MISSING_CONSTRUCTOR_KEYWORD = DiagnosticFactory0.create(ERROR);
 
     // Secondary constructors
 
-    DiagnosticFactory0<JetConstructorDelegationReferenceExpression> CYCLIC_CONSTRUCTOR_DELEGATION_CALL = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtConstructorDelegationReferenceExpression> CYCLIC_CONSTRUCTOR_DELEGATION_CALL = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetDeclaration> CONSTRUCTOR_IN_OBJECT = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
-    DiagnosticFactory0<JetDelegatorToSuperCall> SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtDeclaration> CONSTRUCTOR_IN_OBJECT = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtDelegatorToSuperCall> SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetConstructorDelegationCall> PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED =
+    DiagnosticFactory0<KtConstructorDelegationCall> PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED =
             DiagnosticFactory0.create(ERROR, PositioningStrategies.SECONDARY_CONSTRUCTOR_DELEGATION_CALL);
 
-    DiagnosticFactory0<JetConstructorDelegationReferenceExpression> DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR =
+    DiagnosticFactory0<KtConstructorDelegationReferenceExpression> DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR =
             DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory0<PsiElement> PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetConstructorDelegationCall> EXPLICIT_DELEGATION_CALL_REQUIRED =
+    DiagnosticFactory0<KtConstructorDelegationCall> EXPLICIT_DELEGATION_CALL_REQUIRED =
             DiagnosticFactory0.create(ERROR, PositioningStrategies.SECONDARY_CONSTRUCTOR_DELEGATION_CALL);
 
     DiagnosticFactory1<PsiElement, DeclarationDescriptor> INSTANCE_ACCESS_BEFORE_SUPER_CALL = DiagnosticFactory1.create(ERROR);
 
     // Interface-specific
 
-    DiagnosticFactory0<JetModifierListOwner> ABSTRACT_MODIFIER_IN_INTERFACE = DiagnosticFactory0
+    DiagnosticFactory0<KtModifierListOwner> ABSTRACT_MODIFIER_IN_INTERFACE = DiagnosticFactory0
             .create(WARNING, ABSTRACT_MODIFIER);
 
-    DiagnosticFactory0<JetDeclaration> CONSTRUCTOR_IN_INTERFACE = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
-    DiagnosticFactory0<JetDeclaration> METHOD_OF_ANY_IMPLEMENTED_IN_INTERFACE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtDeclaration> CONSTRUCTOR_IN_INTERFACE = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtDeclaration> METHOD_OF_ANY_IMPLEMENTED_IN_INTERFACE = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory0<PsiElement> SUPERTYPE_INITIALIZED_IN_INTERFACE = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetDelegatorByExpressionSpecifier> DELEGATION_IN_INTERFACE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtDelegatorByExpressionSpecifier> DELEGATION_IN_INTERFACE = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory0<PsiElement> INTERFACE_WITH_SUPERCLASS = DiagnosticFactory0.create(ERROR);
 
     // Enum-specific
 
     DiagnosticFactory0<PsiElement> CLASS_IN_SUPERTYPE_FOR_ENUM = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetTypeParameterList> TYPE_PARAMETERS_IN_ENUM = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetClass> ENUM_ENTRY_SHOULD_BE_INITIALIZED = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetCallExpression> ENUM_CLASS_CONSTRUCTOR_CALL = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeParameterList> TYPE_PARAMETERS_IN_ENUM = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtClass> ENUM_ENTRY_SHOULD_BE_INITIALIZED = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtCallExpression> ENUM_CLASS_CONSTRUCTOR_CALL = DiagnosticFactory0.create(ERROR);
 
     // Sealed-specific
-    DiagnosticFactory0<JetCallExpression> SEALED_CLASS_CONSTRUCTOR_CALL = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetTypeReference> SEALED_SUPERTYPE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetTypeReference> SEALED_SUPERTYPE_IN_LOCAL_CLASS = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtCallExpression> SEALED_CLASS_CONSTRUCTOR_CALL = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeReference> SEALED_SUPERTYPE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeReference> SEALED_SUPERTYPE_IN_LOCAL_CLASS = DiagnosticFactory0.create(ERROR);
 
     // Companion objects
 
-    DiagnosticFactory0<JetObjectDeclaration> MANY_COMPANION_OBJECTS = DiagnosticFactory0.create(ERROR, COMPANION_OBJECT);
+    DiagnosticFactory0<KtObjectDeclaration> MANY_COMPANION_OBJECTS = DiagnosticFactory0.create(ERROR, COMPANION_OBJECT);
 
     DiagnosticFactory2<PsiElement, DeclarationDescriptor, String> DEPRECATION = DiagnosticFactory2.create(WARNING);
     DiagnosticFactory2<PsiElement, DeclarationDescriptor, String> DEPRECATION_ERROR = DiagnosticFactory2.create(ERROR);
 
     // Objects
 
-    DiagnosticFactory1<JetObjectDeclaration, ClassDescriptor> LOCAL_OBJECT_NOT_ALLOWED = DiagnosticFactory1.create(ERROR, DECLARATION_NAME);
-    DiagnosticFactory1<JetClass, ClassDescriptor> LOCAL_INTERFACE_NOT_ALLOWED = DiagnosticFactory1.create(ERROR, DECLARATION_NAME);
+    DiagnosticFactory1<KtObjectDeclaration, ClassDescriptor> LOCAL_OBJECT_NOT_ALLOWED = DiagnosticFactory1.create(ERROR, DECLARATION_NAME);
+    DiagnosticFactory1<KtClass, ClassDescriptor> LOCAL_INTERFACE_NOT_ALLOWED = DiagnosticFactory1.create(ERROR, DECLARATION_NAME);
 
     // Type parameter declarations
 
-    DiagnosticFactory1<JetTypeReference, JetType> FINAL_UPPER_BOUND = DiagnosticFactory1.create(WARNING);
-    DiagnosticFactory0<JetTypeReference> DYNAMIC_UPPER_BOUND = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory1<KtTypeReference, KtType> FINAL_UPPER_BOUND = DiagnosticFactory1.create(WARNING);
+    DiagnosticFactory0<KtTypeReference> DYNAMIC_UPPER_BOUND = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory1<JetNamedDeclaration, TypeParameterDescriptor> CONFLICTING_UPPER_BOUNDS =
+    DiagnosticFactory1<KtNamedDeclaration, TypeParameterDescriptor> CONFLICTING_UPPER_BOUNDS =
             DiagnosticFactory1.create(ERROR, DECLARATION_NAME);
 
-    DiagnosticFactory2<JetSimpleNameExpression, JetTypeConstraint, JetTypeParameterListOwner> NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER =
+    DiagnosticFactory2<KtSimpleNameExpression, KtTypeConstraint, KtTypeParameterListOwner> NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER =
             DiagnosticFactory2.create(ERROR);
 
-    DiagnosticFactory0<JetTypeParameter>
+    DiagnosticFactory0<KtTypeParameter>
             VARIANCE_ON_TYPE_PARAMETER_OF_FUNCTION_OR_PROPERTY = DiagnosticFactory0.create(ERROR, VARIANCE_MODIFIER);
 
-    DiagnosticFactory0<JetTypeParameterList> DEPRECATED_TYPE_PARAMETER_SYNTAX = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory0<KtTypeParameterList> DEPRECATED_TYPE_PARAMETER_SYNTAX = DiagnosticFactory0.create(WARNING);
 
     DiagnosticFactory0<PsiElement> REIFIED_TYPE_PARAMETER_NO_INLINE = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetDeclaration> TYPE_PARAMETERS_NOT_ALLOWED
+    DiagnosticFactory0<KtDeclaration> TYPE_PARAMETERS_NOT_ALLOWED
             = DiagnosticFactory0.create(ERROR, TYPE_PARAMETERS_OR_DECLARATION_SIGNATURE);
 
-    DiagnosticFactory0<JetTypeParameter> TYPE_PARAMETER_OF_PROPERTY_NOT_USED_IN_RECEIVER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeParameter> TYPE_PARAMETER_OF_PROPERTY_NOT_USED_IN_RECEIVER = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory0<PsiElement> CYCLIC_GENERIC_UPPER_BOUND = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetTypeParameter> MISPLACED_TYPE_PARAMETER_CONSTRAINTS = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory0<KtTypeParameter> MISPLACED_TYPE_PARAMETER_CONSTRAINTS = DiagnosticFactory0.create(WARNING);
 
     // Members
 
-    DiagnosticFactory2<JetDeclaration, CallableMemberDescriptor, String> CONFLICTING_OVERLOADS =
+    DiagnosticFactory2<KtDeclaration, CallableMemberDescriptor, String> CONFLICTING_OVERLOADS =
             DiagnosticFactory2.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
 
-    DiagnosticFactory0<JetNamedDeclaration> NON_FINAL_MEMBER_IN_FINAL_CLASS = DiagnosticFactory0.create(WARNING, modifierSetPosition(
-            JetTokens.OPEN_KEYWORD));
+    DiagnosticFactory0<KtNamedDeclaration> NON_FINAL_MEMBER_IN_FINAL_CLASS = DiagnosticFactory0.create(WARNING, modifierSetPosition(
+            KtTokens.OPEN_KEYWORD));
 
-    DiagnosticFactory1<JetModifierListOwner, CallableMemberDescriptor> NOTHING_TO_OVERRIDE = DiagnosticFactory1.create(ERROR, OVERRIDE_MODIFIER);
+    DiagnosticFactory1<KtModifierListOwner, CallableMemberDescriptor> NOTHING_TO_OVERRIDE = DiagnosticFactory1.create(ERROR, OVERRIDE_MODIFIER);
 
-    DiagnosticFactory3<JetNamedDeclaration, CallableMemberDescriptor, CallableMemberDescriptor, DeclarationDescriptor> VIRTUAL_MEMBER_HIDDEN =
+    DiagnosticFactory3<KtNamedDeclaration, CallableMemberDescriptor, CallableMemberDescriptor, DeclarationDescriptor> VIRTUAL_MEMBER_HIDDEN =
             DiagnosticFactory3.create(ERROR, DECLARATION_SIGNATURE);
 
-    DiagnosticFactory2<JetModifierListOwner, CallableMemberDescriptor, CallableDescriptor> CANNOT_OVERRIDE_INVISIBLE_MEMBER =
+    DiagnosticFactory2<KtModifierListOwner, CallableMemberDescriptor, CallableDescriptor> CANNOT_OVERRIDE_INVISIBLE_MEMBER =
             DiagnosticFactory2.create(ERROR, OVERRIDE_MODIFIER);
 
     DiagnosticFactory2<PsiElement, CallableMemberDescriptor, DeclarationDescriptor> DATA_CLASS_OVERRIDE_CONFLICT =
             DiagnosticFactory2.create(ERROR);
 
-    DiagnosticFactory1<JetDeclaration, CallableMemberDescriptor> CANNOT_INFER_VISIBILITY =
+    DiagnosticFactory1<KtDeclaration, CallableMemberDescriptor> CANNOT_INFER_VISIBILITY =
             DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
 
-    DiagnosticFactory2<JetNamedDeclaration, CallableMemberDescriptor, DeclarationDescriptor> OVERRIDING_FINAL_MEMBER =
+    DiagnosticFactory2<KtNamedDeclaration, CallableMemberDescriptor, DeclarationDescriptor> OVERRIDING_FINAL_MEMBER =
             DiagnosticFactory2.create(ERROR, OVERRIDE_MODIFIER);
 
-    DiagnosticFactory3<JetModifierListOwner, Visibility, CallableMemberDescriptor, DeclarationDescriptor> CANNOT_WEAKEN_ACCESS_PRIVILEGE =
+    DiagnosticFactory3<KtModifierListOwner, Visibility, CallableMemberDescriptor, DeclarationDescriptor> CANNOT_WEAKEN_ACCESS_PRIVILEGE =
             DiagnosticFactory3.create(ERROR, VISIBILITY_MODIFIER);
-    DiagnosticFactory3<JetModifierListOwner, Visibility, CallableMemberDescriptor, DeclarationDescriptor> CANNOT_CHANGE_ACCESS_PRIVILEGE =
+    DiagnosticFactory3<KtModifierListOwner, Visibility, CallableMemberDescriptor, DeclarationDescriptor> CANNOT_CHANGE_ACCESS_PRIVILEGE =
             DiagnosticFactory3.create(ERROR, VISIBILITY_MODIFIER);
-    DiagnosticFactory2<JetNamedDeclaration, CallableMemberDescriptor, CallableMemberDescriptor> RETURN_TYPE_MISMATCH_ON_OVERRIDE =
+    DiagnosticFactory2<KtNamedDeclaration, CallableMemberDescriptor, CallableMemberDescriptor> RETURN_TYPE_MISMATCH_ON_OVERRIDE =
             DiagnosticFactory2.create(ERROR, DECLARATION_RETURN_TYPE);
-    DiagnosticFactory2<JetNamedDeclaration, CallableMemberDescriptor, CallableMemberDescriptor> PROPERTY_TYPE_MISMATCH_ON_OVERRIDE =
+    DiagnosticFactory2<KtNamedDeclaration, CallableMemberDescriptor, CallableMemberDescriptor> PROPERTY_TYPE_MISMATCH_ON_OVERRIDE =
             DiagnosticFactory2.create(ERROR, DECLARATION_RETURN_TYPE);
 
-    DiagnosticFactory2<JetClassOrObject, JetClassOrObject, CallableMemberDescriptor> ABSTRACT_MEMBER_NOT_IMPLEMENTED =
+    DiagnosticFactory2<KtClassOrObject, KtClassOrObject, CallableMemberDescriptor> ABSTRACT_MEMBER_NOT_IMPLEMENTED =
             DiagnosticFactory2.create(ERROR, DECLARATION_NAME);
-    DiagnosticFactory2<JetClassOrObject, JetClassOrObject, CallableMemberDescriptor> ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED =
+    DiagnosticFactory2<KtClassOrObject, KtClassOrObject, CallableMemberDescriptor> ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED =
             DiagnosticFactory2.create(ERROR, DECLARATION_NAME);
-    DiagnosticFactory2<JetClassOrObject, JetClassOrObject, CallableMemberDescriptor> MANY_IMPL_MEMBER_NOT_IMPLEMENTED =
+    DiagnosticFactory2<KtClassOrObject, KtClassOrObject, CallableMemberDescriptor> MANY_IMPL_MEMBER_NOT_IMPLEMENTED =
             DiagnosticFactory2.create(ERROR, DECLARATION_NAME);
-    DiagnosticFactory2<JetClassOrObject, JetClassOrObject, CallableMemberDescriptor> MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED =
+    DiagnosticFactory2<KtClassOrObject, KtClassOrObject, CallableMemberDescriptor> MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED =
             DiagnosticFactory2.create(ERROR, DECLARATION_NAME);
 
 
-    DiagnosticFactory1<JetNamedDeclaration, Collection<JetType>> AMBIGUOUS_ANONYMOUS_TYPE_INFERRED =
+    DiagnosticFactory1<KtNamedDeclaration, Collection<KtType>> AMBIGUOUS_ANONYMOUS_TYPE_INFERRED =
             DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE);
 
     // Property-specific
 
-    DiagnosticFactory2<JetNamedDeclaration, PropertyDescriptor, PropertyDescriptor> VAR_OVERRIDDEN_BY_VAL =
+    DiagnosticFactory2<KtNamedDeclaration, PropertyDescriptor, PropertyDescriptor> VAR_OVERRIDDEN_BY_VAL =
             DiagnosticFactory2.create(ERROR, VAL_OR_VAR_NODE);
 
     DiagnosticFactory0<PsiElement> REDUNDANT_MODIFIER_IN_GETTER = DiagnosticFactory0.create(WARNING);
     DiagnosticFactory0<PsiElement> GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<PsiElement> PRIVATE_SETTER_ON_NON_PRIVATE_LATE_INIT_VAR = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<PsiElement> ACCESSOR_VISIBILITY_FOR_ABSTRACT_PROPERTY = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory2<JetTypeReference, JetType, JetType> WRONG_GETTER_RETURN_TYPE = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory2<KtTypeReference, KtType, KtType> WRONG_GETTER_RETURN_TYPE = DiagnosticFactory2.create(ERROR);
 
-    DiagnosticFactory0<JetModifierListOwner>
+    DiagnosticFactory0<KtModifierListOwner>
             ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS = DiagnosticFactory0.create(ERROR, ABSTRACT_MODIFIER);
-    DiagnosticFactory0<JetExpression> ABSTRACT_PROPERTY_WITH_INITIALIZER = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetPropertyAccessor> ABSTRACT_PROPERTY_WITH_GETTER = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetPropertyAccessor> ABSTRACT_PROPERTY_WITH_SETTER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> ABSTRACT_PROPERTY_WITH_INITIALIZER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtPropertyAccessor> ABSTRACT_PROPERTY_WITH_GETTER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtPropertyAccessor> ABSTRACT_PROPERTY_WITH_SETTER = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetPropertyDelegate> ABSTRACT_DELEGATED_PROPERTY = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetPropertyAccessor> ACCESSOR_FOR_DELEGATED_PROPERTY = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetPropertyDelegate> DELEGATED_PROPERTY_IN_INTERFACE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetPropertyDelegate> LOCAL_VARIABLE_WITH_DELEGATE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtPropertyDelegate> ABSTRACT_DELEGATED_PROPERTY = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtPropertyAccessor> ACCESSOR_FOR_DELEGATED_PROPERTY = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtPropertyDelegate> DELEGATED_PROPERTY_IN_INTERFACE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtPropertyDelegate> LOCAL_VARIABLE_WITH_DELEGATE = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetProperty> PROPERTY_WITH_NO_TYPE_NO_INITIALIZER = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtProperty> PROPERTY_WITH_NO_TYPE_NO_INITIALIZER = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
 
-    DiagnosticFactory0<JetProperty> MUST_BE_INITIALIZED = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
-    DiagnosticFactory0<JetProperty> MUST_BE_INITIALIZED_OR_BE_ABSTRACT = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtProperty> MUST_BE_INITIALIZED = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtProperty> MUST_BE_INITIALIZED_OR_BE_ABSTRACT = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
 
-    DiagnosticFactory0<JetExpression> EXTENSION_PROPERTY_WITH_BACKING_FIELD = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetExpression> PROPERTY_INITIALIZER_NO_BACKING_FIELD = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetExpression> PROPERTY_INITIALIZER_IN_INTERFACE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetProperty> FINAL_PROPERTY_IN_INTERFACE = DiagnosticFactory0.create(ERROR, FINAL_MODIFIER);
-    DiagnosticFactory0<JetProperty> PRIVATE_PROPERTY_IN_INTERFACE = DiagnosticFactory0.create(ERROR, PRIVATE_MODIFIER);
-    DiagnosticFactory0<JetProperty> BACKING_FIELD_IN_INTERFACE = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtExpression> EXTENSION_PROPERTY_WITH_BACKING_FIELD = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> PROPERTY_INITIALIZER_NO_BACKING_FIELD = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> PROPERTY_INITIALIZER_IN_INTERFACE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtProperty> FINAL_PROPERTY_IN_INTERFACE = DiagnosticFactory0.create(ERROR, FINAL_MODIFIER);
+    DiagnosticFactory0<KtProperty> PRIVATE_PROPERTY_IN_INTERFACE = DiagnosticFactory0.create(ERROR, PRIVATE_MODIFIER);
+    DiagnosticFactory0<KtProperty> BACKING_FIELD_IN_INTERFACE = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
 
-    DiagnosticFactory0<JetSimpleNameExpression> BACKING_FIELD_OLD_SYNTAX = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetSimpleNameExpression> BACKING_FIELD_USAGE_FORBIDDEN = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtSimpleNameExpression> BACKING_FIELD_OLD_SYNTAX = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtSimpleNameExpression> BACKING_FIELD_USAGE_FORBIDDEN = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory1<PsiElement, String> INAPPLICABLE_LATEINIT_MODIFIER = DiagnosticFactory1.create(ERROR);
 
-    DiagnosticFactory2<JetModifierListOwner, String, ClassDescriptor> ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS = DiagnosticFactory2.create(ERROR, ABSTRACT_MODIFIER);
+    DiagnosticFactory2<KtModifierListOwner, String, ClassDescriptor> ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS = DiagnosticFactory2.create(ERROR, ABSTRACT_MODIFIER);
 
-    DiagnosticFactory0<JetPropertyAccessor> VAL_WITH_SETTER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtPropertyAccessor> VAL_WITH_SETTER = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetExpression> SETTER_PARAMETER_WITH_DEFAULT_VALUE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> SETTER_PARAMETER_WITH_DEFAULT_VALUE = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory2<JetTypeReference, JetType, JetType> WRONG_SETTER_PARAMETER_TYPE = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory2<KtTypeReference, KtType, KtType> WRONG_SETTER_PARAMETER_TYPE = DiagnosticFactory2.create(ERROR);
 
     // Function-specific
 
-    DiagnosticFactory2<JetFunction, String, ClassDescriptor> ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS = DiagnosticFactory2.create(ERROR, ABSTRACT_MODIFIER);
+    DiagnosticFactory2<KtFunction, String, ClassDescriptor> ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS = DiagnosticFactory2.create(ERROR, ABSTRACT_MODIFIER);
 
-    DiagnosticFactory1<JetFunction, SimpleFunctionDescriptor> ABSTRACT_FUNCTION_WITH_BODY = DiagnosticFactory1.create(ERROR, ABSTRACT_MODIFIER);
-    DiagnosticFactory1<JetFunction, SimpleFunctionDescriptor> NON_ABSTRACT_FUNCTION_WITH_NO_BODY =
+    DiagnosticFactory1<KtFunction, SimpleFunctionDescriptor> ABSTRACT_FUNCTION_WITH_BODY = DiagnosticFactory1.create(ERROR, ABSTRACT_MODIFIER);
+    DiagnosticFactory1<KtFunction, SimpleFunctionDescriptor> NON_ABSTRACT_FUNCTION_WITH_NO_BODY =
             DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE);
-    DiagnosticFactory1<JetFunction, SimpleFunctionDescriptor> FINAL_FUNCTION_WITH_NO_BODY = DiagnosticFactory1.create(ERROR, FINAL_MODIFIER);
-    DiagnosticFactory1<JetFunction, SimpleFunctionDescriptor> PRIVATE_FUNCTION_WITH_NO_BODY = DiagnosticFactory1.create(ERROR, PRIVATE_MODIFIER);
+    DiagnosticFactory1<KtFunction, SimpleFunctionDescriptor> FINAL_FUNCTION_WITH_NO_BODY = DiagnosticFactory1.create(ERROR, FINAL_MODIFIER);
+    DiagnosticFactory1<KtFunction, SimpleFunctionDescriptor> PRIVATE_FUNCTION_WITH_NO_BODY = DiagnosticFactory1.create(ERROR, PRIVATE_MODIFIER);
 
-    DiagnosticFactory1<JetFunction, SimpleFunctionDescriptor> NON_MEMBER_FUNCTION_NO_BODY =
+    DiagnosticFactory1<KtFunction, SimpleFunctionDescriptor> NON_MEMBER_FUNCTION_NO_BODY =
             DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE);
 
-    DiagnosticFactory0<JetFunction> FUNCTION_DECLARATION_WITH_NO_NAME = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtFunction> FUNCTION_DECLARATION_WITH_NO_NAME = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
     DiagnosticFactory0<PsiElement>  FUNCTION_EXPRESSION_WITH_NAME     = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetParameter> VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtParameter> VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetNamedFunction> NO_TAIL_CALLS_FOUND = DiagnosticFactory0.create(WARNING, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtNamedFunction> NO_TAIL_CALLS_FOUND = DiagnosticFactory0.create(WARNING, DECLARATION_SIGNATURE);
 
-    DiagnosticFactory0<JetParameter> FUNCTION_EXPRESSION_PARAMETER_WITH_DEFAULT_VALUE = DiagnosticFactory0.create(ERROR, PARAMETER_DEFAULT_VALUE);
+    DiagnosticFactory0<KtParameter> FUNCTION_EXPRESSION_PARAMETER_WITH_DEFAULT_VALUE = DiagnosticFactory0.create(ERROR, PARAMETER_DEFAULT_VALUE);
 
-    DiagnosticFactory0<JetParameter> USELESS_VARARG_ON_PARAMETER = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory0<KtParameter> USELESS_VARARG_ON_PARAMETER = DiagnosticFactory0.create(WARNING);
 
     // Named parameters
 
-    DiagnosticFactory0<JetParameter> DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE = DiagnosticFactory0.create(ERROR, PARAMETER_DEFAULT_VALUE);
+    DiagnosticFactory0<KtParameter> DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE = DiagnosticFactory0.create(ERROR, PARAMETER_DEFAULT_VALUE);
 
-    DiagnosticFactory1<JetParameter, ValueParameterDescriptor> MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtParameter, ValueParameterDescriptor> MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES = DiagnosticFactory1.create(ERROR);
 
-    DiagnosticFactory1<JetClassOrObject, ValueParameterDescriptor> MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE =
+    DiagnosticFactory1<KtClassOrObject, ValueParameterDescriptor> MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE =
             DiagnosticFactory1.create(ERROR, DECLARATION_NAME);
 
-    DiagnosticFactory2<JetParameter, ClassDescriptor, ValueParameterDescriptor> PARAMETER_NAME_CHANGED_ON_OVERRIDE =
+    DiagnosticFactory2<KtParameter, ClassDescriptor, ValueParameterDescriptor> PARAMETER_NAME_CHANGED_ON_OVERRIDE =
             DiagnosticFactory2.create(WARNING, DECLARATION_NAME);
 
-    DiagnosticFactory2<JetClassOrObject, Collection<? extends CallableMemberDescriptor>, Integer> DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES =
+    DiagnosticFactory2<KtClassOrObject, Collection<? extends CallableMemberDescriptor>, Integer> DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES =
             DiagnosticFactory2.create(WARNING, DECLARATION_NAME);
 
-    DiagnosticFactory0<JetReferenceExpression> NAME_FOR_AMBIGUOUS_PARAMETER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtReferenceExpression> NAME_FOR_AMBIGUOUS_PARAMETER = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory0<PsiElement> DATA_CLASS_WITHOUT_PARAMETERS = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetParameter> DATA_CLASS_VARARG_PARAMETER = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetParameter> DATA_CLASS_NOT_PROPERTY_PARAMETER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtParameter> DATA_CLASS_VARARG_PARAMETER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtParameter> DATA_CLASS_NOT_PROPERTY_PARAMETER = DiagnosticFactory0.create(ERROR);
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -426,13 +426,13 @@ public interface Errors {
     DiagnosticFactory1<PsiElement, String> NAME_SHADOWING = DiagnosticFactory1.create(WARNING, PositioningStrategies.FOR_REDECLARATION);
     DiagnosticFactory0<PsiElement> ACCESSOR_PARAMETER_NAME_SHADOWING = DiagnosticFactory0.create(WARNING);
 
-    DiagnosticFactory0<JetExpression> TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM = DiagnosticFactory0.create(ERROR);
 
     // Checking call arguments
 
     DiagnosticFactory0<PsiElement> MIXING_NAMED_AND_POSITIONED_ARGUMENTS = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetReferenceExpression> ARGUMENT_PASSED_TWICE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory1<JetReferenceExpression, JetReferenceExpression> NAMED_PARAMETER_NOT_FOUND =
+    DiagnosticFactory0<KtReferenceExpression> ARGUMENT_PASSED_TWICE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory1<KtReferenceExpression, KtReferenceExpression> NAMED_PARAMETER_NOT_FOUND =
             DiagnosticFactory1.create(ERROR, FOR_UNRESOLVED_REFERENCE);
     DiagnosticFactory1<PsiElement, BadNamedArgumentsTarget> NAMED_ARGUMENTS_NOT_ALLOWED = DiagnosticFactory1.create(ERROR);
 
@@ -441,46 +441,46 @@ public interface Errors {
         INVOKE_ON_FUNCTION_TYPE
     }
 
-    DiagnosticFactory0<JetExpression> VARARG_OUTSIDE_PARENTHESES = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> VARARG_OUTSIDE_PARENTHESES = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<LeafPsiElement> NON_VARARG_SPREAD = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetExpression> MANY_FUNCTION_LITERAL_ARGUMENTS = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> MANY_FUNCTION_LITERAL_ARGUMENTS = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory1<PsiElement, CallableDescriptor> TOO_MANY_ARGUMENTS = DiagnosticFactory1.create(ERROR);
 
-    DiagnosticFactory1<JetElement, ValueParameterDescriptor> NO_VALUE_FOR_PARAMETER = DiagnosticFactory1.create(ERROR, VALUE_ARGUMENTS);
+    DiagnosticFactory1<KtElement, ValueParameterDescriptor> NO_VALUE_FOR_PARAMETER = DiagnosticFactory1.create(ERROR, VALUE_ARGUMENTS);
 
-    DiagnosticFactory1<JetExpression, JetType> MISSING_RECEIVER = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory0<JetExpression> NO_RECEIVER_ALLOWED = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory1<KtExpression, KtType> MISSING_RECEIVER = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory0<KtExpression> NO_RECEIVER_ALLOWED = DiagnosticFactory0.create(ERROR);
 
     // Call resolution
 
-    DiagnosticFactory1<JetExpression, String> ILLEGAL_SELECTOR = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtExpression, String> ILLEGAL_SELECTOR = DiagnosticFactory1.create(ERROR);
 
     DiagnosticFactory0<PsiElement> SAFE_CALL_IN_QUALIFIER = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory2<JetExpression, JetExpression, JetType> FUNCTION_EXPECTED = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory2<JetExpression, JetExpression, Boolean> FUNCTION_CALL_EXPECTED = DiagnosticFactory2.create(ERROR, CALL_EXPRESSION);
+    DiagnosticFactory2<KtExpression, KtExpression, KtType> FUNCTION_EXPECTED = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory2<KtExpression, KtExpression, Boolean> FUNCTION_CALL_EXPECTED = DiagnosticFactory2.create(ERROR, CALL_EXPRESSION);
 
     DiagnosticFactory0<PsiElement> NON_TAIL_RECURSIVE_CALL = DiagnosticFactory0.create(WARNING, CALL_EXPRESSION);
     DiagnosticFactory0<PsiElement> TAIL_RECURSION_IN_TRY_IS_NOT_SUPPORTED = DiagnosticFactory0.create(WARNING, CALL_EXPRESSION);
 
     DiagnosticFactory0<PsiElement> NO_CONSTRUCTOR = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<PsiElement> CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetExpression> NOT_A_CLASS = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> NOT_A_CLASS = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory1<PsiElement, Collection<? extends ResolvedCall<?>>> OVERLOAD_RESOLUTION_AMBIGUITY = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory1<PsiElement, Collection<? extends ResolvedCall<?>>> NONE_APPLICABLE = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory1<PsiElement, Collection<? extends ResolvedCall<?>>> CANNOT_COMPLETE_RESOLVE = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory1<PsiElement, Collection<? extends ResolvedCall<?>>> UNRESOLVED_REFERENCE_WRONG_RECEIVER = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<PsiElement, JetExpression> INVOKE_EXTENSION_ON_NOT_EXTENSION_FUNCTION = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<PsiElement, KtExpression> INVOKE_EXTENSION_ON_NOT_EXTENSION_FUNCTION = DiagnosticFactory1.create(ERROR);
 
     DiagnosticFactory1<PsiElement, TypeParameterDescriptor> TYPE_PARAMETER_AS_REIFIED = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<PsiElement, JetType> REIFIED_TYPE_FORBIDDEN_SUBSTITUTION = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<PsiElement, KtType> REIFIED_TYPE_FORBIDDEN_SUBSTITUTION = DiagnosticFactory1.create(ERROR);
 
     // Type inference
 
-    DiagnosticFactory0<JetParameter> CANNOT_INFER_PARAMETER_TYPE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtParameter> CANNOT_INFER_PARAMETER_TYPE = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory1<PsiElement, InferenceErrorData> TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory1<PsiElement, InferenceErrorData> TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS = DiagnosticFactory1.create(ERROR);
@@ -489,74 +489,74 @@ public interface Errors {
     DiagnosticFactory0<PsiElement> TYPE_INFERENCE_INCORPORATION_ERROR = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory1<PsiElement, TypeParameterDescriptor> TYPE_INFERENCE_ONLY_INPUT_TYPES = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory1<PsiElement, InferenceErrorData> TYPE_INFERENCE_UPPER_BOUND_VIOLATED = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory2<JetElement, JetType, JetType> TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory2<KtElement, KtType, KtType> TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH = DiagnosticFactory2.create(ERROR);
 
     // Reflection
 
-    DiagnosticFactory1<JetExpression, CallableMemberDescriptor> EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory0<JetExpression> CALLABLE_REFERENCE_LHS_NOT_A_CLASS = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetExpression> CALLABLE_REFERENCE_TO_MEMBER_OR_EXTENSION_WITH_EMPTY_LHS = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetExpression> CALLABLE_REFERENCE_TO_OBJECT_MEMBER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory1<KtExpression, CallableMemberDescriptor> EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory0<KtExpression> CALLABLE_REFERENCE_LHS_NOT_A_CLASS = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> CALLABLE_REFERENCE_TO_MEMBER_OR_EXTENSION_WITH_EMPTY_LHS = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> CALLABLE_REFERENCE_TO_OBJECT_MEMBER = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetExpression> CLASS_LITERAL_LHS_NOT_A_CLASS = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetExpression> ARRAY_CLASS_LITERAL_REQUIRES_ARGUMENT = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> CLASS_LITERAL_LHS_NOT_A_CLASS = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> ARRAY_CLASS_LITERAL_REQUIRES_ARGUMENT = DiagnosticFactory0.create(ERROR);
 
     // Multi-declarations
 
-    DiagnosticFactory0<JetMultiDeclaration> INITIALIZER_REQUIRED_FOR_MULTIDECLARATION = DiagnosticFactory0.create(ERROR, DEFAULT);
-    DiagnosticFactory2<JetExpression, Name, JetType> COMPONENT_FUNCTION_MISSING = DiagnosticFactory2.create(ERROR, DEFAULT);
-    DiagnosticFactory2<JetExpression, Name, Collection<? extends ResolvedCall<?>>> COMPONENT_FUNCTION_AMBIGUITY = DiagnosticFactory2.create(ERROR, DEFAULT);
-    DiagnosticFactory3<JetExpression, Name, JetType, JetType> COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH = DiagnosticFactory3.create(ERROR, DEFAULT);
+    DiagnosticFactory0<KtMultiDeclaration> INITIALIZER_REQUIRED_FOR_MULTIDECLARATION = DiagnosticFactory0.create(ERROR, DEFAULT);
+    DiagnosticFactory2<KtExpression, Name, KtType> COMPONENT_FUNCTION_MISSING = DiagnosticFactory2.create(ERROR, DEFAULT);
+    DiagnosticFactory2<KtExpression, Name, Collection<? extends ResolvedCall<?>>> COMPONENT_FUNCTION_AMBIGUITY = DiagnosticFactory2.create(ERROR, DEFAULT);
+    DiagnosticFactory3<KtExpression, Name, KtType, KtType> COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH = DiagnosticFactory3.create(ERROR, DEFAULT);
 
     // Super calls
 
-    DiagnosticFactory1<JetSuperExpression, String> SUPER_IS_NOT_AN_EXPRESSION = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetSuperExpression, String> SUPER_CANT_BE_EXTENSION_RECEIVER = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory0<JetSuperExpression> SUPER_NOT_AVAILABLE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetSuperExpression> SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetSuperExpression> AMBIGUOUS_SUPER = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetExpression> ABSTRACT_SUPER_CALL = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetTypeReference> NOT_A_SUPERTYPE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory1<KtSuperExpression, String> SUPER_IS_NOT_AN_EXPRESSION = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtSuperExpression, String> SUPER_CANT_BE_EXTENSION_RECEIVER = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory0<KtSuperExpression> SUPER_NOT_AVAILABLE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtSuperExpression> SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtSuperExpression> AMBIGUOUS_SUPER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> ABSTRACT_SUPER_CALL = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeReference> NOT_A_SUPERTYPE = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<PsiElement> TYPE_ARGUMENTS_REDUNDANT_IN_SUPER_QUALIFIER = DiagnosticFactory0.create(WARNING);
 
     // Conventions
 
-    DiagnosticFactory0<JetArrayAccessExpression> NO_GET_METHOD = DiagnosticFactory0.create(ERROR, ARRAY_ACCESS);
-    DiagnosticFactory0<JetArrayAccessExpression> NO_SET_METHOD = DiagnosticFactory0.create(ERROR, ARRAY_ACCESS);
+    DiagnosticFactory0<KtArrayAccessExpression> NO_GET_METHOD = DiagnosticFactory0.create(ERROR, ARRAY_ACCESS);
+    DiagnosticFactory0<KtArrayAccessExpression> NO_SET_METHOD = DiagnosticFactory0.create(ERROR, ARRAY_ACCESS);
 
-    DiagnosticFactory2<JetUnaryExpression, FunctionDescriptor, String> DEPRECATED_UNARY_PLUS_MINUS = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<KtUnaryExpression, FunctionDescriptor, String> DEPRECATED_UNARY_PLUS_MINUS = DiagnosticFactory2.create(WARNING);
 
-    DiagnosticFactory0<JetSimpleNameExpression> INC_DEC_SHOULD_NOT_RETURN_UNIT = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory2<JetSimpleNameExpression, DeclarationDescriptor, JetSimpleNameExpression> ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT =
+    DiagnosticFactory0<KtSimpleNameExpression> INC_DEC_SHOULD_NOT_RETURN_UNIT = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory2<KtSimpleNameExpression, DeclarationDescriptor, KtSimpleNameExpression> ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT =
             DiagnosticFactory2.create(ERROR);
     DiagnosticFactory1<PsiElement, Collection<? extends ResolvedCall<?>>>
             ASSIGN_OPERATOR_AMBIGUITY = DiagnosticFactory1.create(ERROR);
 
-    DiagnosticFactory0<JetSimpleNameExpression> EQUALS_MISSING = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory3<JetBinaryExpression, JetSimpleNameExpression, JetType, JetType> EQUALITY_NOT_APPLICABLE =
+    DiagnosticFactory0<KtSimpleNameExpression> EQUALS_MISSING = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory3<KtBinaryExpression, KtSimpleNameExpression, KtType, KtType> EQUALITY_NOT_APPLICABLE =
             DiagnosticFactory3.create(ERROR);
 
 
-    DiagnosticFactory1<JetExpression, JetType> HAS_NEXT_MISSING = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetExpression, JetType> HAS_NEXT_FUNCTION_AMBIGUITY = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetExpression, JetType> HAS_NEXT_FUNCTION_NONE_APPLICABLE = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetExpression, JetType> HAS_NEXT_FUNCTION_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtExpression, KtType> HAS_NEXT_MISSING = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtExpression, KtType> HAS_NEXT_FUNCTION_AMBIGUITY = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtExpression, KtType> HAS_NEXT_FUNCTION_NONE_APPLICABLE = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtExpression, KtType> HAS_NEXT_FUNCTION_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR);
 
-    DiagnosticFactory1<JetExpression, JetType> NEXT_AMBIGUITY = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetExpression, JetType> NEXT_MISSING = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetExpression, JetType> NEXT_NONE_APPLICABLE = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtExpression, KtType> NEXT_AMBIGUITY = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtExpression, KtType> NEXT_MISSING = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtExpression, KtType> NEXT_NONE_APPLICABLE = DiagnosticFactory1.create(ERROR);
 
-    DiagnosticFactory0<JetExpression> ITERATOR_MISSING = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> ITERATOR_MISSING = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory1<PsiElement, Collection<? extends ResolvedCall<?>>> ITERATOR_AMBIGUITY = DiagnosticFactory1.create(ERROR);
 
-    DiagnosticFactory2<JetExpression, String, JetType> DELEGATE_SPECIAL_FUNCTION_MISSING = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory3<PsiElement, FunctionDescriptor, JetType, String> DELEGATE_RESOLVED_TO_DEPRECATED_CONVENTION = DiagnosticFactory3.create(WARNING);
-    DiagnosticFactory2<JetExpression, String, Collection<? extends ResolvedCall<?>>> DELEGATE_SPECIAL_FUNCTION_AMBIGUITY = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory2<JetExpression, String, Collection<? extends ResolvedCall<?>>> DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory3<JetExpression, String, JetType, JetType> DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH = DiagnosticFactory3.create(ERROR);
-    DiagnosticFactory2<JetExpression, String, Collection<? extends ResolvedCall<?>>> DELEGATE_PD_METHOD_NONE_APPLICABLE = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<KtExpression, String, KtType> DELEGATE_SPECIAL_FUNCTION_MISSING = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory3<PsiElement, FunctionDescriptor, KtType, String> DELEGATE_RESOLVED_TO_DEPRECATED_CONVENTION = DiagnosticFactory3.create(WARNING);
+    DiagnosticFactory2<KtExpression, String, Collection<? extends ResolvedCall<?>>> DELEGATE_SPECIAL_FUNCTION_AMBIGUITY = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory2<KtExpression, String, Collection<? extends ResolvedCall<?>>> DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory3<KtExpression, String, KtType, KtType> DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH = DiagnosticFactory3.create(ERROR);
+    DiagnosticFactory2<KtExpression, String, Collection<? extends ResolvedCall<?>>> DELEGATE_PD_METHOD_NONE_APPLICABLE = DiagnosticFactory2.create(WARNING);
 
-    DiagnosticFactory1<JetSimpleNameExpression, JetType> COMPARE_TO_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtSimpleNameExpression, KtType> COMPARE_TO_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR);
 
     DiagnosticFactory0<PsiElement> UNDERSCORE_IS_RESERVED = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory1<PsiElement, String> INVALID_CHARACTERS = DiagnosticFactory1.create(ERROR);
@@ -565,177 +565,177 @@ public interface Errors {
     DiagnosticFactory0<PsiElement> INAPPLICABLE_INFIX_MODIFIER = DiagnosticFactory0.create(WARNING);
 
     DiagnosticFactory2<PsiElement, FunctionDescriptor, String> OPERATOR_MODIFIER_REQUIRED = DiagnosticFactory2.create(WARNING);
-    DiagnosticFactory2<JetOperationReferenceExpression, FunctionDescriptor, String> INFIX_MODIFIER_REQUIRED = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<KtOperationReferenceExpression, FunctionDescriptor, String> INFIX_MODIFIER_REQUIRED = DiagnosticFactory2.create(WARNING);
 
     // Labels
 
-    DiagnosticFactory0<JetSimpleNameExpression> LABEL_NAME_CLASH = DiagnosticFactory0.create(WARNING);
-    DiagnosticFactory0<JetSimpleNameExpression> AMBIGUOUS_LABEL = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtSimpleNameExpression> LABEL_NAME_CLASH = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory0<KtSimpleNameExpression> AMBIGUOUS_LABEL = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetExpressionWithLabel> BREAK_OR_CONTINUE_OUTSIDE_A_LOOP = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetExpressionWithLabel> BREAK_OR_CONTINUE_IN_WHEN = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetExpressionWithLabel> BREAK_OR_CONTINUE_JUMPS_ACROSS_FUNCTION_BOUNDARY = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory1<JetExpressionWithLabel, String> NOT_A_LOOP_LABEL = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetReturnExpression, String> NOT_A_RETURN_LABEL = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory0<KtExpressionWithLabel> BREAK_OR_CONTINUE_OUTSIDE_A_LOOP = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpressionWithLabel> BREAK_OR_CONTINUE_IN_WHEN = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpressionWithLabel> BREAK_OR_CONTINUE_JUMPS_ACROSS_FUNCTION_BOUNDARY = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory1<KtExpressionWithLabel, String> NOT_A_LOOP_LABEL = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtReturnExpression, String> NOT_A_RETURN_LABEL = DiagnosticFactory1.create(ERROR);
 
     // Control flow / Data flow
 
-    DiagnosticFactory1<JetElement, List<TextRange>> UNREACHABLE_CODE = DiagnosticFactory1.create(
+    DiagnosticFactory1<KtElement, List<TextRange>> UNREACHABLE_CODE = DiagnosticFactory1.create(
             WARNING, PositioningStrategies.UNREACHABLE_CODE);
 
-    DiagnosticFactory0<JetVariableDeclaration> VARIABLE_WITH_NO_TYPE_NO_INITIALIZER = DiagnosticFactory0.create(ERROR, DECLARATION_NAME);
+    DiagnosticFactory0<KtVariableDeclaration> VARIABLE_WITH_NO_TYPE_NO_INITIALIZER = DiagnosticFactory0.create(ERROR, DECLARATION_NAME);
 
-    DiagnosticFactory1<JetSimpleNameExpression, VariableDescriptor> UNINITIALIZED_VARIABLE = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetSimpleNameExpression, ValueParameterDescriptor> UNINITIALIZED_PARAMETER = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtSimpleNameExpression, VariableDescriptor> UNINITIALIZED_VARIABLE = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtSimpleNameExpression, ValueParameterDescriptor> UNINITIALIZED_PARAMETER = DiagnosticFactory1.create(ERROR);
 
-    DiagnosticFactory1<JetNamedDeclaration, VariableDescriptor> UNUSED_VARIABLE = DiagnosticFactory1.create(WARNING, DECLARATION_NAME);
-    DiagnosticFactory1<JetParameter, VariableDescriptor> UNUSED_PARAMETER = DiagnosticFactory1.create(WARNING, DECLARATION_NAME);
+    DiagnosticFactory1<KtNamedDeclaration, VariableDescriptor> UNUSED_VARIABLE = DiagnosticFactory1.create(WARNING, DECLARATION_NAME);
+    DiagnosticFactory1<KtParameter, VariableDescriptor> UNUSED_PARAMETER = DiagnosticFactory1.create(WARNING, DECLARATION_NAME);
 
-    DiagnosticFactory1<JetNamedDeclaration, VariableDescriptor> ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE =
+    DiagnosticFactory1<KtNamedDeclaration, VariableDescriptor> ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE =
             DiagnosticFactory1.create(WARNING, DECLARATION_NAME);
-    DiagnosticFactory1<JetExpression, DeclarationDescriptor> VARIABLE_WITH_REDUNDANT_INITIALIZER = DiagnosticFactory1.create(WARNING);
-    DiagnosticFactory2<JetBinaryExpression, JetElement, DeclarationDescriptor> UNUSED_VALUE = DiagnosticFactory2.create(WARNING, PositioningStrategies.UNUSED_VALUE);
-    DiagnosticFactory1<JetElement, JetElement> UNUSED_CHANGED_VALUE = DiagnosticFactory1.create(WARNING);
-    DiagnosticFactory0<JetElement> UNUSED_EXPRESSION = DiagnosticFactory0.create(WARNING);
-    DiagnosticFactory0<JetFunctionLiteralExpression> UNUSED_FUNCTION_LITERAL = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory1<KtExpression, DeclarationDescriptor> VARIABLE_WITH_REDUNDANT_INITIALIZER = DiagnosticFactory1.create(WARNING);
+    DiagnosticFactory2<KtBinaryExpression, KtElement, DeclarationDescriptor> UNUSED_VALUE = DiagnosticFactory2.create(WARNING, PositioningStrategies.UNUSED_VALUE);
+    DiagnosticFactory1<KtElement, KtElement> UNUSED_CHANGED_VALUE = DiagnosticFactory1.create(WARNING);
+    DiagnosticFactory0<KtElement> UNUSED_EXPRESSION = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory0<KtFunctionLiteralExpression> UNUSED_FUNCTION_LITERAL = DiagnosticFactory0.create(WARNING);
 
-    DiagnosticFactory1<JetExpression, DeclarationDescriptor> VAL_REASSIGNMENT = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetExpression, DeclarationDescriptor> SETTER_PROJECTED_OUT = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtExpression, DeclarationDescriptor> VAL_REASSIGNMENT = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtExpression, DeclarationDescriptor> SETTER_PROJECTED_OUT = DiagnosticFactory1.create(ERROR);
 
-    DiagnosticFactory1<JetExpression, DeclarationDescriptor> INITIALIZATION_BEFORE_DECLARATION = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtExpression, DeclarationDescriptor> INITIALIZATION_BEFORE_DECLARATION = DiagnosticFactory1.create(ERROR);
 
-    DiagnosticFactory0<JetExpression> VARIABLE_EXPECTED = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> VARIABLE_EXPECTED = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory2<JetBinaryExpression, JetBinaryExpression, Boolean> SENSELESS_COMPARISON = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<KtBinaryExpression, KtBinaryExpression, Boolean> SENSELESS_COMPARISON = DiagnosticFactory2.create(WARNING);
 
-    DiagnosticFactory0<JetElement> SENSELESS_NULL_IN_WHEN = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory0<KtElement> SENSELESS_NULL_IN_WHEN = DiagnosticFactory0.create(WARNING);
 
-    DiagnosticFactory0<JetIfExpression> INVALID_IF_AS_EXPRESSION = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtIfExpression> INVALID_IF_AS_EXPRESSION = DiagnosticFactory0.create(ERROR);
 
     // Nullability
 
-    DiagnosticFactory1<PsiElement, JetType> UNSAFE_CALL = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory3<JetExpression, String, String, String> UNSAFE_INFIX_CALL = DiagnosticFactory3.create(ERROR);
-    DiagnosticFactory1<PsiElement, JetType> UNNECESSARY_SAFE_CALL = DiagnosticFactory1.create(WARNING);
+    DiagnosticFactory1<PsiElement, KtType> UNSAFE_CALL = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory3<KtExpression, String, String, String> UNSAFE_INFIX_CALL = DiagnosticFactory3.create(ERROR);
+    DiagnosticFactory1<PsiElement, KtType> UNNECESSARY_SAFE_CALL = DiagnosticFactory1.create(WARNING);
     DiagnosticFactory0<PsiElement> UNEXPECTED_SAFE_CALL = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory1<PsiElement, JetType> UNNECESSARY_NOT_NULL_ASSERTION = DiagnosticFactory1.create(WARNING);
+    DiagnosticFactory1<PsiElement, KtType> UNNECESSARY_NOT_NULL_ASSERTION = DiagnosticFactory1.create(WARNING);
     DiagnosticFactory0<PsiElement> NOT_NULL_ASSERTION_ON_FUNCTION_LITERAL = DiagnosticFactory0.create(WARNING);
 
-    DiagnosticFactory1<JetBinaryExpression, JetType> USELESS_ELVIS = DiagnosticFactory1.create(WARNING, PositioningStrategies.USELESS_ELVIS);
+    DiagnosticFactory1<KtBinaryExpression, KtType> USELESS_ELVIS = DiagnosticFactory1.create(WARNING, PositioningStrategies.USELESS_ELVIS);
     DiagnosticFactory0<PsiElement> USELESS_ELVIS_ON_FUNCTION_LITERAL = DiagnosticFactory0.create(WARNING);
 
     // Compile-time values
 
-    DiagnosticFactory0<JetExpression> DIVISION_BY_ZERO = DiagnosticFactory0.create(WARNING);
-    DiagnosticFactory0<JetExpression> INTEGER_OVERFLOW = DiagnosticFactory0.create(WARNING);
-    DiagnosticFactory0<JetConstantExpression> WRONG_LONG_SUFFIX = DiagnosticFactory0.create(ERROR, LONG_LITERAL_SUFFIX);
-    DiagnosticFactory0<JetConstantExpression> INT_LITERAL_OUT_OF_RANGE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetConstantExpression> FLOAT_LITERAL_OUT_OF_RANGE = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory2<JetConstantExpression, String, JetType> CONSTANT_EXPECTED_TYPE_MISMATCH = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory0<JetConstantExpression> INCORRECT_CHARACTER_LITERAL = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetConstantExpression> EMPTY_CHARACTER_LITERAL = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory1<JetConstantExpression, JetConstantExpression> TOO_MANY_CHARACTERS_IN_CHARACTER_LITERAL = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetElement, JetElement> ILLEGAL_ESCAPE = DiagnosticFactory1.create(ERROR, CUT_CHAR_QUOTES);
-    DiagnosticFactory1<JetConstantExpression, JetType> NULL_FOR_NONNULL_TYPE = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory0<JetEscapeStringTemplateEntry> ILLEGAL_ESCAPE_SEQUENCE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> DIVISION_BY_ZERO = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory0<KtExpression> INTEGER_OVERFLOW = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory0<KtConstantExpression> WRONG_LONG_SUFFIX = DiagnosticFactory0.create(ERROR, LONG_LITERAL_SUFFIX);
+    DiagnosticFactory0<KtConstantExpression> INT_LITERAL_OUT_OF_RANGE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtConstantExpression> FLOAT_LITERAL_OUT_OF_RANGE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory2<KtConstantExpression, String, KtType> CONSTANT_EXPECTED_TYPE_MISMATCH = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory0<KtConstantExpression> INCORRECT_CHARACTER_LITERAL = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtConstantExpression> EMPTY_CHARACTER_LITERAL = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory1<KtConstantExpression, KtConstantExpression> TOO_MANY_CHARACTERS_IN_CHARACTER_LITERAL = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtElement, KtElement> ILLEGAL_ESCAPE = DiagnosticFactory1.create(ERROR, CUT_CHAR_QUOTES);
+    DiagnosticFactory1<KtConstantExpression, KtType> NULL_FOR_NONNULL_TYPE = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory0<KtEscapeStringTemplateEntry> ILLEGAL_ESCAPE_SEQUENCE = DiagnosticFactory0.create(ERROR);
 
     // Casts and is-checks
 
-    DiagnosticFactory1<JetElement, JetType> CANNOT_CHECK_FOR_ERASED = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory2<JetBinaryExpressionWithTypeRHS, JetType, JetType> UNCHECKED_CAST = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory1<KtElement, KtType> CANNOT_CHECK_FOR_ERASED = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory2<KtBinaryExpressionWithTypeRHS, KtType, KtType> UNCHECKED_CAST = DiagnosticFactory2.create(WARNING);
 
-    DiagnosticFactory0<JetBinaryExpressionWithTypeRHS> USELESS_CAST = DiagnosticFactory0.create(WARNING, AS_TYPE);
-    DiagnosticFactory0<JetSimpleNameExpression> CAST_NEVER_SUCCEEDS = DiagnosticFactory0.create(WARNING);
-    DiagnosticFactory0<JetTypeReference> DYNAMIC_NOT_ALLOWED = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetTypeReference> IS_ENUM_ENTRY = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtBinaryExpressionWithTypeRHS> USELESS_CAST = DiagnosticFactory0.create(WARNING, AS_TYPE);
+    DiagnosticFactory0<KtSimpleNameExpression> CAST_NEVER_SUCCEEDS = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory0<KtTypeReference> DYNAMIC_NOT_ALLOWED = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeReference> IS_ENUM_ENTRY = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory1<JetExpression, JetType> IMPLICIT_CAST_TO_UNIT_OR_ANY = DiagnosticFactory1.create(WARNING);
+    DiagnosticFactory1<KtExpression, KtType> IMPLICIT_CAST_TO_UNIT_OR_ANY = DiagnosticFactory1.create(WARNING);
 
-    DiagnosticFactory2<JetExpression, JetType, String> SMARTCAST_IMPOSSIBLE = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory2<KtExpression, KtType, String> SMARTCAST_IMPOSSIBLE = DiagnosticFactory2.create(ERROR);
 
-    DiagnosticFactory0<JetNullableType> USELESS_NULLABLE_CHECK = DiagnosticFactory0.create(WARNING, NULLABLE_TYPE);
+    DiagnosticFactory0<KtNullableType> USELESS_NULLABLE_CHECK = DiagnosticFactory0.create(WARNING, NULLABLE_TYPE);
 
     // Properties / locals
 
-    DiagnosticFactory0<JetTypeReference> LOCAL_EXTENSION_PROPERTY = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetPropertyAccessor> LOCAL_VARIABLE_WITH_GETTER = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetPropertyAccessor> LOCAL_VARIABLE_WITH_SETTER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtTypeReference> LOCAL_EXTENSION_PROPERTY = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtPropertyAccessor> LOCAL_VARIABLE_WITH_GETTER = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtPropertyAccessor> LOCAL_VARIABLE_WITH_SETTER = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory3<JetExpression, DeclarationDescriptor, Visibility, DeclarationDescriptor> INVISIBLE_SETTER = DiagnosticFactory3.create(ERROR);
+    DiagnosticFactory3<KtExpression, DeclarationDescriptor, Visibility, DeclarationDescriptor> INVISIBLE_SETTER = DiagnosticFactory3.create(ERROR);
 
-    DiagnosticFactory1<PsiElement, JetKeywordToken> VAL_OR_VAR_ON_LOOP_PARAMETER = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<PsiElement, JetKeywordToken> VAL_OR_VAR_ON_FUN_PARAMETER = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<PsiElement, JetKeywordToken> VAL_OR_VAR_ON_CATCH_PARAMETER = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<PsiElement, JetKeywordToken> VAL_OR_VAR_ON_SECONDARY_CONSTRUCTOR_PARAMETER = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<PsiElement, KtKeywordToken> VAL_OR_VAR_ON_LOOP_PARAMETER = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<PsiElement, KtKeywordToken> VAL_OR_VAR_ON_FUN_PARAMETER = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<PsiElement, KtKeywordToken> VAL_OR_VAR_ON_CATCH_PARAMETER = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<PsiElement, KtKeywordToken> VAL_OR_VAR_ON_SECONDARY_CONSTRUCTOR_PARAMETER = DiagnosticFactory1.create(ERROR);
 
     // Backing fields
 
-    DiagnosticFactory0<JetElement> NO_BACKING_FIELD_ABSTRACT_PROPERTY = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetElement> NO_BACKING_FIELD_CUSTOM_ACCESSORS = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetElement> INACCESSIBLE_BACKING_FIELD = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetElement> NOT_PROPERTY_BACKING_FIELD = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtElement> NO_BACKING_FIELD_ABSTRACT_PROPERTY = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtElement> NO_BACKING_FIELD_CUSTOM_ACCESSORS = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtElement> INACCESSIBLE_BACKING_FIELD = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtElement> NOT_PROPERTY_BACKING_FIELD = DiagnosticFactory0.create(ERROR);
 
     // When expressions
 
-    DiagnosticFactory0<JetWhenCondition> EXPECTED_CONDITION = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetWhenEntry> ELSE_MISPLACED_IN_WHEN = DiagnosticFactory0.create(ERROR, ELSE_ENTRY);
-    DiagnosticFactory0<JetWhenExpression> NO_ELSE_IN_WHEN = DiagnosticFactory0.create(ERROR, WHEN_EXPRESSION);
-    DiagnosticFactory0<JetWhenExpression> NON_EXHAUSTIVE_WHEN = DiagnosticFactory0.create(WARNING, WHEN_EXPRESSION);
+    DiagnosticFactory0<KtWhenCondition> EXPECTED_CONDITION = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtWhenEntry> ELSE_MISPLACED_IN_WHEN = DiagnosticFactory0.create(ERROR, ELSE_ENTRY);
+    DiagnosticFactory0<KtWhenExpression> NO_ELSE_IN_WHEN = DiagnosticFactory0.create(ERROR, WHEN_EXPRESSION);
+    DiagnosticFactory0<KtWhenExpression> NON_EXHAUSTIVE_WHEN = DiagnosticFactory0.create(WARNING, WHEN_EXPRESSION);
 
     // Type mismatch
 
-    DiagnosticFactory2<JetExpression, JetType, JetType> TYPE_MISMATCH = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory1<JetExpression, JetType> RETURN_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetExpression, JetType> EXPECTED_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetBinaryExpression, JetType> ASSIGNMENT_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory2<JetTypeReference, JetType, JetType> TYPE_MISMATCH_IN_FOR_LOOP = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory1<JetElement, JetType> TYPE_MISMATCH_IN_CONDITION = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory3<JetExpression, String, JetType, JetType> RESULT_TYPE_MISMATCH = DiagnosticFactory3.create(ERROR);
-    DiagnosticFactory0<JetWhenConditionInRange> TYPE_MISMATCH_IN_RANGE = DiagnosticFactory0.create(ERROR, WHEN_CONDITION_IN_RANGE);
+    DiagnosticFactory2<KtExpression, KtType, KtType> TYPE_MISMATCH = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory1<KtExpression, KtType> RETURN_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtExpression, KtType> EXPECTED_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtBinaryExpression, KtType> ASSIGNMENT_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory2<KtTypeReference, KtType, KtType> TYPE_MISMATCH_IN_FOR_LOOP = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory1<KtElement, KtType> TYPE_MISMATCH_IN_CONDITION = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory3<KtExpression, String, KtType, KtType> RESULT_TYPE_MISMATCH = DiagnosticFactory3.create(ERROR);
+    DiagnosticFactory0<KtWhenConditionInRange> TYPE_MISMATCH_IN_RANGE = DiagnosticFactory0.create(ERROR, WHEN_CONDITION_IN_RANGE);
 
-    DiagnosticFactory1<JetParameter, JetType> EXPECTED_PARAMETER_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory2<JetFunction, Integer, List<JetType>> EXPECTED_PARAMETERS_NUMBER_MISMATCH =
+    DiagnosticFactory1<KtParameter, KtType> EXPECTED_PARAMETER_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory2<KtFunction, Integer, List<KtType>> EXPECTED_PARAMETERS_NUMBER_MISMATCH =
             DiagnosticFactory2.create(ERROR, FUNCTION_PARAMETERS);
 
-    DiagnosticFactory2<JetElement, JetType, JetType> INCOMPATIBLE_TYPES = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory2<KtElement, KtType, KtType> INCOMPATIBLE_TYPES = DiagnosticFactory2.create(ERROR);
 
     DiagnosticFactory0<PsiElement> IMPLICIT_NOTHING_RETURN_TYPE = DiagnosticFactory0.create(WARNING);
 
     // Context tracking
 
-    DiagnosticFactory1<JetExpression, JetExpression> EXPRESSION_EXPECTED = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory0<JetBinaryExpression> ASSIGNMENT_IN_EXPRESSION_CONTEXT = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetDeclaration> DECLARATION_IN_ILLEGAL_CONTEXT = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory1<KtExpression, KtExpression> EXPRESSION_EXPECTED = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory0<KtBinaryExpression> ASSIGNMENT_IN_EXPRESSION_CONTEXT = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtDeclaration> DECLARATION_IN_ILLEGAL_CONTEXT = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetSimpleNameExpression> EXPRESSION_EXPECTED_PACKAGE_FOUND = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtSimpleNameExpression> EXPRESSION_EXPECTED_PACKAGE_FOUND = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetReturnExpression> RETURN_NOT_ALLOWED = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetReturnExpression> RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetDeclarationWithBody>
+    DiagnosticFactory0<KtReturnExpression> RETURN_NOT_ALLOWED = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtReturnExpression> RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtDeclarationWithBody>
             NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY = DiagnosticFactory0.create(ERROR, DECLARATION_WITH_BODY);
 
-    DiagnosticFactory0<JetClassInitializer> ANONYMOUS_INITIALIZER_IN_INTERFACE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtClassInitializer> ANONYMOUS_INITIALIZER_IN_INTERFACE = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<JetThisExpression> NO_THIS = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetRootPackageExpression> PACKAGE_IS_NOT_AN_EXPRESSION = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory1<JetSimpleNameExpression, ClassifierDescriptor> NO_COMPANION_OBJECT = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetSimpleNameExpression, TypeParameterDescriptor> TYPE_PARAMETER_IS_NOT_AN_EXPRESSION = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetSimpleNameExpression, TypeParameterDescriptor> TYPE_PARAMETER_ON_LHS_OF_DOT = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<JetExpression, ClassDescriptor> NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory2<JetExpression, ClassDescriptor, String> NESTED_CLASS_SHOULD_BE_QUALIFIED = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory0<KtThisExpression> NO_THIS = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtRootPackageExpression> PACKAGE_IS_NOT_AN_EXPRESSION = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory1<KtSimpleNameExpression, ClassifierDescriptor> NO_COMPANION_OBJECT = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtSimpleNameExpression, TypeParameterDescriptor> TYPE_PARAMETER_IS_NOT_AN_EXPRESSION = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtSimpleNameExpression, TypeParameterDescriptor> TYPE_PARAMETER_ON_LHS_OF_DOT = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<KtExpression, ClassDescriptor> NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory2<KtExpression, ClassDescriptor, String> NESTED_CLASS_SHOULD_BE_QUALIFIED = DiagnosticFactory2.create(ERROR);
 
     DiagnosticFactory1<PsiElement, ClassDescriptor> INACCESSIBLE_OUTER_CLASS_EXPRESSION = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory0<JetClass> NESTED_CLASS_NOT_ALLOWED = DiagnosticFactory0.create(ERROR, DECLARATION_NAME);
+    DiagnosticFactory0<KtClass> NESTED_CLASS_NOT_ALLOWED = DiagnosticFactory0.create(ERROR, DECLARATION_NAME);
 
     //Inline and inlinable parameters
-    DiagnosticFactory2<JetElement, DeclarationDescriptor, DeclarationDescriptor> INVISIBLE_MEMBER_FROM_INLINE = DiagnosticFactory2.create(ERROR, CALL_ELEMENT);
-    DiagnosticFactory3<JetElement, JetElement, DeclarationDescriptor, DeclarationDescriptor> NON_LOCAL_RETURN_NOT_ALLOWED = DiagnosticFactory3.create(ERROR, CALL_ELEMENT);
-    DiagnosticFactory2<JetElement, JetNamedDeclaration, DeclarationDescriptor> NOT_YET_SUPPORTED_IN_INLINE = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory2<KtElement, DeclarationDescriptor, DeclarationDescriptor> INVISIBLE_MEMBER_FROM_INLINE = DiagnosticFactory2.create(ERROR, CALL_ELEMENT);
+    DiagnosticFactory3<KtElement, KtElement, DeclarationDescriptor, DeclarationDescriptor> NON_LOCAL_RETURN_NOT_ALLOWED = DiagnosticFactory3.create(ERROR, CALL_ELEMENT);
+    DiagnosticFactory2<KtElement, KtNamedDeclaration, DeclarationDescriptor> NOT_YET_SUPPORTED_IN_INLINE = DiagnosticFactory2.create(ERROR);
     DiagnosticFactory1<PsiElement, DeclarationDescriptor> NOTHING_TO_INLINE = DiagnosticFactory1.create(WARNING);
-    DiagnosticFactory2<JetElement, JetExpression, DeclarationDescriptor> USAGE_IS_NOT_INLINABLE = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory2<JetElement, JetElement, DeclarationDescriptor> NULLABLE_INLINE_PARAMETER = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory2<JetElement, JetElement, DeclarationDescriptor> RECURSION_IN_INLINE = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory0<JetElement> DECLARATION_CANT_BE_INLINED = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory2<KtElement, KtExpression, DeclarationDescriptor> USAGE_IS_NOT_INLINABLE = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory2<KtElement, KtElement, DeclarationDescriptor> NULLABLE_INLINE_PARAMETER = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory2<KtElement, KtElement, DeclarationDescriptor> RECURSION_IN_INLINE = DiagnosticFactory2.create(ERROR);
+    DiagnosticFactory0<KtElement> DECLARATION_CANT_BE_INLINED = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory1<PsiElement, CallableDescriptor> INLINE_CALL_CYCLE = DiagnosticFactory1.create(ERROR, DEFAULT);
     DiagnosticFactory0<PsiElement> NON_LOCAL_RETURN_IN_DISABLED_INLINE = DiagnosticFactory0.create(ERROR);
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
index a0be395befd..f4f21aac76d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
@@ -20,20 +20,20 @@ import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiNameIdentifierOwner
 import com.intellij.psi.tree.TokenSet
-import org.jetbrains.kotlin.JetNodeTypes
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.KtNodeTypes
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.*
 import org.jetbrains.kotlin.utils.sure
 
 public object PositioningStrategies {
-    private open class DeclarationHeader<T : JetDeclaration> : PositioningStrategy<T>() {
+    private open class DeclarationHeader<T : KtDeclaration> : PositioningStrategy<T>() {
         override fun isValid(element: T): Boolean {
-            if (element is JetNamedDeclaration &&
-                element !is JetObjectDeclaration &&
-                element !is JetSecondaryConstructor &&
-                element !is JetFunction
+            if (element is KtNamedDeclaration &&
+                element !is KtObjectDeclaration &&
+                element !is KtSecondaryConstructor &&
+                element !is KtFunction
             ) {
                 if (element.getNameIdentifier() == null) {
                     return false
@@ -46,7 +46,7 @@ public object PositioningStrategies {
     public val DEFAULT: PositioningStrategy<PsiElement> = object : PositioningStrategy<PsiElement>() {
         override fun mark(element: PsiElement): List<TextRange> {
             when (element) {
-                is JetObjectLiteralExpression -> {
+                is KtObjectLiteralExpression -> {
                     val objectDeclaration = element.getObjectDeclaration()
                     val objectKeyword = objectDeclaration.getObjectKeyword()
                     val delegationSpecifierList = objectDeclaration.getDelegationSpecifierList()
@@ -55,13 +55,13 @@ public object PositioningStrategies {
                     }
                     return markRange(objectKeyword, delegationSpecifierList)
                 }
-                is JetObjectDeclaration -> {
+                is KtObjectDeclaration -> {
                     return markRange(
                             element.getObjectKeyword(),
                             element.getNameIdentifier() ?: element.getObjectKeyword()
                     )
                 }
-                is JetConstructorDelegationCall -> {
+                is KtConstructorDelegationCall -> {
                     return SECONDARY_CONSTRUCTOR_DELEGATION_CALL.mark(element)
                 }
                 else -> {
@@ -71,19 +71,19 @@ public object PositioningStrategies {
         }
     }
 
-    public val DECLARATION_RETURN_TYPE: PositioningStrategy<JetDeclaration> = object : PositioningStrategy<JetDeclaration>() {
-        override fun mark(element: JetDeclaration): List<TextRange> {
+    public val DECLARATION_RETURN_TYPE: PositioningStrategy<KtDeclaration> = object : PositioningStrategy<KtDeclaration>() {
+        override fun mark(element: KtDeclaration): List<TextRange> {
             return markElement(getElementToMark(element))
         }
 
-        override fun isValid(element: JetDeclaration): Boolean {
+        override fun isValid(element: KtDeclaration): Boolean {
             return !hasSyntaxErrors(getElementToMark(element))
         }
 
-        private fun getElementToMark(declaration: JetDeclaration): PsiElement {
+        private fun getElementToMark(declaration: KtDeclaration): PsiElement {
             val (returnTypeRef, nameIdentifierOrPlaceholder) = when (declaration) {
-                is JetCallableDeclaration -> Pair(declaration.getTypeReference(), declaration.getNameIdentifier())
-                is JetPropertyAccessor -> Pair(declaration.getReturnTypeReference(), declaration.getNamePlaceholder())
+                is KtCallableDeclaration -> Pair(declaration.getTypeReference(), declaration.getNameIdentifier())
+                is KtPropertyAccessor -> Pair(declaration.getReturnTypeReference(), declaration.getNamePlaceholder())
                 else -> Pair(null, null)
             }
 
@@ -93,43 +93,43 @@ public object PositioningStrategies {
         }
     }
 
-    public val DECLARATION_NAME: PositioningStrategy<JetNamedDeclaration> = object : DeclarationHeader<JetNamedDeclaration>() {
-        override fun mark(element: JetNamedDeclaration): List<TextRange> {
+    public val DECLARATION_NAME: PositioningStrategy<KtNamedDeclaration> = object : DeclarationHeader<KtNamedDeclaration>() {
+        override fun mark(element: KtNamedDeclaration): List<TextRange> {
             val nameIdentifier = element.getNameIdentifier()
             if (nameIdentifier != null) {
-                if (element is JetClassOrObject) {
+                if (element is KtClassOrObject) {
                     val startElement =
-                            element.getModifierList()?.getModifier(JetTokens.ENUM_KEYWORD)
-                            ?: element.getNode().findChildByType(TokenSet.create(JetTokens.CLASS_KEYWORD, JetTokens.OBJECT_KEYWORD))?.getPsi()
+                            element.getModifierList()?.getModifier(KtTokens.ENUM_KEYWORD)
+                            ?: element.getNode().findChildByType(TokenSet.create(KtTokens.CLASS_KEYWORD, KtTokens.OBJECT_KEYWORD))?.getPsi()
                             ?: element
 
                     return markRange(startElement, nameIdentifier)
                 }
                 return markElement(nameIdentifier)
             }
-            if (element is JetNamedFunction) {
+            if (element is KtNamedFunction) {
                 return DECLARATION_SIGNATURE.mark(element)
             }
             return DEFAULT.mark(element)
         }
     }
 
-    public val DECLARATION_SIGNATURE: PositioningStrategy<JetDeclaration> = object : DeclarationHeader<JetDeclaration>() {
-        override fun mark(element: JetDeclaration): List<TextRange> {
+    public val DECLARATION_SIGNATURE: PositioningStrategy<KtDeclaration> = object : DeclarationHeader<KtDeclaration>() {
+        override fun mark(element: KtDeclaration): List<TextRange> {
             when (element) {
-                is JetConstructor<*> -> {
+                is KtConstructor<*> -> {
                     val begin = element.getConstructorKeyword() ?: element.getValueParameterList() ?: return markElement(element)
                     val end = element.getValueParameterList() ?: element.getConstructorKeyword() ?: return markElement(element)
                     return markRange(begin, end)
                 }
-                is JetFunction -> {
+                is KtFunction -> {
                     val endOfSignatureElement =
                             element.getTypeReference()
                             ?: element.getValueParameterList()
                             ?: element.getNameIdentifier()
                             ?: element
                     val startElement
-                            = if (element is JetFunctionLiteral) {
+                            = if (element is KtFunctionLiteral) {
                                 element.getReceiverTypeReference()
                                 ?: element.getValueParameterList()
                                 ?: element
@@ -137,11 +137,11 @@ public object PositioningStrategies {
                             else element
                     return markRange(startElement, endOfSignatureElement)
                 }
-                is JetProperty -> {
+                is KtProperty -> {
                     val endOfSignatureElement = element.getTypeReference() ?: element.getNameIdentifier() ?: element
                     return markRange(element, endOfSignatureElement)
                 }
-                is JetPropertyAccessor -> {
+                is KtPropertyAccessor -> {
                     val endOfSignatureElement =
                             element.getReturnTypeReference()
                             ?: element.getRightParenthesis()?.getPsi()
@@ -149,12 +149,12 @@ public object PositioningStrategies {
 
                     return markRange(element, endOfSignatureElement)
                 }
-                is JetClass -> {
+                is KtClass -> {
                     val nameAsDeclaration = element.getNameIdentifier() ?: return markElement(element)
                     val primaryConstructorParameterList = element.getPrimaryConstructorParameterList() ?: return markElement(nameAsDeclaration)
                     return markRange(nameAsDeclaration, primaryConstructorParameterList)
                 }
-                is JetObjectDeclaration -> {
+                is KtObjectDeclaration -> {
                     return DECLARATION_NAME.mark(element)
                 }
             }
@@ -164,23 +164,23 @@ public object PositioningStrategies {
 
     public val DECLARATION_SIGNATURE_OR_DEFAULT: PositioningStrategy<PsiElement> = object : PositioningStrategy<PsiElement>() {
         override fun mark(element: PsiElement): List<TextRange> {
-            return if (element is JetDeclaration)
+            return if (element is KtDeclaration)
                 DECLARATION_SIGNATURE.mark(element)
             else
                 DEFAULT.mark(element)
         }
 
         override fun isValid(element: PsiElement): Boolean {
-            return if (element is JetDeclaration)
+            return if (element is KtDeclaration)
                 DECLARATION_SIGNATURE.isValid(element)
             else
                 DEFAULT.isValid(element)
         }
     }
 
-    public val TYPE_PARAMETERS_OR_DECLARATION_SIGNATURE: PositioningStrategy<JetDeclaration> = object : PositioningStrategy<JetDeclaration>() {
-        override fun mark(element: JetDeclaration): List<TextRange> {
-            if (element is JetTypeParameterListOwner) {
+    public val TYPE_PARAMETERS_OR_DECLARATION_SIGNATURE: PositioningStrategy<KtDeclaration> = object : PositioningStrategy<KtDeclaration>() {
+        override fun mark(element: KtDeclaration): List<TextRange> {
+            if (element is KtTypeParameterListOwner) {
                 val jetTypeParameterList = element.getTypeParameterList()
                 if (jetTypeParameterList != null) {
                     return markElement(jetTypeParameterList)
@@ -190,32 +190,32 @@ public object PositioningStrategies {
         }
     }
 
-    public val ABSTRACT_MODIFIER: PositioningStrategy<JetModifierListOwner> = modifierSetPosition(JetTokens.ABSTRACT_KEYWORD)
+    public val ABSTRACT_MODIFIER: PositioningStrategy<KtModifierListOwner> = modifierSetPosition(KtTokens.ABSTRACT_KEYWORD)
 
-    public val OVERRIDE_MODIFIER: PositioningStrategy<JetModifierListOwner> = modifierSetPosition(JetTokens.OVERRIDE_KEYWORD)
+    public val OVERRIDE_MODIFIER: PositioningStrategy<KtModifierListOwner> = modifierSetPosition(KtTokens.OVERRIDE_KEYWORD)
 
-    public val FINAL_MODIFIER: PositioningStrategy<JetModifierListOwner> = modifierSetPosition(JetTokens.FINAL_KEYWORD)
+    public val FINAL_MODIFIER: PositioningStrategy<KtModifierListOwner> = modifierSetPosition(KtTokens.FINAL_KEYWORD)
 
-    public val PRIVATE_MODIFIER: PositioningStrategy<JetModifierListOwner> = modifierSetPosition(JetTokens.PRIVATE_KEYWORD)
+    public val PRIVATE_MODIFIER: PositioningStrategy<KtModifierListOwner> = modifierSetPosition(KtTokens.PRIVATE_KEYWORD)
 
-    public val VARIANCE_MODIFIER: PositioningStrategy<JetModifierListOwner> = modifierSetPosition(JetTokens.IN_KEYWORD, JetTokens.OUT_KEYWORD)
+    public val VARIANCE_MODIFIER: PositioningStrategy<KtModifierListOwner> = modifierSetPosition(KtTokens.IN_KEYWORD, KtTokens.OUT_KEYWORD)
 
     public val FOR_REDECLARATION: PositioningStrategy<PsiElement> = object : PositioningStrategy<PsiElement>() {
         override fun mark(element: PsiElement): List<TextRange> {
             val nameIdentifier = when (element) {
-                is JetNamedDeclaration -> element.getNameIdentifier()
-                is JetFile -> element.getPackageDirective()!!.getNameIdentifier()
+                is KtNamedDeclaration -> element.getNameIdentifier()
+                is KtFile -> element.getPackageDirective()!!.getNameIdentifier()
                 else -> null
             }
 
-            if (nameIdentifier == null && element is JetObjectDeclaration) return DEFAULT.mark(element)
+            if (nameIdentifier == null && element is KtObjectDeclaration) return DEFAULT.mark(element)
 
             return markElement(nameIdentifier ?: element)
         }
     }
-    public val FOR_UNRESOLVED_REFERENCE: PositioningStrategy<JetReferenceExpression> = object : PositioningStrategy<JetReferenceExpression>() {
-        override fun mark(element: JetReferenceExpression): List<TextRange> {
-            if (element is JetArrayAccessExpression) {
+    public val FOR_UNRESOLVED_REFERENCE: PositioningStrategy<KtReferenceExpression> = object : PositioningStrategy<KtReferenceExpression>() {
+        override fun mark(element: KtReferenceExpression): List<TextRange> {
+            if (element is KtArrayAccessExpression) {
                 val ranges = element.getBracketRanges()
                 if (!ranges.isEmpty()) {
                     return ranges
@@ -226,9 +226,9 @@ public object PositioningStrategies {
     }
 
     @JvmStatic
-    public fun modifierSetPosition(vararg tokens: JetModifierKeywordToken): PositioningStrategy<JetModifierListOwner> {
-        return object : PositioningStrategy<JetModifierListOwner>() {
-            override fun mark(element: JetModifierListOwner): List<TextRange> {
+    public fun modifierSetPosition(vararg tokens: KtModifierKeywordToken): PositioningStrategy<KtModifierListOwner> {
+        return object : PositioningStrategy<KtModifierListOwner>() {
+            override fun mark(element: KtModifierListOwner): List<TextRange> {
                 val modifierList = element.getModifierList().sure { "No modifier list, but modifier has been found by the analyzer" }
 
                 for (token in tokens) {
@@ -242,15 +242,15 @@ public object PositioningStrategies {
         }
     }
 
-    public val ARRAY_ACCESS: PositioningStrategy<JetArrayAccessExpression> = object : PositioningStrategy<JetArrayAccessExpression>() {
-        override fun mark(element: JetArrayAccessExpression): List<TextRange> {
+    public val ARRAY_ACCESS: PositioningStrategy<KtArrayAccessExpression> = object : PositioningStrategy<KtArrayAccessExpression>() {
+        override fun mark(element: KtArrayAccessExpression): List<TextRange> {
             return markElement(element.getIndicesNode())
         }
     }
 
-    public val VISIBILITY_MODIFIER: PositioningStrategy<JetModifierListOwner> = object : PositioningStrategy<JetModifierListOwner>() {
-        override fun mark(element: JetModifierListOwner): List<TextRange> {
-            val visibilityTokens = listOf(JetTokens.PRIVATE_KEYWORD, JetTokens.PROTECTED_KEYWORD, JetTokens.PUBLIC_KEYWORD, JetTokens.INTERNAL_KEYWORD)
+    public val VISIBILITY_MODIFIER: PositioningStrategy<KtModifierListOwner> = object : PositioningStrategy<KtModifierListOwner>() {
+        override fun mark(element: KtModifierListOwner): List<TextRange> {
+            val visibilityTokens = listOf(KtTokens.PRIVATE_KEYWORD, KtTokens.PROTECTED_KEYWORD, KtTokens.PUBLIC_KEYWORD, KtTokens.INTERNAL_KEYWORD)
             val modifierList = element.getModifierList()
 
             val result = visibilityTokens.map { modifierList?.getModifier(it)?.getTextRange() }.filterNotNull()
@@ -265,9 +265,9 @@ public object PositioningStrategies {
             }
 
             val elementToMark = when (element) {
-                is JetObjectDeclaration -> element.getObjectKeyword()
-                is JetPropertyAccessor -> element.getNamePlaceholder()
-                is JetClassInitializer -> element
+                is KtObjectDeclaration -> element.getObjectKeyword()
+                is KtPropertyAccessor -> element.getNamePlaceholder()
+                is KtClassInitializer -> element
                 else -> throw IllegalArgumentException(
                         "Can't find text range for element '${element.javaClass.getCanonicalName()}' with the text '${element.getText()}'")
             }
@@ -275,104 +275,104 @@ public object PositioningStrategies {
         }
     }
 
-    public val VARIANCE_IN_PROJECTION: PositioningStrategy<JetTypeProjection> = object : PositioningStrategy<JetTypeProjection>() {
-        override fun mark(element: JetTypeProjection): List<TextRange> {
+    public val VARIANCE_IN_PROJECTION: PositioningStrategy<KtTypeProjection> = object : PositioningStrategy<KtTypeProjection>() {
+        override fun mark(element: KtTypeProjection): List<TextRange> {
             return markElement(element.getProjectionToken()!!)
         }
     }
 
-    public val PARAMETER_DEFAULT_VALUE: PositioningStrategy<JetParameter> = object : PositioningStrategy<JetParameter>() {
-        override fun mark(element: JetParameter): List<TextRange> {
+    public val PARAMETER_DEFAULT_VALUE: PositioningStrategy<KtParameter> = object : PositioningStrategy<KtParameter>() {
+        override fun mark(element: KtParameter): List<TextRange> {
             return markNode(element.getDefaultValue()!!.getNode())
         }
     }
 
     public val CALL_ELEMENT: PositioningStrategy<PsiElement> = object : PositioningStrategy<PsiElement>() {
         override fun mark(element: PsiElement): List<TextRange> {
-            return markElement((element as? JetCallElement)?.getCalleeExpression() ?: element)
+            return markElement((element as? KtCallElement)?.getCalleeExpression() ?: element)
         }
     }
 
-    public val DECLARATION_WITH_BODY: PositioningStrategy<JetDeclarationWithBody> = object : PositioningStrategy<JetDeclarationWithBody>() {
-        override fun mark(element: JetDeclarationWithBody): List<TextRange> {
-            val lastBracketRange = (element.getBodyExpression() as? JetBlockExpression)?.getLastBracketRange()
+    public val DECLARATION_WITH_BODY: PositioningStrategy<KtDeclarationWithBody> = object : PositioningStrategy<KtDeclarationWithBody>() {
+        override fun mark(element: KtDeclarationWithBody): List<TextRange> {
+            val lastBracketRange = (element.getBodyExpression() as? KtBlockExpression)?.getLastBracketRange()
             return if (lastBracketRange != null)
                 markRange(lastBracketRange)
             else
                 markElement(element)
         }
 
-        override fun isValid(element: JetDeclarationWithBody): Boolean {
-            return super.isValid(element) && (element.getBodyExpression() as? JetBlockExpression)?.getLastBracketRange() != null
+        override fun isValid(element: KtDeclarationWithBody): Boolean {
+            return super.isValid(element) && (element.getBodyExpression() as? KtBlockExpression)?.getLastBracketRange() != null
         }
     }
 
-    public val VAL_OR_VAR_NODE: PositioningStrategy<JetNamedDeclaration> = object : PositioningStrategy<JetNamedDeclaration>() {
-        override fun mark(element: JetNamedDeclaration): List<TextRange> {
+    public val VAL_OR_VAR_NODE: PositioningStrategy<KtNamedDeclaration> = object : PositioningStrategy<KtNamedDeclaration>() {
+        override fun mark(element: KtNamedDeclaration): List<TextRange> {
             return when (element) {
-                is JetParameter -> markElement(element.valOrVarKeyword ?: element)
-                is JetProperty -> markElement(element.valOrVarKeyword)
+                is KtParameter -> markElement(element.valOrVarKeyword ?: element)
+                is KtProperty -> markElement(element.valOrVarKeyword)
                 else -> error("Declaration is neither a parameter nor a property: " + element.getElementTextWithContext())
             }
         }
     }
 
-    public val ELSE_ENTRY: PositioningStrategy<JetWhenEntry> = object : PositioningStrategy<JetWhenEntry>() {
-        override fun mark(element: JetWhenEntry): List<TextRange> {
+    public val ELSE_ENTRY: PositioningStrategy<KtWhenEntry> = object : PositioningStrategy<KtWhenEntry>() {
+        override fun mark(element: KtWhenEntry): List<TextRange> {
             return markElement(element.getElseKeyword()!!)
         }
     }
 
-    public val WHEN_EXPRESSION: PositioningStrategy<JetWhenExpression> = object : PositioningStrategy<JetWhenExpression>() {
-        override fun mark(element: JetWhenExpression): List<TextRange> {
+    public val WHEN_EXPRESSION: PositioningStrategy<KtWhenExpression> = object : PositioningStrategy<KtWhenExpression>() {
+        override fun mark(element: KtWhenExpression): List<TextRange> {
             return markElement(element.getWhenKeyword())
         }
     }
 
-    public val WHEN_CONDITION_IN_RANGE: PositioningStrategy<JetWhenConditionInRange> = object : PositioningStrategy<JetWhenConditionInRange>() {
-        override fun mark(element: JetWhenConditionInRange): List<TextRange> {
+    public val WHEN_CONDITION_IN_RANGE: PositioningStrategy<KtWhenConditionInRange> = object : PositioningStrategy<KtWhenConditionInRange>() {
+        override fun mark(element: KtWhenConditionInRange): List<TextRange> {
             return markElement(element.getOperationReference())
         }
     }
 
-    public val NULLABLE_TYPE: PositioningStrategy<JetNullableType> = object : PositioningStrategy<JetNullableType>() {
-        override fun mark(element: JetNullableType): List<TextRange> {
+    public val NULLABLE_TYPE: PositioningStrategy<KtNullableType> = object : PositioningStrategy<KtNullableType>() {
+        override fun mark(element: KtNullableType): List<TextRange> {
             return markNode(element.getQuestionMarkNode())
         }
     }
 
     public val CALL_EXPRESSION: PositioningStrategy<PsiElement> = object : PositioningStrategy<PsiElement>() {
         override fun mark(element: PsiElement): List<TextRange> {
-            if (element is JetCallExpression) {
+            if (element is KtCallExpression) {
                 return markRange(element, element.getTypeArgumentList() ?: element.getCalleeExpression() ?: element)
             }
             return markElement(element)
         }
     }
 
-    public val VALUE_ARGUMENTS: PositioningStrategy<JetElement> = object : PositioningStrategy<JetElement>() {
-        override fun mark(element: JetElement): List<TextRange> {
-            return markElement((element as? JetValueArgumentList)?.getRightParenthesis() ?: element)
+    public val VALUE_ARGUMENTS: PositioningStrategy<KtElement> = object : PositioningStrategy<KtElement>() {
+        override fun mark(element: KtElement): List<TextRange> {
+            return markElement((element as? KtValueArgumentList)?.getRightParenthesis() ?: element)
         }
     }
 
-    public val FUNCTION_PARAMETERS: PositioningStrategy<JetFunction> = object : PositioningStrategy<JetFunction>() {
-        override fun mark(element: JetFunction): List<TextRange> {
+    public val FUNCTION_PARAMETERS: PositioningStrategy<KtFunction> = object : PositioningStrategy<KtFunction>() {
+        override fun mark(element: KtFunction): List<TextRange> {
             val valueParameterList = element.getValueParameterList()
             if (valueParameterList != null) {
                 return markElement(valueParameterList)
             }
-            if (element is JetFunctionLiteral) {
+            if (element is KtFunctionLiteral) {
                 return markNode(element.getLBrace().getNode())
             }
             return DECLARATION_SIGNATURE_OR_DEFAULT.mark(element)
         }
     }
 
-    public val CUT_CHAR_QUOTES: PositioningStrategy<JetElement> = object : PositioningStrategy<JetElement>() {
-        override fun mark(element: JetElement): List<TextRange> {
-            if (element is JetConstantExpression) {
-                if (element.getNode().getElementType() == JetNodeTypes.CHARACTER_CONSTANT) {
+    public val CUT_CHAR_QUOTES: PositioningStrategy<KtElement> = object : PositioningStrategy<KtElement>() {
+        override fun mark(element: KtElement): List<TextRange> {
+            if (element is KtConstantExpression) {
+                if (element.getNode().getElementType() == KtNodeTypes.CHARACTER_CONSTANT) {
                     val elementTextRange = element.getTextRange()
                     return listOf(TextRange.create(elementTextRange.getStartOffset() + 1, elementTextRange.getEndOffset() - 1))
                 }
@@ -381,10 +381,10 @@ public object PositioningStrategies {
         }
     }
 
-    public val LONG_LITERAL_SUFFIX: PositioningStrategy<JetElement> = object : PositioningStrategy<JetElement>() {
-        override fun mark(element: JetElement): List<TextRange> {
-            if (element is JetConstantExpression) {
-                if (element.getNode().getElementType() == JetNodeTypes.INTEGER_CONSTANT) {
+    public val LONG_LITERAL_SUFFIX: PositioningStrategy<KtElement> = object : PositioningStrategy<KtElement>() {
+        override fun mark(element: KtElement): List<TextRange> {
+            if (element is KtConstantExpression) {
+                if (element.getNode().getElementType() == KtNodeTypes.INTEGER_CONSTANT) {
                     val endOffset = element.endOffset
                     return listOf(TextRange.create(endOffset - 1, endOffset))
                 }
@@ -399,26 +399,26 @@ public object PositioningStrategies {
         }
     }
 
-    public val AS_TYPE: PositioningStrategy<JetBinaryExpressionWithTypeRHS> = object : PositioningStrategy<JetBinaryExpressionWithTypeRHS>() {
-        override fun mark(element: JetBinaryExpressionWithTypeRHS): List<TextRange> {
+    public val AS_TYPE: PositioningStrategy<KtBinaryExpressionWithTypeRHS> = object : PositioningStrategy<KtBinaryExpressionWithTypeRHS>() {
+        override fun mark(element: KtBinaryExpressionWithTypeRHS): List<TextRange> {
             return markRange(element.getOperationReference(), element)
         }
     }
 
-    public val COMPANION_OBJECT: PositioningStrategy<JetObjectDeclaration> = object : PositioningStrategy<JetObjectDeclaration>() {
-        override fun mark(element: JetObjectDeclaration): List<TextRange> {
-            if (element.hasModifier(JetTokens.COMPANION_KEYWORD)) {
-                return modifierSetPosition(JetTokens.COMPANION_KEYWORD).mark(element)
+    public val COMPANION_OBJECT: PositioningStrategy<KtObjectDeclaration> = object : PositioningStrategy<KtObjectDeclaration>() {
+        override fun mark(element: KtObjectDeclaration): List<TextRange> {
+            if (element.hasModifier(KtTokens.COMPANION_KEYWORD)) {
+                return modifierSetPosition(KtTokens.COMPANION_KEYWORD).mark(element)
             }
             return DEFAULT.mark(element)
         }
     }
 
-    public val SECONDARY_CONSTRUCTOR_DELEGATION_CALL: PositioningStrategy<JetConstructorDelegationCall> =
-            object : PositioningStrategy<JetConstructorDelegationCall>() {
-                override fun mark(element: JetConstructorDelegationCall): List<TextRange> {
+    public val SECONDARY_CONSTRUCTOR_DELEGATION_CALL: PositioningStrategy<KtConstructorDelegationCall> =
+            object : PositioningStrategy<KtConstructorDelegationCall>() {
+                override fun mark(element: KtConstructorDelegationCall): List<TextRange> {
                     if (element.isImplicit()) {
-                        val constructor = element.getStrictParentOfType<JetSecondaryConstructor>()!!
+                        val constructor = element.getStrictParentOfType<KtSecondaryConstructor>()!!
                         val valueParameterList = constructor.getValueParameterList() ?: return markElement(constructor)
                         return markRange(constructor.getConstructorKeyword(), valueParameterList.getLastChild())
                     }
@@ -426,30 +426,30 @@ public object PositioningStrategies {
                 }
             }
 
-    public val DELEGATOR_SUPER_CALL: PositioningStrategy<JetEnumEntry> = object: PositioningStrategy<JetEnumEntry>() {
-        override fun mark(element: JetEnumEntry): List<TextRange> {
+    public val DELEGATOR_SUPER_CALL: PositioningStrategy<KtEnumEntry> = object: PositioningStrategy<KtEnumEntry>() {
+        override fun mark(element: KtEnumEntry): List<TextRange> {
             val specifiers = element.getDelegationSpecifiers()
             return markElement(if (specifiers.isEmpty()) element else specifiers[0])
         }
     }
 
-    public val UNUSED_VALUE: PositioningStrategy<JetBinaryExpression> = object: PositioningStrategy<JetBinaryExpression>() {
-        override fun mark(element: JetBinaryExpression): List<TextRange> {
+    public val UNUSED_VALUE: PositioningStrategy<KtBinaryExpression> = object: PositioningStrategy<KtBinaryExpression>() {
+        override fun mark(element: KtBinaryExpression): List<TextRange> {
             return listOf(TextRange(element.getLeft()!!.startOffset, element.getOperationReference().endOffset))
         }
     }
 
-    public val USELESS_ELVIS: PositioningStrategy<JetBinaryExpression> = object: PositioningStrategy<JetBinaryExpression>() {
-        override fun mark(element: JetBinaryExpression): List<TextRange> {
+    public val USELESS_ELVIS: PositioningStrategy<KtBinaryExpression> = object: PositioningStrategy<KtBinaryExpression>() {
+        override fun mark(element: KtBinaryExpression): List<TextRange> {
             return listOf(TextRange(element.getOperationReference().startOffset, element.endOffset))
         }
     }
 
-    public val IMPORT_ALIAS: PositioningStrategy<JetImportDirective> = object: PositioningStrategy<JetImportDirective>() {
-        override fun mark(element: JetImportDirective): List<TextRange> {
+    public val IMPORT_ALIAS: PositioningStrategy<KtImportDirective> = object: PositioningStrategy<KtImportDirective>() {
+        override fun mark(element: KtImportDirective): List<TextRange> {
             element.aliasNameNode?.let { return markNode(it) }
             element.importedReference?.let {
-                if (it is JetQualifiedExpression) {
+                if (it is KtQualifiedExpression) {
                     it.selectorExpression?.let { return markElement(it) }
                 }
                 return markElement(it)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
index 4fe4a3caad0..48604b7315d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
@@ -25,15 +25,15 @@ import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory;
 import org.jetbrains.kotlin.diagnostics.Errors;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
-import org.jetbrains.kotlin.psi.JetTypeConstraint;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
+import org.jetbrains.kotlin.psi.KtTypeConstraint;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.renderer.DescriptorRendererOptions;
 import org.jetbrains.kotlin.renderer.MultiRenderer;
 import org.jetbrains.kotlin.renderer.Renderer;
 import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker.VarianceConflictDiagnosticData;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.util.MappedExtensionProvider;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
 
@@ -387,10 +387,10 @@ public class DefaultErrorMessages {
 
         MAP.put(IMPLICIT_CAST_TO_UNIT_OR_ANY, "Type is cast to ''{0}''. Please specify ''{0}'' as expected type, if you mean such cast",
                 RENDER_TYPE);
-        MAP.put(EXPRESSION_EXPECTED, "{0} is not an expression, and only expressions are allowed here", new Renderer<JetExpression>() {
+        MAP.put(EXPRESSION_EXPECTED, "{0} is not an expression, and only expressions are allowed here", new Renderer<KtExpression>() {
             @NotNull
             @Override
-            public String render(@NotNull JetExpression expression) {
+            public String render(@NotNull KtExpression expression) {
                 String expressionType = expression.toString();
                 return expressionType.substring(0, 1) +
                        expressionType.substring(1).toLowerCase();
@@ -477,10 +477,10 @@ public class DefaultErrorMessages {
         MAP.put(UNEXPECTED_SAFE_CALL, "Safe-call is not allowed here");
         MAP.put(UNNECESSARY_NOT_NULL_ASSERTION, "Unnecessary non-null assertion (!!) on a non-null receiver of type {0}", RENDER_TYPE);
         MAP.put(NOT_NULL_ASSERTION_ON_FUNCTION_LITERAL, "Non-null assertion (!!) is called on function literal");
-        MAP.put(NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER, "{0} does not refer to a type parameter of {1}", new Renderer<JetTypeConstraint>() {
+        MAP.put(NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER, "{0} does not refer to a type parameter of {1}", new Renderer<KtTypeConstraint>() {
             @NotNull
             @Override
-            public String render(@NotNull JetTypeConstraint typeConstraint) {
+            public String render(@NotNull KtTypeConstraint typeConstraint) {
                 //noinspection ConstantConditions
                 return typeConstraint.getSubjectTypeParameterName().getReferencedName();
             }
@@ -525,10 +525,10 @@ public class DefaultErrorMessages {
 
         MAP.put(INCONSISTENT_TYPE_PARAMETER_VALUES, "Type parameter {0} of ''{1}'' has inconsistent values: {2}", NAME, NAME, RENDER_COLLECTION_OF_TYPES);
 
-        MAP.put(EQUALITY_NOT_APPLICABLE, "Operator ''{0}'' cannot be applied to ''{1}'' and ''{2}''", new Renderer<JetSimpleNameExpression>() {
+        MAP.put(EQUALITY_NOT_APPLICABLE, "Operator ''{0}'' cannot be applied to ''{1}'' and ''{2}''", new Renderer<KtSimpleNameExpression>() {
             @NotNull
             @Override
-            public String render(@NotNull JetSimpleNameExpression nameExpression) {
+            public String render(@NotNull KtSimpleNameExpression nameExpression) {
                 //noinspection ConstantConditions
                 return nameExpression.getReferencedName();
             }
@@ -565,10 +565,10 @@ public class DefaultErrorMessages {
 
         MAP.put(FUNCTION_EXPECTED, "Expression ''{0}''{1} cannot be invoked as a function. " +
                                    "The function '" + OperatorNameConventions.INVOKE.asString() + "()' is not found",
-                ELEMENT_TEXT, new Renderer<JetType>() {
+                ELEMENT_TEXT, new Renderer<KtType>() {
                     @NotNull
                     @Override
-                    public String render(@NotNull JetType type) {
+                    public String render(@NotNull KtType type) {
                         if (type.isError()) return "";
                         return " of type '" + RENDER_TYPE.render(type) + "'";
                     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt
index 5e24e4025fb..ad33e953c15 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt
@@ -25,9 +25,9 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.diagnostics.rendering.TabledDescriptorRenderer.newTable
 import org.jetbrains.kotlin.diagnostics.rendering.TabledDescriptorRenderer.newText
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.Renderer
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -41,10 +41,10 @@ import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.Constrain
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.RECEIVER_POSITION
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.VALUE_PARAMETER_POSITION
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.Variance
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import java.io.PrintWriter
 import java.io.StringWriter
 
@@ -83,17 +83,17 @@ public object Renderers {
 
     public val ELEMENT_TEXT: Renderer<PsiElement> = Renderer { it.getText() }
 
-    public val DECLARATION_NAME: Renderer<JetNamedDeclaration> = Renderer { it.getNameAsSafeName().asString() }
+    public val DECLARATION_NAME: Renderer<KtNamedDeclaration> = Renderer { it.getNameAsSafeName().asString() }
 
-    public val RENDER_CLASS_OR_OBJECT: Renderer<JetClassOrObject> = Renderer {
-        classOrObject: JetClassOrObject ->
+    public val RENDER_CLASS_OR_OBJECT: Renderer<KtClassOrObject> = Renderer {
+        classOrObject: KtClassOrObject ->
         val name = if (classOrObject.getName() != null) " '" + classOrObject.getName() + "'" else ""
-        if (classOrObject is JetClass) "Class" + name else "Object" + name
+        if (classOrObject is KtClass) "Class" + name else "Object" + name
     }
 
     public val RENDER_CLASS_OR_OBJECT_NAME: Renderer<ClassDescriptor> = Renderer { it.renderKindWithName() }
 
-    public val RENDER_TYPE: Renderer<JetType> = Renderer { DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(it) }
+    public val RENDER_TYPE: Renderer<KtType> = Renderer { DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(it) }
 
     public val RENDER_POSITION_VARIANCE: Renderer<Variance> = Renderer {
         variance: Variance ->
@@ -179,18 +179,18 @@ public object Renderers {
             val receiverType = DescriptorUtils.getReceiverParameterType(substitutedDescriptor.getExtensionReceiverParameter())
 
             val errorPositions = Sets.newHashSet<ConstraintPosition>()
-            val parameterTypes = Lists.newArrayList<JetType>()
+            val parameterTypes = Lists.newArrayList<KtType>()
             for (valueParameterDescriptor in substitutedDescriptor.getValueParameters()) {
                 parameterTypes.add(valueParameterDescriptor.getType())
                 if (valueParameterDescriptor.getIndex() >= inferenceErrorData.valueArgumentsTypes.size()) continue
                 val actualType = inferenceErrorData.valueArgumentsTypes.get(valueParameterDescriptor.getIndex())
-                if (!JetTypeChecker.DEFAULT.isSubtypeOf(actualType, valueParameterDescriptor.getType())) {
+                if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(actualType, valueParameterDescriptor.getType())) {
                     errorPositions.add(VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.getIndex()))
                 }
             }
 
             if (receiverType != null && inferenceErrorData.receiverArgumentType != null
-                && !JetTypeChecker.DEFAULT.isSubtypeOf(inferenceErrorData.receiverArgumentType, receiverType)) {
+                && !KotlinTypeChecker.DEFAULT.isSubtypeOf(inferenceErrorData.receiverArgumentType, receiverType)) {
                 errorPositions.add(RECEIVER_POSITION.position())
             }
 
@@ -279,11 +279,11 @@ public object Renderers {
                 .table(newTable()
                                .descriptor(inferenceErrorData.descriptor))
 
-        var violatedUpperBound: JetType? = null
+        var violatedUpperBound: KtType? = null
         for (upperBound in typeParameterDescriptor.getUpperBounds()) {
             val upperBoundWithSubstitutedInferredTypes = systemWithoutWeakConstraints.getResultingSubstitutor().substitute(upperBound, Variance.INVARIANT)
             if (upperBoundWithSubstitutedInferredTypes != null
-                && !JetTypeChecker.DEFAULT.isSubtypeOf(inferredValueForTypeParameter, upperBoundWithSubstitutedInferredTypes)) {
+                && !KotlinTypeChecker.DEFAULT.isSubtypeOf(inferredValueForTypeParameter, upperBoundWithSubstitutedInferredTypes)) {
                 violatedUpperBound = upperBoundWithSubstitutedInferredTypes
                 break
             }
@@ -356,9 +356,9 @@ public object Renderers {
         }.toString()
     }
 
-    private fun renderTypes(types: Collection<JetType>) = StringUtil.join(types, { RENDER_TYPE.render(it) }, ", ")
+    private fun renderTypes(types: Collection<KtType>) = StringUtil.join(types, { RENDER_TYPE.render(it) }, ", ")
 
-    public val RENDER_COLLECTION_OF_TYPES: Renderer<Collection<JetType>> = Renderer { renderTypes(it) }
+    public val RENDER_COLLECTION_OF_TYPES: Renderer<Collection<KtType>> = Renderer { renderTypes(it) }
 
     private fun renderConstraintSystem(constraintSystem: ConstraintSystem, renderTypeBounds: Renderer<TypeBounds>): String {
         val typeVariables = constraintSystem.getTypeVariables()
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/TabledDescriptorRenderer.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/TabledDescriptorRenderer.java
index d3fd0ed6605..ddf881963e3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/TabledDescriptorRenderer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/TabledDescriptorRenderer.java
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.diagnostics.rendering.TabledDescriptorRenderer.TextR
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.renderer.Renderer;
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Iterator;
 import java.util.List;
@@ -50,11 +50,11 @@ public class TabledDescriptorRenderer {
         }
 
         public static class FunctionArgumentsRow implements TableRow {
-            public final JetType receiverType;
-            public final List<JetType> argumentTypes;
+            public final KtType receiverType;
+            public final List<KtType> argumentTypes;
             public final Predicate<ConstraintPosition> isErrorPosition;
 
-            public FunctionArgumentsRow(JetType receiverType, List<JetType> argumentTypes, Predicate<ConstraintPosition> isErrorPosition) {
+            public FunctionArgumentsRow(KtType receiverType, List<KtType> argumentTypes, Predicate<ConstraintPosition> isErrorPosition) {
                 this.receiverType = receiverType;
                 this.argumentTypes = argumentTypes;
                 this.isErrorPosition = isErrorPosition;
@@ -68,13 +68,13 @@ public class TabledDescriptorRenderer {
             return this;
         }
 
-        public TableRenderer functionArgumentTypeList(@Nullable JetType receiverType, @NotNull List<JetType> argumentTypes) {
+        public TableRenderer functionArgumentTypeList(@Nullable KtType receiverType, @NotNull List<KtType> argumentTypes) {
 
             return functionArgumentTypeList(receiverType, argumentTypes, Predicates.<ConstraintPosition>alwaysFalse());
         }
 
-        public TableRenderer functionArgumentTypeList(@Nullable JetType receiverType,
-                @NotNull List<JetType> argumentTypes,
+        public TableRenderer functionArgumentTypeList(@Nullable KtType receiverType,
+                @NotNull List<KtType> argumentTypes,
                 @NotNull Predicate<ConstraintPosition> isErrorPosition) {
             rows.add(new FunctionArgumentsRow(receiverType, argumentTypes, isErrorPosition));
             return this;
@@ -156,7 +156,7 @@ public class TabledDescriptorRenderer {
     }
 
     @NotNull
-    public Renderer<JetType> getTypeRenderer() {
+    public Renderer<KtType> getTypeRenderer() {
         return Renderers.RENDER_TYPE;
     }
 
@@ -183,7 +183,7 @@ public class TabledDescriptorRenderer {
         }
     }
 
-    private void renderFunctionArguments(@Nullable JetType receiverType, @NotNull List<JetType> argumentTypes, StringBuilder result) {
+    private void renderFunctionArguments(@Nullable KtType receiverType, @NotNull List<KtType> argumentTypes, StringBuilder result) {
         boolean hasReceiver = receiverType != null;
         if (hasReceiver) {
             result.append("receiver: ");
@@ -196,8 +196,8 @@ public class TabledDescriptorRenderer {
         }
 
         result.append("(");
-        for (Iterator<JetType> iterator = argumentTypes.iterator(); iterator.hasNext(); ) {
-            JetType argumentType = iterator.next();
+        for (Iterator<KtType> iterator = argumentTypes.iterator(); iterator.hasNext(); ) {
+            KtType argumentType = iterator.next();
             String renderedArgument = getTypeRenderer().render(argumentType);
 
             result.append(renderedArgument);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/extensions/ExternalDeclarationsProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/extensions/ExternalDeclarationsProvider.kt
index 86d7f999f36..15dddabe7d7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/extensions/ExternalDeclarationsProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/extensions/ExternalDeclarationsProvider.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.extensions
 
 import org.jetbrains.kotlin.extensions.ProjectExtensionDescriptor
 import org.jetbrains.kotlin.analyzer.ModuleInfo
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
 public interface ExternalDeclarationsProvider {
     companion object : ProjectExtensionDescriptor<ExternalDeclarationsProvider>(
@@ -26,5 +26,5 @@ public interface ExternalDeclarationsProvider {
             javaClass<ExternalDeclarationsProvider>()
     )
 
-    public fun getExternalDeclarations(moduleInfo: ModuleInfo?): Collection<JetFile>
+    public fun getExternalDeclarations(moduleInfo: ModuleInfo?): Collection<KtFile>
 }
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/idea/JetFileType.java b/compiler/frontend/src/org/jetbrains/kotlin/idea/KotlinFileType.java
similarity index 91%
rename from compiler/frontend/src/org/jetbrains/kotlin/idea/JetFileType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/idea/KotlinFileType.java
index 6da6338c2dd..52aaf684da3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/idea/JetFileType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/idea/KotlinFileType.java
@@ -23,9 +23,9 @@ import org.jetbrains.annotations.NotNull;
 
 import javax.swing.*;
 
-public class JetFileType extends LanguageFileType {
+public class KotlinFileType extends LanguageFileType {
     public static final String EXTENSION = "kt";
-    public static final JetFileType INSTANCE = new JetFileType();
+    public static final KotlinFileType INSTANCE = new KotlinFileType();
 
     private final NotNullLazyValue<Icon> myIcon = new NotNullLazyValue<Icon>() {
         @NotNull
@@ -35,7 +35,7 @@ public class JetFileType extends LanguageFileType {
         }
     };
 
-    private JetFileType() {
+    private KotlinFileType() {
         super(KotlinLanguage.INSTANCE);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/idea/MainFunctionDetector.java b/compiler/frontend/src/org/jetbrains/kotlin/idea/MainFunctionDetector.java
index ff8a5e0f855..a97edca4dcb 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/idea/MainFunctionDetector.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/idea/MainFunctionDetector.java
@@ -21,14 +21,14 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.psi.JetAnnotationEntry;
-import org.jetbrains.kotlin.psi.JetDeclaration;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
+import org.jetbrains.kotlin.psi.KtAnnotationEntry;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationUtilKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeProjection;
 import org.jetbrains.kotlin.types.Variance;
 
@@ -36,14 +36,14 @@ import java.util.Collection;
 import java.util.List;
 
 public class MainFunctionDetector {
-    private final NotNullFunction<JetNamedFunction, FunctionDescriptor> getFunctionDescriptor;
+    private final NotNullFunction<KtNamedFunction, FunctionDescriptor> getFunctionDescriptor;
 
     /** Assumes that the function declaration is already resolved and the descriptor can be found in the {@code bindingContext}. */
     public MainFunctionDetector(@NotNull final BindingContext bindingContext) {
-        this.getFunctionDescriptor = new NotNullFunction<JetNamedFunction, FunctionDescriptor>() {
+        this.getFunctionDescriptor = new NotNullFunction<KtNamedFunction, FunctionDescriptor>() {
             @NotNull
             @Override
-            public FunctionDescriptor fun(JetNamedFunction function) {
+            public FunctionDescriptor fun(KtNamedFunction function) {
                 SimpleFunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, function);
                 if (functionDescriptor == null) {
                     throw new IllegalStateException("No descriptor resolved for " + function + " " + function.getText());
@@ -53,15 +53,15 @@ public class MainFunctionDetector {
         };
     }
 
-    public MainFunctionDetector(@NotNull NotNullFunction<JetNamedFunction, FunctionDescriptor> functionResolver) {
+    public MainFunctionDetector(@NotNull NotNullFunction<KtNamedFunction, FunctionDescriptor> functionResolver) {
         this.getFunctionDescriptor = functionResolver;
     }
 
-    public boolean hasMain(@NotNull List<JetDeclaration> declarations) {
+    public boolean hasMain(@NotNull List<KtDeclaration> declarations) {
         return findMainFunction(declarations) != null;
     }
 
-    public boolean isMain(@NotNull JetNamedFunction function) {
+    public boolean isMain(@NotNull KtNamedFunction function) {
         if (function.isLocal()) {
             return false;
         }
@@ -89,13 +89,13 @@ public class MainFunctionDetector {
         if (parameters.size() != 1) return false;
 
         ValueParameterDescriptor parameter = parameters.get(0);
-        JetType parameterType = parameter.getType();
+        KtType parameterType = parameter.getType();
         if (!KotlinBuiltIns.isArray(parameterType)) return false;
 
         List<TypeProjection> typeArguments = parameterType.getArguments();
         if (typeArguments.size() != 1) return false;
 
-        JetType typeArgument = typeArguments.get(0).getType();
+        KtType typeArgument = typeArguments.get(0).getType();
         if (!KotlinBuiltIns.isString(typeArgument)) {
             return false;
         }
@@ -112,9 +112,9 @@ public class MainFunctionDetector {
     }
 
     @Nullable
-    public JetNamedFunction getMainFunction(@NotNull Collection<JetFile> files) {
-        for (JetFile file : files) {
-            JetNamedFunction mainFunction = findMainFunction(file.getDeclarations());
+    public KtNamedFunction getMainFunction(@NotNull Collection<KtFile> files) {
+        for (KtFile file : files) {
+            KtNamedFunction mainFunction = findMainFunction(file.getDeclarations());
             if (mainFunction != null) {
                 return mainFunction;
             }
@@ -123,10 +123,10 @@ public class MainFunctionDetector {
     }
 
     @Nullable
-    private JetNamedFunction findMainFunction(@NotNull List<JetDeclaration> declarations) {
-        for (JetDeclaration declaration : declarations) {
-            if (declaration instanceof JetNamedFunction) {
-                JetNamedFunction candidateFunction = (JetNamedFunction) declaration;
+    private KtNamedFunction findMainFunction(@NotNull List<KtDeclaration> declarations) {
+        for (KtDeclaration declaration : declarations) {
+            if (declaration instanceof KtNamedFunction) {
+                KtNamedFunction candidateFunction = (KtNamedFunction) declaration;
                 if (isMain(candidateFunction)) {
                     return candidateFunction;
                 }
@@ -145,8 +145,8 @@ public class MainFunctionDetector {
         return functionDescriptor.getName().asString();
     }
 
-    private static boolean hasAnnotationWithExactNumberOfArguments(@NotNull JetNamedFunction function, int number) {
-        for (JetAnnotationEntry entry : function.getAnnotationEntries()) {
+    private static boolean hasAnnotationWithExactNumberOfArguments(@NotNull KtNamedFunction function, int number) {
+        for (KtAnnotationEntry entry : function.getAnnotationEntries()) {
             if (entry.getValueArguments().size() == number) {
                 return true;
             }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/incremental/KotlinLookupLocation.kt b/compiler/frontend/src/org/jetbrains/kotlin/incremental/KotlinLookupLocation.kt
index 288e23f5bdd..6db271ec1ff 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/incremental/KotlinLookupLocation.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/incremental/KotlinLookupLocation.kt
@@ -17,6 +17,6 @@
 package org.jetbrains.kotlin.incremental
 
 import org.jetbrains.kotlin.incremental.components.LookupLocation
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 
-class KotlinLookupLocation(val element: JetElement) : LookupLocation
+class KotlinLookupLocation(val element: KtElement) : LookupLocation
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/incremental/utils.kt b/compiler/frontend/src/org/jetbrains/kotlin/incremental/utils.kt
index 944582cf2ba..049b17bbc9d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/incremental/utils.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/incremental/utils.kt
@@ -26,9 +26,9 @@ import org.jetbrains.kotlin.incremental.components.ScopeKind
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.doNotAnalyze
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 
-public fun LookupTracker.record(from: LookupLocation, inScope: JetScope, name: Name) {
+public fun LookupTracker.record(from: LookupLocation, inScope: KtScope, name: Name) {
     if (this == LookupTracker.DO_NOTHING || from is NoLookupLocation) return
 
     if (from !is KotlinLookupLocation) throw AssertionError("Unexpected location type: ${from.javaClass}")
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/lexer/KDocToken.java b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/lexer/KDocToken.java
index 8384c28e3e8..aea59f749cb 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/lexer/KDocToken.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/lexer/KDocToken.java
@@ -18,9 +18,9 @@ package org.jetbrains.kotlin.kdoc.lexer;
 
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.lexer.JetToken;
+import org.jetbrains.kotlin.lexer.KtToken;
 
-public class KDocToken extends JetToken {
+public class KDocToken extends KtToken {
     public KDocToken(@NotNull @NonNls String debugName) {
         super(debugName);
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/lexer/_KDocLexer.java b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/lexer/_KDocLexer.java
index eb97a82e4a4..27f277b3471 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/lexer/_KDocLexer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/lexer/_KDocLexer.java
@@ -7,7 +7,7 @@ import com.intellij.psi.TokenType;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.util.text.CharArrayUtil;
 import java.lang.Character;
-import org.jetbrains.kotlin.lexer.JetTokens;
+
 import org.jetbrains.kotlin.kdoc.parser.KDocKnownTag;
 
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/parser/KDocLinkParser.kt b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/parser/KDocLinkParser.kt
index 16f596c9ba3..957b204a9d3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/parser/KDocLinkParser.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/parser/KDocLinkParser.kt
@@ -20,8 +20,8 @@ import com.intellij.lang.PsiParser
 import com.intellij.psi.tree.IElementType
 import com.intellij.lang.PsiBuilder
 import com.intellij.lang.ASTNode
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.lexer.JetLexer
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.lexer.KotlinLexer
 import com.intellij.lang.PsiBuilderFactory
 import kotlin.platform.*
 
@@ -36,7 +36,7 @@ class KDocLinkParser(): PsiParser {
             val project = parentElement.getProject()
             val builder = PsiBuilderFactory.getInstance().createBuilder(project,
                                                                         chameleon,
-                                                                        JetLexer(),
+                    KotlinLexer(),
                                                                         root.getLanguage(),
                                                                         chameleon.getText())
             val parser = KDocLinkParser()
@@ -47,19 +47,19 @@ class KDocLinkParser(): PsiParser {
 
     override fun parse(root: IElementType, builder: PsiBuilder): ASTNode {
         val rootMarker = builder.mark()
-        val hasLBracket = builder.getTokenType() == JetTokens.LBRACKET
+        val hasLBracket = builder.getTokenType() == KtTokens.LBRACKET
         if (hasLBracket) {
             builder.advanceLexer()
         }
         parseQualifiedName(builder)
         if (hasLBracket) {
-            if (!builder.eof() && builder.getTokenType() != JetTokens.RBRACKET) {
+            if (!builder.eof() && builder.getTokenType() != KtTokens.RBRACKET) {
                 builder.error("Closing bracket expected")
-                while (!builder.eof() && builder.getTokenType() != JetTokens.RBRACKET) {
+                while (!builder.eof() && builder.getTokenType() != KtTokens.RBRACKET) {
                     builder.advanceLexer()
                 }
             }
-            if (builder.getTokenType() == JetTokens.RBRACKET) {
+            if (builder.getTokenType() == KtTokens.RBRACKET) {
                 builder.advanceLexer()
             }
         }
@@ -86,7 +86,7 @@ class KDocLinkParser(): PsiParser {
             }
             builder.advanceLexer()
             marker.done(KDocElementTypes.KDOC_NAME)
-            if (builder.getTokenType() != JetTokens.DOT) {
+            if (builder.getTokenType() != KtTokens.DOT) {
                 break
             }
             marker = marker.precede()
@@ -94,5 +94,5 @@ class KDocLinkParser(): PsiParser {
         }
     }
 
-    private fun isName(tokenType: IElementType?) = tokenType == JetTokens.IDENTIFIER || tokenType in JetTokens.KEYWORDS
+    private fun isName(tokenType: IElementType?) = tokenType == KtTokens.IDENTIFIER || tokenType in KtTokens.KEYWORDS
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/api/KDoc.kt b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/api/KDoc.kt
index 186a489ef50..5ac18e859d7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/api/KDoc.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/api/KDoc.kt
@@ -18,12 +18,12 @@ package org.jetbrains.kotlin.kdoc.psi.api
 
 import com.intellij.psi.PsiComment
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocSection
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.kdoc.parser.KDocKnownTag
 
 // Don't implement JetElement (or it will be treated as statement)
 public interface KDoc : PsiComment {
-    public fun getOwner(): JetDeclaration?
+    public fun getOwner(): KtDeclaration?
     public fun getDefaultSection(): KDocSection
     public fun findSectionByName(name: String): KDocSection?
     public fun findSectionByTag(tag: KDocKnownTag): KDocSection?
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocImpl.kt
index 666340bbb81..d2d7902aec2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocImpl.kt
@@ -22,8 +22,8 @@ import com.intellij.psi.tree.IElementType
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.kdoc.lexer.KDocTokens
 import org.jetbrains.kotlin.kdoc.psi.api.KDoc
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.getChildOfType
 import org.jetbrains.kotlin.psi.psiUtil.getChildrenOfType
@@ -35,9 +35,9 @@ public class KDocImpl(buffer: CharSequence?) : LazyParseablePsiElement(KDocToken
 
     override fun toString(): String = getNode().getElementType().toString()
 
-    override fun getTokenType(): IElementType = JetTokens.DOC_COMMENT
+    override fun getTokenType(): IElementType = KtTokens.DOC_COMMENT
 
-    override fun getOwner(): JetDeclaration? = getParentOfType<JetDeclaration>(true)
+    override fun getOwner(): KtDeclaration? = getParentOfType<KtDeclaration>(true)
 
     override fun getDefaultSection(): KDocSection = getChildOfType<KDocSection>()!!
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocLink.kt b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocLink.kt
index e7d1182d95f..6265e2d08fe 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocLink.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocLink.kt
@@ -20,11 +20,11 @@ import com.intellij.lang.ASTNode
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiReference
 import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry
-import org.jetbrains.kotlin.psi.JetElementImpl
+import org.jetbrains.kotlin.psi.KtElementImpl
 import org.jetbrains.kotlin.kdoc.psi.api.KDoc
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 
-public class KDocLink(node: ASTNode) : JetElementImpl(node) {
+public class KDocLink(node: ASTNode) : KtElementImpl(node) {
     public fun getLinkText(): String = getLinkTextRange().substring(getText())
 
     public fun getLinkTextRange(): TextRange {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocName.kt b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocName.kt
index 7be79583574..6eca71c76be 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocName.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocName.kt
@@ -17,17 +17,17 @@
 package org.jetbrains.kotlin.kdoc.psi.impl
 
 import com.intellij.lang.ASTNode
-import org.jetbrains.kotlin.psi.JetElementImpl
+import org.jetbrains.kotlin.psi.KtElementImpl
 import org.jetbrains.kotlin.kdoc.psi.api.KDoc
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import com.intellij.openapi.util.TextRange
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.psiUtil.getChildOfType
 
 /**
  * A single part of a qualified name in the tag subject or link.
  */
-public class KDocName(node: ASTNode): JetElementImpl(node) {
+public class KDocName(node: ASTNode): KtElementImpl(node) {
     public fun getContainingDoc(): KDoc {
         val kdoc = getStrictParentOfType<KDoc>()
         return kdoc ?: throw IllegalStateException("KDocName must be inside a KDoc")
@@ -45,7 +45,7 @@ public class KDocName(node: ASTNode): JetElementImpl(node) {
      * the range of the element excluding the qualifier and dot, if present).
      */
     public fun getNameTextRange(): TextRange {
-        val dot = getNode().findChildByType(JetTokens.DOT)
+        val dot = getNode().findChildByType(KtTokens.DOT)
         val textRange = getTextRange()
         val nameStart = if (dot != null) dot.getTextRange().getEndOffset() - textRange.getStartOffset() else 0
         return TextRange(nameStart, textRange.getLength())
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetTokens.java b/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetTokens.java
deleted file mode 100644
index 47f016298cc..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetTokens.java
+++ /dev/null
@@ -1,245 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.lexer;
-
-import com.intellij.psi.TokenType;
-import com.intellij.psi.tree.IElementType;
-import com.intellij.psi.tree.TokenSet;
-import org.jetbrains.kotlin.kdoc.lexer.KDocTokens;
-
-public interface JetTokens {
-    JetToken EOF   = new JetToken("EOF");
-
-    JetToken BLOCK_COMMENT     = new JetToken("BLOCK_COMMENT");
-    JetToken EOL_COMMENT       = new JetToken("EOL_COMMENT");
-    JetToken SHEBANG_COMMENT   = new JetToken("SHEBANG_COMMENT");
-
-    //JetToken DOC_COMMENT   = new JetToken("DOC_COMMENT");
-    IElementType DOC_COMMENT   = KDocTokens.KDOC;
-
-    IElementType WHITE_SPACE = TokenType.WHITE_SPACE;
-
-    JetToken INTEGER_LITERAL    = new JetToken("INTEGER_LITERAL");
-    JetToken FLOAT_LITERAL      = new JetToken("FLOAT_CONSTANT");
-    JetToken CHARACTER_LITERAL  = new JetToken("CHARACTER_LITERAL");
-
-    JetToken CLOSING_QUOTE = new JetToken("CLOSING_QUOTE");
-    JetToken OPEN_QUOTE = new JetToken("OPEN_QUOTE");
-    JetToken REGULAR_STRING_PART = new JetToken("REGULAR_STRING_PART");
-    JetToken ESCAPE_SEQUENCE = new JetToken("ESCAPE_SEQUENCE");
-    JetToken SHORT_TEMPLATE_ENTRY_START = new JetToken("SHORT_TEMPLATE_ENTRY_START");
-    JetToken LONG_TEMPLATE_ENTRY_START = new JetToken("LONG_TEMPLATE_ENTRY_START");
-    JetToken LONG_TEMPLATE_ENTRY_END = new JetToken("LONG_TEMPLATE_ENTRY_END");
-    JetToken DANGLING_NEWLINE = new JetToken("DANGLING_NEWLINE");
-
-    JetKeywordToken PACKAGE_KEYWORD          = JetKeywordToken.keyword("package");
-    JetKeywordToken AS_KEYWORD               = JetKeywordToken.keyword("as");
-    JetKeywordToken TYPE_ALIAS_KEYWORD       = JetKeywordToken.keyword("typealias");
-    JetKeywordToken CLASS_KEYWORD            = JetKeywordToken.keyword("class");
-    JetKeywordToken THIS_KEYWORD             = JetKeywordToken.keyword("this");
-    JetKeywordToken SUPER_KEYWORD            = JetKeywordToken.keyword("super");
-    JetKeywordToken VAL_KEYWORD              = JetKeywordToken.keyword("val");
-    JetKeywordToken VAR_KEYWORD              = JetKeywordToken.keyword("var");
-    JetKeywordToken FUN_KEYWORD              = JetKeywordToken.keyword("fun");
-    JetKeywordToken FOR_KEYWORD              = JetKeywordToken.keyword("for");
-    JetKeywordToken NULL_KEYWORD             = JetKeywordToken.keyword("null");
-    JetKeywordToken TRUE_KEYWORD             = JetKeywordToken.keyword("true");
-    JetKeywordToken FALSE_KEYWORD            = JetKeywordToken.keyword("false");
-    JetKeywordToken IS_KEYWORD               = JetKeywordToken.keyword("is");
-    JetModifierKeywordToken IN_KEYWORD       = JetModifierKeywordToken.keywordModifier("in");
-    JetKeywordToken THROW_KEYWORD            = JetKeywordToken.keyword("throw");
-    JetKeywordToken RETURN_KEYWORD           = JetKeywordToken.keyword("return");
-    JetKeywordToken BREAK_KEYWORD            = JetKeywordToken.keyword("break");
-    JetKeywordToken CONTINUE_KEYWORD         = JetKeywordToken.keyword("continue");
-    JetKeywordToken OBJECT_KEYWORD           = JetKeywordToken.keyword("object");
-    JetKeywordToken IF_KEYWORD               = JetKeywordToken.keyword("if");
-    JetKeywordToken TRY_KEYWORD              = JetKeywordToken.keyword("try");
-    JetKeywordToken ELSE_KEYWORD             = JetKeywordToken.keyword("else");
-    JetKeywordToken WHILE_KEYWORD            = JetKeywordToken.keyword("while");
-    JetKeywordToken DO_KEYWORD               = JetKeywordToken.keyword("do");
-    JetKeywordToken WHEN_KEYWORD             = JetKeywordToken.keyword("when");
-    JetKeywordToken INTERFACE_KEYWORD        = JetKeywordToken.keyword("interface");
-    // TODO: Discuss "This" keyword
-    JetKeywordToken CAPITALIZED_THIS_KEYWORD = JetKeywordToken.keyword("This");
-
-
-    JetToken AS_SAFE = JetKeywordToken.keyword("AS_SAFE");//new JetToken("as?");
-
-    JetToken IDENTIFIER = new JetToken("IDENTIFIER");
-
-    JetToken FIELD_IDENTIFIER = new JetToken("FIELD_IDENTIFIER");
-    JetSingleValueToken LBRACKET    = new JetSingleValueToken("LBRACKET", "[");
-    JetSingleValueToken RBRACKET    = new JetSingleValueToken("RBRACKET", "]");
-    JetSingleValueToken LBRACE      = new JetSingleValueToken("LBRACE", "{");
-    JetSingleValueToken RBRACE      = new JetSingleValueToken("RBRACE", "}");
-    JetSingleValueToken LPAR        = new JetSingleValueToken("LPAR", "(");
-    JetSingleValueToken RPAR        = new JetSingleValueToken("RPAR", ")");
-    JetSingleValueToken DOT         = new JetSingleValueToken("DOT", ".");
-    JetSingleValueToken PLUSPLUS    = new JetSingleValueToken("PLUSPLUS", "++");
-    JetSingleValueToken MINUSMINUS  = new JetSingleValueToken("MINUSMINUS", "--");
-    JetSingleValueToken MUL         = new JetSingleValueToken("MUL", "*");
-    JetSingleValueToken PLUS        = new JetSingleValueToken("PLUS", "+");
-    JetSingleValueToken MINUS       = new JetSingleValueToken("MINUS", "-");
-    JetSingleValueToken EXCL        = new JetSingleValueToken("EXCL", "!");
-    JetSingleValueToken DIV         = new JetSingleValueToken("DIV", "/");
-    JetSingleValueToken PERC        = new JetSingleValueToken("PERC", "%");
-    JetSingleValueToken LT          = new JetSingleValueToken("LT", "<");
-    JetSingleValueToken GT          = new JetSingleValueToken("GT", ">");
-    JetSingleValueToken LTEQ        = new JetSingleValueToken("LTEQ", "<=");
-    JetSingleValueToken GTEQ        = new JetSingleValueToken("GTEQ", ">=");
-    JetSingleValueToken EQEQEQ      = new JetSingleValueToken("EQEQEQ", "===");
-    JetSingleValueToken ARROW       = new JetSingleValueToken("ARROW", "->");
-    JetSingleValueToken DOUBLE_ARROW       = new JetSingleValueToken("DOUBLE_ARROW", "=>");
-    JetSingleValueToken EXCLEQEQEQ  = new JetSingleValueToken("EXCLEQEQEQ", "!==");
-    JetSingleValueToken EQEQ        = new JetSingleValueToken("EQEQ", "==");
-    JetSingleValueToken EXCLEQ      = new JetSingleValueToken("EXCLEQ", "!=");
-    JetSingleValueToken EXCLEXCL    = new JetSingleValueToken("EXCLEXCL", "!!");
-    JetSingleValueToken ANDAND      = new JetSingleValueToken("ANDAND", "&&");
-    JetSingleValueToken OROR        = new JetSingleValueToken("OROR", "||");
-    JetSingleValueToken SAFE_ACCESS = new JetSingleValueToken("SAFE_ACCESS", "?.");
-    JetSingleValueToken ELVIS       = new JetSingleValueToken("ELVIS", "?:");
-    JetSingleValueToken QUEST       = new JetSingleValueToken("QUEST", "?");
-    JetSingleValueToken COLONCOLON  = new JetSingleValueToken("COLONCOLON", "::");
-    JetSingleValueToken COLON       = new JetSingleValueToken("COLON", ":");
-    JetSingleValueToken SEMICOLON   = new JetSingleValueToken("SEMICOLON", ";");
-    JetSingleValueToken DOUBLE_SEMICOLON   = new JetSingleValueToken("DOUBLE_SEMICOLON", ";;");
-    JetSingleValueToken RANGE       = new JetSingleValueToken("RANGE", "..");
-    JetSingleValueToken EQ          = new JetSingleValueToken("EQ", "=");
-    JetSingleValueToken MULTEQ      = new JetSingleValueToken("MULTEQ", "*=");
-    JetSingleValueToken DIVEQ       = new JetSingleValueToken("DIVEQ", "/=");
-    JetSingleValueToken PERCEQ      = new JetSingleValueToken("PERCEQ", "%=");
-    JetSingleValueToken PLUSEQ      = new JetSingleValueToken("PLUSEQ", "+=");
-    JetSingleValueToken MINUSEQ     = new JetSingleValueToken("MINUSEQ", "-=");
-    JetKeywordToken NOT_IN      = JetKeywordToken.keyword("NOT_IN", "!in");
-    JetKeywordToken NOT_IS      = JetKeywordToken.keyword("NOT_IS", "!is");
-    JetSingleValueToken HASH        = new JetSingleValueToken("HASH", "#");
-    JetSingleValueToken AT          = new JetSingleValueToken("AT", "@");
-
-    JetSingleValueToken COMMA       = new JetSingleValueToken("COMMA", ",");
-
-    JetToken EOL_OR_SEMICOLON   = new JetToken("EOL_OR_SEMICOLON");
-    JetKeywordToken FILE_KEYWORD    = JetKeywordToken.softKeyword("file");
-    JetKeywordToken FIELD_KEYWORD     = JetKeywordToken.softKeyword("field");
-    JetKeywordToken PROPERTY_KEYWORD     = JetKeywordToken.softKeyword("property");
-    JetKeywordToken RECEIVER_KEYWORD     = JetKeywordToken.softKeyword("receiver");
-    JetKeywordToken PARAM_KEYWORD     = JetKeywordToken.softKeyword("param");
-    JetKeywordToken SETPARAM_KEYWORD  = JetKeywordToken.softKeyword("setparam");
-    JetKeywordToken IMPORT_KEYWORD    = JetKeywordToken.softKeyword("import");
-    JetKeywordToken WHERE_KEYWORD     = JetKeywordToken.softKeyword("where");
-    JetKeywordToken BY_KEYWORD        = JetKeywordToken.softKeyword("by");
-    JetKeywordToken GET_KEYWORD       = JetKeywordToken.softKeyword("get");
-    JetKeywordToken SET_KEYWORD       = JetKeywordToken.softKeyword("set");
-    JetKeywordToken CONSTRUCTOR_KEYWORD = JetKeywordToken.softKeyword("constructor");
-    JetKeywordToken INIT_KEYWORD        = JetKeywordToken.softKeyword("init");
-
-    JetModifierKeywordToken ABSTRACT_KEYWORD  = JetModifierKeywordToken.softKeywordModifier("abstract");
-    JetModifierKeywordToken ENUM_KEYWORD      = JetModifierKeywordToken.softKeywordModifier("enum");
-    JetModifierKeywordToken OPEN_KEYWORD      = JetModifierKeywordToken.softKeywordModifier("open");
-    JetModifierKeywordToken INNER_KEYWORD     = JetModifierKeywordToken.softKeywordModifier("inner");
-    JetModifierKeywordToken OVERRIDE_KEYWORD  = JetModifierKeywordToken.softKeywordModifier("override");
-    JetModifierKeywordToken PRIVATE_KEYWORD   = JetModifierKeywordToken.softKeywordModifier("private");
-    JetModifierKeywordToken PUBLIC_KEYWORD    = JetModifierKeywordToken.softKeywordModifier("public");
-    JetModifierKeywordToken INTERNAL_KEYWORD  = JetModifierKeywordToken.softKeywordModifier("internal");
-    JetModifierKeywordToken PROTECTED_KEYWORD = JetModifierKeywordToken.softKeywordModifier("protected");
-    JetKeywordToken CATCH_KEYWORD     = JetKeywordToken.softKeyword("catch");
-    JetModifierKeywordToken OUT_KEYWORD       = JetModifierKeywordToken.softKeywordModifier("out");
-    JetModifierKeywordToken VARARG_KEYWORD    = JetModifierKeywordToken.softKeywordModifier("vararg");
-    JetModifierKeywordToken REIFIED_KEYWORD   = JetModifierKeywordToken.softKeywordModifier("reified");
-    JetKeywordToken DYNAMIC_KEYWORD   = JetKeywordToken.softKeyword("dynamic");
-    JetModifierKeywordToken COMPANION_KEYWORD = JetModifierKeywordToken.softKeywordModifier("companion");
-    JetModifierKeywordToken SEALED_KEYWORD    = JetModifierKeywordToken.softKeywordModifier("sealed");
-
-    JetModifierKeywordToken DEFAULT_VISIBILITY_KEYWORD = PUBLIC_KEYWORD;
-
-    JetKeywordToken FINALLY_KEYWORD   = JetKeywordToken.softKeyword("finally");
-    JetModifierKeywordToken FINAL_KEYWORD     = JetModifierKeywordToken.softKeywordModifier("final");
-
-    JetModifierKeywordToken LATEINIT_KEYWORD = JetModifierKeywordToken.softKeywordModifier("lateinit");
-
-    JetModifierKeywordToken DATA_KEYWORD    = JetModifierKeywordToken.softKeywordModifier("data");
-    JetModifierKeywordToken INLINE_KEYWORD    = JetModifierKeywordToken.softKeywordModifier("inline");
-    JetModifierKeywordToken NOINLINE_KEYWORD    = JetModifierKeywordToken.softKeywordModifier("noinline");
-    JetModifierKeywordToken TAILREC_KEYWORD    = JetModifierKeywordToken.softKeywordModifier("tailrec");
-    JetModifierKeywordToken EXTERNAL_KEYWORD    = JetModifierKeywordToken.softKeywordModifier("external");
-    JetModifierKeywordToken ANNOTATION_KEYWORD    = JetModifierKeywordToken.softKeywordModifier("annotation");
-    JetModifierKeywordToken CROSSINLINE_KEYWORD    = JetModifierKeywordToken.softKeywordModifier("crossinline");
-    JetModifierKeywordToken OPERATOR_KEYWORD = JetModifierKeywordToken.softKeywordModifier("operator");
-    JetModifierKeywordToken INFIX_KEYWORD = JetModifierKeywordToken.softKeywordModifier("infix");
-
-    JetModifierKeywordToken CONST_KEYWORD = JetModifierKeywordToken.softKeywordModifier("const");
-
-    TokenSet KEYWORDS = TokenSet.create(PACKAGE_KEYWORD, AS_KEYWORD, TYPE_ALIAS_KEYWORD, CLASS_KEYWORD, INTERFACE_KEYWORD,
-                                        THIS_KEYWORD, SUPER_KEYWORD, VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, FOR_KEYWORD,
-                                        NULL_KEYWORD,
-                                        TRUE_KEYWORD, FALSE_KEYWORD, IS_KEYWORD,
-                                        IN_KEYWORD, THROW_KEYWORD, RETURN_KEYWORD, BREAK_KEYWORD, CONTINUE_KEYWORD, OBJECT_KEYWORD, IF_KEYWORD,
-                                        ELSE_KEYWORD, WHILE_KEYWORD, DO_KEYWORD, TRY_KEYWORD, WHEN_KEYWORD,
-                                        NOT_IN, NOT_IS, CAPITALIZED_THIS_KEYWORD, AS_SAFE
-    );
-
-    TokenSet SOFT_KEYWORDS = TokenSet.create(FILE_KEYWORD, IMPORT_KEYWORD, WHERE_KEYWORD, BY_KEYWORD, GET_KEYWORD,
-                                             SET_KEYWORD, ABSTRACT_KEYWORD, ENUM_KEYWORD, OPEN_KEYWORD, INNER_KEYWORD,
-                                             OVERRIDE_KEYWORD, PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD,
-                                             CATCH_KEYWORD, FINALLY_KEYWORD, OUT_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD, REIFIED_KEYWORD,
-                                             DYNAMIC_KEYWORD, COMPANION_KEYWORD, CONSTRUCTOR_KEYWORD, INIT_KEYWORD, SEALED_KEYWORD,
-                                             FIELD_KEYWORD, PROPERTY_KEYWORD, RECEIVER_KEYWORD, PARAM_KEYWORD, SETPARAM_KEYWORD,
-                                             LATEINIT_KEYWORD,
-                                             DATA_KEYWORD, INLINE_KEYWORD, NOINLINE_KEYWORD, TAILREC_KEYWORD, EXTERNAL_KEYWORD,
-                                             ANNOTATION_KEYWORD, CROSSINLINE_KEYWORD, CONST_KEYWORD, OPERATOR_KEYWORD, INFIX_KEYWORD
-    );
-
-    /*
-        This array is used in stub serialization:
-        1. Do not change order.
-        2. If you add an entry or change order, increase stub version.
-     */
-    JetModifierKeywordToken[] MODIFIER_KEYWORDS_ARRAY =
-            new JetModifierKeywordToken[] {
-                    ABSTRACT_KEYWORD, ENUM_KEYWORD, OPEN_KEYWORD, INNER_KEYWORD, OVERRIDE_KEYWORD, PRIVATE_KEYWORD,
-                    PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD, OUT_KEYWORD, IN_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD,
-                    REIFIED_KEYWORD, COMPANION_KEYWORD, SEALED_KEYWORD, LATEINIT_KEYWORD,
-                    DATA_KEYWORD, INLINE_KEYWORD, NOINLINE_KEYWORD, TAILREC_KEYWORD, EXTERNAL_KEYWORD, ANNOTATION_KEYWORD, CROSSINLINE_KEYWORD,
-                    CONST_KEYWORD, OPERATOR_KEYWORD, INFIX_KEYWORD
-            };
-
-    TokenSet MODIFIER_KEYWORDS = TokenSet.create(MODIFIER_KEYWORDS_ARRAY);
-
-    TokenSet VISIBILITY_MODIFIERS = TokenSet.create(PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD);
-
-    TokenSet WHITESPACES = TokenSet.create(TokenType.WHITE_SPACE);
-
-    /**
-     * Don't add KDocTokens to COMMENTS TokenSet, because it is used in JetParserDefinition.getCommentTokens(),
-     * and therefor all COMMENTS tokens will be ignored by PsiBuilder.
-     *
-     * @see org.jetbrains.kotlin.psi.JetPsiUtil#isInComment(com.intellij.psi.PsiElement)
-     */
-    TokenSet COMMENTS = TokenSet.create(EOL_COMMENT, BLOCK_COMMENT, DOC_COMMENT, SHEBANG_COMMENT);
-    TokenSet WHITE_SPACE_OR_COMMENT_BIT_SET = TokenSet.orSet(COMMENTS, TokenSet.create(WHITE_SPACE));
-
-    TokenSet STRINGS = TokenSet.create(CHARACTER_LITERAL, REGULAR_STRING_PART);
-    TokenSet OPERATIONS = TokenSet.create(AS_KEYWORD, AS_SAFE, IS_KEYWORD, IN_KEYWORD, DOT, PLUSPLUS, MINUSMINUS, EXCLEXCL, MUL, PLUS,
-                                          MINUS, EXCL, DIV, PERC, LT, GT, LTEQ, GTEQ, EQEQEQ, EXCLEQEQEQ, EQEQ, EXCLEQ, ANDAND, OROR,
-                                          SAFE_ACCESS, ELVIS,
-            //            MAP, FILTER,
-                                          RANGE, EQ, MULTEQ, DIVEQ, PERCEQ, PLUSEQ, MINUSEQ,
-                                          NOT_IN, NOT_IS,
-                                          IDENTIFIER);
-
-    TokenSet AUGMENTED_ASSIGNMENTS = TokenSet.create(PLUSEQ, MINUSEQ, MULTEQ, PERCEQ, DIVEQ);
-    TokenSet ALL_ASSIGNMENTS = TokenSet.create(EQ, PLUSEQ, MINUSEQ, MULTEQ, PERCEQ, DIVEQ);
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetLexer.java b/compiler/frontend/src/org/jetbrains/kotlin/lexer/KotlinLexer.java
similarity index 91%
rename from compiler/frontend/src/org/jetbrains/kotlin/lexer/JetLexer.java
rename to compiler/frontend/src/org/jetbrains/kotlin/lexer/KotlinLexer.java
index e880cb1b110..a141e4aa420 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetLexer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/lexer/KotlinLexer.java
@@ -20,8 +20,8 @@ import com.intellij.lexer.FlexAdapter;
 
 import java.io.Reader;
 
-public class JetLexer extends FlexAdapter {
-    public JetLexer() {
+public class KotlinLexer extends FlexAdapter {
+    public KotlinLexer() {
         super(new _JetLexer((Reader) null));
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetKeywordToken.java b/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtKeywordToken.java
similarity index 70%
rename from compiler/frontend/src/org/jetbrains/kotlin/lexer/JetKeywordToken.java
rename to compiler/frontend/src/org/jetbrains/kotlin/lexer/KtKeywordToken.java
index bd0c57696e5..a13e950ce3e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetKeywordToken.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtKeywordToken.java
@@ -19,29 +19,29 @@ package org.jetbrains.kotlin.lexer;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 
-public class JetKeywordToken extends JetSingleValueToken {
+public class KtKeywordToken extends KtSingleValueToken {
 
     /**
      * Generate keyword (identifier that has a keyword meaning in all possible contexts)
      */
-    public static JetKeywordToken keyword(String value) {
+    public static KtKeywordToken keyword(String value) {
         return keyword(value, value);
     }
 
-    public static JetKeywordToken keyword(String debugName, String value) {
-        return new JetKeywordToken(debugName, value, false);
+    public static KtKeywordToken keyword(String debugName, String value) {
+        return new KtKeywordToken(debugName, value, false);
     }
 
     /**
      * Generate soft keyword (identifier that has a keyword meaning only in some contexts)
      */
-    public static JetKeywordToken softKeyword(String value) {
-        return new JetKeywordToken(value, value, true);
+    public static KtKeywordToken softKeyword(String value) {
+        return new KtKeywordToken(value, value, true);
     }
 
     private final boolean myIsSoft;
 
-    protected JetKeywordToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value, boolean isSoft) {
+    protected KtKeywordToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value, boolean isSoft) {
         super(debugName, value);
         myIsSoft = isSoft;
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetModifierKeywordToken.java b/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtModifierKeywordToken.java
similarity index 70%
rename from compiler/frontend/src/org/jetbrains/kotlin/lexer/JetModifierKeywordToken.java
rename to compiler/frontend/src/org/jetbrains/kotlin/lexer/KtModifierKeywordToken.java
index 217d1e5ea3d..c83d08ec5ab 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetModifierKeywordToken.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtModifierKeywordToken.java
@@ -20,23 +20,23 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 
 /* Modifier keyword is a keyword that can be used in annotation position as part of modifier list.*/
-public final class JetModifierKeywordToken extends JetKeywordToken {
+public final class KtModifierKeywordToken extends KtKeywordToken {
 
     /**
      * Generate keyword (identifier that has a keyword meaning in all possible contexts)
      */
-    public static JetModifierKeywordToken keywordModifier(String value) {
-        return new JetModifierKeywordToken(value, value, false);
+    public static KtModifierKeywordToken keywordModifier(String value) {
+        return new KtModifierKeywordToken(value, value, false);
     }
 
     /**
      * Generate soft keyword (identifier that has a keyword meaning only in some contexts)
      */
-    public static JetModifierKeywordToken softKeywordModifier(String value) {
-        return new JetModifierKeywordToken(value, value, true);
+    public static KtModifierKeywordToken softKeywordModifier(String value) {
+        return new KtModifierKeywordToken(value, value, true);
     }
 
-    private JetModifierKeywordToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value, boolean isSoft) {
+    private KtModifierKeywordToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value, boolean isSoft) {
         super(debugName, value, isSoft);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetSingleValueToken.java b/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtSingleValueToken.java
similarity index 85%
rename from compiler/frontend/src/org/jetbrains/kotlin/lexer/JetSingleValueToken.java
rename to compiler/frontend/src/org/jetbrains/kotlin/lexer/KtSingleValueToken.java
index 142fa36b70f..eab2649fdb0 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetSingleValueToken.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtSingleValueToken.java
@@ -19,11 +19,11 @@ package org.jetbrains.kotlin.lexer;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 
-public class JetSingleValueToken extends JetToken {
+public class KtSingleValueToken extends KtToken {
 
     private final String myValue;
 
-    public JetSingleValueToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value) {
+    public KtSingleValueToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value) {
         super(debugName);
         myValue = value;
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetToken.java b/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtToken.java
similarity index 89%
rename from compiler/frontend/src/org/jetbrains/kotlin/lexer/JetToken.java
rename to compiler/frontend/src/org/jetbrains/kotlin/lexer/KtToken.java
index 29adf090786..c9c13fd230e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetToken.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtToken.java
@@ -21,8 +21,8 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
 
-public class JetToken extends IElementType {
-    public JetToken(@NotNull @NonNls String debugName) {
+public class KtToken extends IElementType {
+    public KtToken(@NotNull @NonNls String debugName) {
         super(debugName, KotlinLanguage.INSTANCE);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtTokens.java b/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtTokens.java
new file mode 100644
index 00000000000..15d58b1bd26
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtTokens.java
@@ -0,0 +1,246 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.lexer;
+
+import com.intellij.psi.TokenType;
+import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.tree.TokenSet;
+import org.jetbrains.kotlin.kdoc.lexer.KDocTokens;
+import org.jetbrains.kotlin.psi.KtPsiUtil;
+
+public interface KtTokens {
+    KtToken EOF   = new KtToken("EOF");
+
+    KtToken BLOCK_COMMENT     = new KtToken("BLOCK_COMMENT");
+    KtToken EOL_COMMENT       = new KtToken("EOL_COMMENT");
+    KtToken SHEBANG_COMMENT   = new KtToken("SHEBANG_COMMENT");
+
+    //KtToken DOC_COMMENT   = new KtToken("DOC_COMMENT");
+    IElementType DOC_COMMENT   = KDocTokens.KDOC;
+
+    IElementType WHITE_SPACE = TokenType.WHITE_SPACE;
+
+    KtToken INTEGER_LITERAL    = new KtToken("INTEGER_LITERAL");
+    KtToken FLOAT_LITERAL      = new KtToken("FLOAT_CONSTANT");
+    KtToken CHARACTER_LITERAL  = new KtToken("CHARACTER_LITERAL");
+
+    KtToken CLOSING_QUOTE = new KtToken("CLOSING_QUOTE");
+    KtToken OPEN_QUOTE = new KtToken("OPEN_QUOTE");
+    KtToken REGULAR_STRING_PART = new KtToken("REGULAR_STRING_PART");
+    KtToken ESCAPE_SEQUENCE = new KtToken("ESCAPE_SEQUENCE");
+    KtToken SHORT_TEMPLATE_ENTRY_START = new KtToken("SHORT_TEMPLATE_ENTRY_START");
+    KtToken LONG_TEMPLATE_ENTRY_START = new KtToken("LONG_TEMPLATE_ENTRY_START");
+    KtToken LONG_TEMPLATE_ENTRY_END = new KtToken("LONG_TEMPLATE_ENTRY_END");
+    KtToken DANGLING_NEWLINE = new KtToken("DANGLING_NEWLINE");
+
+    KtKeywordToken PACKAGE_KEYWORD          = KtKeywordToken.keyword("package");
+    KtKeywordToken AS_KEYWORD               = KtKeywordToken.keyword("as");
+    KtKeywordToken TYPE_ALIAS_KEYWORD       = KtKeywordToken.keyword("typealias");
+    KtKeywordToken CLASS_KEYWORD            = KtKeywordToken.keyword("class");
+    KtKeywordToken THIS_KEYWORD             = KtKeywordToken.keyword("this");
+    KtKeywordToken SUPER_KEYWORD            = KtKeywordToken.keyword("super");
+    KtKeywordToken VAL_KEYWORD              = KtKeywordToken.keyword("val");
+    KtKeywordToken VAR_KEYWORD              = KtKeywordToken.keyword("var");
+    KtKeywordToken FUN_KEYWORD              = KtKeywordToken.keyword("fun");
+    KtKeywordToken FOR_KEYWORD              = KtKeywordToken.keyword("for");
+    KtKeywordToken NULL_KEYWORD             = KtKeywordToken.keyword("null");
+    KtKeywordToken TRUE_KEYWORD             = KtKeywordToken.keyword("true");
+    KtKeywordToken FALSE_KEYWORD            = KtKeywordToken.keyword("false");
+    KtKeywordToken IS_KEYWORD               = KtKeywordToken.keyword("is");
+    KtModifierKeywordToken IN_KEYWORD       = KtModifierKeywordToken.keywordModifier("in");
+    KtKeywordToken THROW_KEYWORD            = KtKeywordToken.keyword("throw");
+    KtKeywordToken RETURN_KEYWORD           = KtKeywordToken.keyword("return");
+    KtKeywordToken BREAK_KEYWORD            = KtKeywordToken.keyword("break");
+    KtKeywordToken CONTINUE_KEYWORD         = KtKeywordToken.keyword("continue");
+    KtKeywordToken OBJECT_KEYWORD           = KtKeywordToken.keyword("object");
+    KtKeywordToken IF_KEYWORD               = KtKeywordToken.keyword("if");
+    KtKeywordToken TRY_KEYWORD              = KtKeywordToken.keyword("try");
+    KtKeywordToken ELSE_KEYWORD             = KtKeywordToken.keyword("else");
+    KtKeywordToken WHILE_KEYWORD            = KtKeywordToken.keyword("while");
+    KtKeywordToken DO_KEYWORD               = KtKeywordToken.keyword("do");
+    KtKeywordToken WHEN_KEYWORD             = KtKeywordToken.keyword("when");
+    KtKeywordToken INTERFACE_KEYWORD        = KtKeywordToken.keyword("interface");
+    // TODO: Discuss "This" keyword
+    KtKeywordToken CAPITALIZED_THIS_KEYWORD = KtKeywordToken.keyword("This");
+
+
+    KtToken AS_SAFE = KtKeywordToken.keyword("AS_SAFE");//new KtToken("as?");
+
+    KtToken IDENTIFIER = new KtToken("IDENTIFIER");
+
+    KtToken FIELD_IDENTIFIER = new KtToken("FIELD_IDENTIFIER");
+    KtSingleValueToken LBRACKET    = new KtSingleValueToken("LBRACKET", "[");
+    KtSingleValueToken RBRACKET    = new KtSingleValueToken("RBRACKET", "]");
+    KtSingleValueToken LBRACE      = new KtSingleValueToken("LBRACE", "{");
+    KtSingleValueToken RBRACE      = new KtSingleValueToken("RBRACE", "}");
+    KtSingleValueToken LPAR        = new KtSingleValueToken("LPAR", "(");
+    KtSingleValueToken RPAR        = new KtSingleValueToken("RPAR", ")");
+    KtSingleValueToken DOT         = new KtSingleValueToken("DOT", ".");
+    KtSingleValueToken PLUSPLUS    = new KtSingleValueToken("PLUSPLUS", "++");
+    KtSingleValueToken MINUSMINUS  = new KtSingleValueToken("MINUSMINUS", "--");
+    KtSingleValueToken MUL         = new KtSingleValueToken("MUL", "*");
+    KtSingleValueToken PLUS        = new KtSingleValueToken("PLUS", "+");
+    KtSingleValueToken MINUS       = new KtSingleValueToken("MINUS", "-");
+    KtSingleValueToken EXCL        = new KtSingleValueToken("EXCL", "!");
+    KtSingleValueToken DIV         = new KtSingleValueToken("DIV", "/");
+    KtSingleValueToken PERC        = new KtSingleValueToken("PERC", "%");
+    KtSingleValueToken LT          = new KtSingleValueToken("LT", "<");
+    KtSingleValueToken GT          = new KtSingleValueToken("GT", ">");
+    KtSingleValueToken LTEQ        = new KtSingleValueToken("LTEQ", "<=");
+    KtSingleValueToken GTEQ        = new KtSingleValueToken("GTEQ", ">=");
+    KtSingleValueToken EQEQEQ      = new KtSingleValueToken("EQEQEQ", "===");
+    KtSingleValueToken ARROW       = new KtSingleValueToken("ARROW", "->");
+    KtSingleValueToken DOUBLE_ARROW       = new KtSingleValueToken("DOUBLE_ARROW", "=>");
+    KtSingleValueToken EXCLEQEQEQ  = new KtSingleValueToken("EXCLEQEQEQ", "!==");
+    KtSingleValueToken EQEQ        = new KtSingleValueToken("EQEQ", "==");
+    KtSingleValueToken EXCLEQ      = new KtSingleValueToken("EXCLEQ", "!=");
+    KtSingleValueToken EXCLEXCL    = new KtSingleValueToken("EXCLEXCL", "!!");
+    KtSingleValueToken ANDAND      = new KtSingleValueToken("ANDAND", "&&");
+    KtSingleValueToken OROR        = new KtSingleValueToken("OROR", "||");
+    KtSingleValueToken SAFE_ACCESS = new KtSingleValueToken("SAFE_ACCESS", "?.");
+    KtSingleValueToken ELVIS       = new KtSingleValueToken("ELVIS", "?:");
+    KtSingleValueToken QUEST       = new KtSingleValueToken("QUEST", "?");
+    KtSingleValueToken COLONCOLON  = new KtSingleValueToken("COLONCOLON", "::");
+    KtSingleValueToken COLON       = new KtSingleValueToken("COLON", ":");
+    KtSingleValueToken SEMICOLON   = new KtSingleValueToken("SEMICOLON", ";");
+    KtSingleValueToken DOUBLE_SEMICOLON   = new KtSingleValueToken("DOUBLE_SEMICOLON", ";;");
+    KtSingleValueToken RANGE       = new KtSingleValueToken("RANGE", "..");
+    KtSingleValueToken EQ          = new KtSingleValueToken("EQ", "=");
+    KtSingleValueToken MULTEQ      = new KtSingleValueToken("MULTEQ", "*=");
+    KtSingleValueToken DIVEQ       = new KtSingleValueToken("DIVEQ", "/=");
+    KtSingleValueToken PERCEQ      = new KtSingleValueToken("PERCEQ", "%=");
+    KtSingleValueToken PLUSEQ      = new KtSingleValueToken("PLUSEQ", "+=");
+    KtSingleValueToken MINUSEQ     = new KtSingleValueToken("MINUSEQ", "-=");
+    KtKeywordToken NOT_IN      = KtKeywordToken.keyword("NOT_IN", "!in");
+    KtKeywordToken NOT_IS      = KtKeywordToken.keyword("NOT_IS", "!is");
+    KtSingleValueToken HASH        = new KtSingleValueToken("HASH", "#");
+    KtSingleValueToken AT          = new KtSingleValueToken("AT", "@");
+
+    KtSingleValueToken COMMA       = new KtSingleValueToken("COMMA", ",");
+
+    KtToken EOL_OR_SEMICOLON   = new KtToken("EOL_OR_SEMICOLON");
+    KtKeywordToken FILE_KEYWORD    = KtKeywordToken.softKeyword("file");
+    KtKeywordToken FIELD_KEYWORD     = KtKeywordToken.softKeyword("field");
+    KtKeywordToken PROPERTY_KEYWORD     = KtKeywordToken.softKeyword("property");
+    KtKeywordToken RECEIVER_KEYWORD     = KtKeywordToken.softKeyword("receiver");
+    KtKeywordToken PARAM_KEYWORD     = KtKeywordToken.softKeyword("param");
+    KtKeywordToken SETPARAM_KEYWORD  = KtKeywordToken.softKeyword("setparam");
+    KtKeywordToken IMPORT_KEYWORD    = KtKeywordToken.softKeyword("import");
+    KtKeywordToken WHERE_KEYWORD     = KtKeywordToken.softKeyword("where");
+    KtKeywordToken BY_KEYWORD        = KtKeywordToken.softKeyword("by");
+    KtKeywordToken GET_KEYWORD       = KtKeywordToken.softKeyword("get");
+    KtKeywordToken SET_KEYWORD       = KtKeywordToken.softKeyword("set");
+    KtKeywordToken CONSTRUCTOR_KEYWORD = KtKeywordToken.softKeyword("constructor");
+    KtKeywordToken INIT_KEYWORD        = KtKeywordToken.softKeyword("init");
+
+    KtModifierKeywordToken ABSTRACT_KEYWORD  = KtModifierKeywordToken.softKeywordModifier("abstract");
+    KtModifierKeywordToken ENUM_KEYWORD      = KtModifierKeywordToken.softKeywordModifier("enum");
+    KtModifierKeywordToken OPEN_KEYWORD      = KtModifierKeywordToken.softKeywordModifier("open");
+    KtModifierKeywordToken INNER_KEYWORD     = KtModifierKeywordToken.softKeywordModifier("inner");
+    KtModifierKeywordToken OVERRIDE_KEYWORD  = KtModifierKeywordToken.softKeywordModifier("override");
+    KtModifierKeywordToken PRIVATE_KEYWORD   = KtModifierKeywordToken.softKeywordModifier("private");
+    KtModifierKeywordToken PUBLIC_KEYWORD    = KtModifierKeywordToken.softKeywordModifier("public");
+    KtModifierKeywordToken INTERNAL_KEYWORD  = KtModifierKeywordToken.softKeywordModifier("internal");
+    KtModifierKeywordToken PROTECTED_KEYWORD = KtModifierKeywordToken.softKeywordModifier("protected");
+    KtKeywordToken CATCH_KEYWORD     = KtKeywordToken.softKeyword("catch");
+    KtModifierKeywordToken OUT_KEYWORD       = KtModifierKeywordToken.softKeywordModifier("out");
+    KtModifierKeywordToken VARARG_KEYWORD    = KtModifierKeywordToken.softKeywordModifier("vararg");
+    KtModifierKeywordToken REIFIED_KEYWORD   = KtModifierKeywordToken.softKeywordModifier("reified");
+    KtKeywordToken DYNAMIC_KEYWORD   = KtKeywordToken.softKeyword("dynamic");
+    KtModifierKeywordToken COMPANION_KEYWORD = KtModifierKeywordToken.softKeywordModifier("companion");
+    KtModifierKeywordToken SEALED_KEYWORD    = KtModifierKeywordToken.softKeywordModifier("sealed");
+
+    KtModifierKeywordToken DEFAULT_VISIBILITY_KEYWORD = PUBLIC_KEYWORD;
+
+    KtKeywordToken FINALLY_KEYWORD   = KtKeywordToken.softKeyword("finally");
+    KtModifierKeywordToken FINAL_KEYWORD     = KtModifierKeywordToken.softKeywordModifier("final");
+
+    KtModifierKeywordToken LATEINIT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("lateinit");
+
+    KtModifierKeywordToken DATA_KEYWORD    = KtModifierKeywordToken.softKeywordModifier("data");
+    KtModifierKeywordToken INLINE_KEYWORD    = KtModifierKeywordToken.softKeywordModifier("inline");
+    KtModifierKeywordToken NOINLINE_KEYWORD    = KtModifierKeywordToken.softKeywordModifier("noinline");
+    KtModifierKeywordToken TAILREC_KEYWORD    = KtModifierKeywordToken.softKeywordModifier("tailrec");
+    KtModifierKeywordToken EXTERNAL_KEYWORD    = KtModifierKeywordToken.softKeywordModifier("external");
+    KtModifierKeywordToken ANNOTATION_KEYWORD    = KtModifierKeywordToken.softKeywordModifier("annotation");
+    KtModifierKeywordToken CROSSINLINE_KEYWORD    = KtModifierKeywordToken.softKeywordModifier("crossinline");
+    KtModifierKeywordToken OPERATOR_KEYWORD = KtModifierKeywordToken.softKeywordModifier("operator");
+    KtModifierKeywordToken INFIX_KEYWORD = KtModifierKeywordToken.softKeywordModifier("infix");
+
+    KtModifierKeywordToken CONST_KEYWORD = KtModifierKeywordToken.softKeywordModifier("const");
+
+    TokenSet KEYWORDS = TokenSet.create(PACKAGE_KEYWORD, AS_KEYWORD, TYPE_ALIAS_KEYWORD, CLASS_KEYWORD, INTERFACE_KEYWORD,
+                                        THIS_KEYWORD, SUPER_KEYWORD, VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, FOR_KEYWORD,
+                                        NULL_KEYWORD,
+                                        TRUE_KEYWORD, FALSE_KEYWORD, IS_KEYWORD,
+                                        IN_KEYWORD, THROW_KEYWORD, RETURN_KEYWORD, BREAK_KEYWORD, CONTINUE_KEYWORD, OBJECT_KEYWORD, IF_KEYWORD,
+                                        ELSE_KEYWORD, WHILE_KEYWORD, DO_KEYWORD, TRY_KEYWORD, WHEN_KEYWORD,
+                                        NOT_IN, NOT_IS, CAPITALIZED_THIS_KEYWORD, AS_SAFE
+    );
+
+    TokenSet SOFT_KEYWORDS = TokenSet.create(FILE_KEYWORD, IMPORT_KEYWORD, WHERE_KEYWORD, BY_KEYWORD, GET_KEYWORD,
+                                             SET_KEYWORD, ABSTRACT_KEYWORD, ENUM_KEYWORD, OPEN_KEYWORD, INNER_KEYWORD,
+                                             OVERRIDE_KEYWORD, PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD,
+                                             CATCH_KEYWORD, FINALLY_KEYWORD, OUT_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD, REIFIED_KEYWORD,
+                                             DYNAMIC_KEYWORD, COMPANION_KEYWORD, CONSTRUCTOR_KEYWORD, INIT_KEYWORD, SEALED_KEYWORD,
+                                             FIELD_KEYWORD, PROPERTY_KEYWORD, RECEIVER_KEYWORD, PARAM_KEYWORD, SETPARAM_KEYWORD,
+                                             LATEINIT_KEYWORD,
+                                             DATA_KEYWORD, INLINE_KEYWORD, NOINLINE_KEYWORD, TAILREC_KEYWORD, EXTERNAL_KEYWORD,
+                                             ANNOTATION_KEYWORD, CROSSINLINE_KEYWORD, CONST_KEYWORD, OPERATOR_KEYWORD, INFIX_KEYWORD
+    );
+
+    /*
+        This array is used in stub serialization:
+        1. Do not change order.
+        2. If you add an entry or change order, increase stub version.
+     */
+    KtModifierKeywordToken[] MODIFIER_KEYWORDS_ARRAY =
+            new KtModifierKeywordToken[] {
+                    ABSTRACT_KEYWORD, ENUM_KEYWORD, OPEN_KEYWORD, INNER_KEYWORD, OVERRIDE_KEYWORD, PRIVATE_KEYWORD,
+                    PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD, OUT_KEYWORD, IN_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD,
+                    REIFIED_KEYWORD, COMPANION_KEYWORD, SEALED_KEYWORD, LATEINIT_KEYWORD,
+                    DATA_KEYWORD, INLINE_KEYWORD, NOINLINE_KEYWORD, TAILREC_KEYWORD, EXTERNAL_KEYWORD, ANNOTATION_KEYWORD, CROSSINLINE_KEYWORD,
+                    CONST_KEYWORD, OPERATOR_KEYWORD, INFIX_KEYWORD
+            };
+
+    TokenSet MODIFIER_KEYWORDS = TokenSet.create(MODIFIER_KEYWORDS_ARRAY);
+
+    TokenSet VISIBILITY_MODIFIERS = TokenSet.create(PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD);
+
+    TokenSet WHITESPACES = TokenSet.create(TokenType.WHITE_SPACE);
+
+    /**
+     * Don't add KDocTokens to COMMENTS TokenSet, because it is used in JetParserDefinition.getCommentTokens(),
+     * and therefor all COMMENTS tokens will be ignored by PsiBuilder.
+     *
+     * @see KtPsiUtil#isInComment(com.intellij.psi.PsiElement)
+     */
+    TokenSet COMMENTS = TokenSet.create(EOL_COMMENT, BLOCK_COMMENT, DOC_COMMENT, SHEBANG_COMMENT);
+    TokenSet WHITE_SPACE_OR_COMMENT_BIT_SET = TokenSet.orSet(COMMENTS, TokenSet.create(WHITE_SPACE));
+
+    TokenSet STRINGS = TokenSet.create(CHARACTER_LITERAL, REGULAR_STRING_PART);
+    TokenSet OPERATIONS = TokenSet.create(AS_KEYWORD, AS_SAFE, IS_KEYWORD, IN_KEYWORD, DOT, PLUSPLUS, MINUSMINUS, EXCLEXCL, MUL, PLUS,
+                                          MINUS, EXCL, DIV, PERC, LT, GT, LTEQ, GTEQ, EQEQEQ, EXCLEQEQEQ, EQEQ, EXCLEQ, ANDAND, OROR,
+                                          SAFE_ACCESS, ELVIS,
+            //            MAP, FILTER,
+                                          RANGE, EQ, MULTEQ, DIVEQ, PERCEQ, PLUSEQ, MINUSEQ,
+                                          NOT_IN, NOT_IS,
+                                          IDENTIFIER);
+
+    TokenSet AUGMENTED_ASSIGNMENTS = TokenSet.create(PLUSEQ, MINUSEQ, MULTEQ, PERCEQ, DIVEQ);
+    TokenSet ALL_ASSIGNMENTS = TokenSet.create(EQ, PLUSEQ, MINUSEQ, MULTEQ, PERCEQ, DIVEQ);
+}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/lexer/_JetLexer.java b/compiler/frontend/src/org/jetbrains/kotlin/lexer/_JetLexer.java
index d2baf9584f7..d94ec97c3fe 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/lexer/_JetLexer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/lexer/_JetLexer.java
@@ -611,9 +611,9 @@ class _JetLexer implements FlexLexer {
     private IElementType commentStateToTokenType(int state) {
         switch (state) {
             case BLOCK_COMMENT:
-                return JetTokens.BLOCK_COMMENT;
+                return KtTokens.BLOCK_COMMENT;
             case DOC_COMMENT:
-                return JetTokens.DOC_COMMENT;
+                return KtTokens.DOC_COMMENT;
             default:
                 throw new IllegalArgumentException("Unexpected state: " + state);
         }
@@ -864,188 +864,188 @@ class _JetLexer implements FlexLexer {
 
       switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
         case 102: 
-          { return JetTokens.TYPE_ALIAS_KEYWORD ;
+          { return KtTokens.TYPE_ALIAS_KEYWORD ;
           }
         case 104: break;
         case 3: 
-          { return JetTokens.IDENTIFIER;
+          { return KtTokens.IDENTIFIER;
           }
         case 105: break;
         case 11: 
-          { pushState(STRING); return JetTokens.OPEN_QUOTE;
+          { pushState(STRING); return KtTokens.OPEN_QUOTE;
           }
         case 106: break;
         case 78: 
-          { return JetTokens.FOR_KEYWORD ;
+          { return KtTokens.FOR_KEYWORD ;
           }
         case 107: break;
         case 98: 
-          { return JetTokens.RETURN_KEYWORD ;
+          { return KtTokens.RETURN_KEYWORD ;
           }
         case 108: break;
         case 103: 
-          { return JetTokens.INTERFACE_KEYWORD ;
+          { return KtTokens.INTERFACE_KEYWORD ;
           }
         case 109: break;
         case 88: 
-          { return JetTokens.NULL_KEYWORD ;
+          { return KtTokens.NULL_KEYWORD ;
           }
         case 110: break;
         case 35: 
           { if (lBraceCount == 0) {
                                              popState();
-                                             return JetTokens.LONG_TEMPLATE_ENTRY_END;
+                                             return KtTokens.LONG_TEMPLATE_ENTRY_END;
                                            }
                                            lBraceCount--;
-                                           return JetTokens.RBRACE;
+                                           return KtTokens.RBRACE;
           }
         case 111: break;
         case 18: 
-          { return JetTokens.LT        ;
+          { return KtTokens.LT        ;
           }
         case 112: break;
         case 52: 
-          { return JetTokens.DO_KEYWORD ;
+          { return KtTokens.DO_KEYWORD ;
           }
         case 113: break;
         case 17: 
-          { return JetTokens.PLUS      ;
+          { return KtTokens.PLUS      ;
           }
         case 114: break;
         case 55: 
-          { return JetTokens.PLUSEQ    ;
+          { return KtTokens.PLUSEQ    ;
           }
         case 115: break;
         case 91: 
-          { popState(); return JetTokens.THIS_KEYWORD;
+          { popState(); return KtTokens.THIS_KEYWORD;
           }
         case 116: break;
         case 27: 
-          { return JetTokens.COMMA     ;
+          { return KtTokens.COMMA     ;
           }
         case 117: break;
         case 19: 
-          { return JetTokens.GT        ;
+          { return KtTokens.GT        ;
           }
         case 118: break;
         case 4: 
-          { return JetTokens.WHITE_SPACE;
+          { return KtTokens.WHITE_SPACE;
           }
         case 119: break;
         case 25: 
-          { return JetTokens.RPAR      ;
+          { return KtTokens.RPAR      ;
           }
         case 120: break;
         case 54: 
-          { return JetTokens.DOUBLE_ARROW;
+          { return KtTokens.DOUBLE_ARROW;
           }
         case 121: break;
         case 86: 
-          { return JetTokens.TRUE_KEYWORD ;
+          { return KtTokens.TRUE_KEYWORD ;
           }
         case 122: break;
         case 37: 
-          { return JetTokens.FIELD_IDENTIFIER;
+          { return KtTokens.FIELD_IDENTIFIER;
           }
         case 123: break;
         case 59: 
-          { return JetTokens.ANDAND    ;
+          { return KtTokens.ANDAND    ;
           }
         case 124: break;
         case 65: 
-          { pushState(LONG_TEMPLATE_ENTRY); return JetTokens.LONG_TEMPLATE_ENTRY_START;
+          { pushState(LONG_TEMPLATE_ENTRY); return KtTokens.LONG_TEMPLATE_ENTRY_START;
           }
         case 125: break;
         case 36: 
-          { return JetTokens.FLOAT_LITERAL;
+          { return KtTokens.FLOAT_LITERAL;
           }
         case 126: break;
         case 38: 
-          { return JetTokens.EOL_COMMENT;
+          { return KtTokens.EOL_COMMENT;
           }
         case 127: break;
         case 89: 
-          { return JetTokens.WHEN_KEYWORD ;
+          { return KtTokens.WHEN_KEYWORD ;
           }
         case 128: break;
         case 74: 
-          { pushState(RAW_STRING); return JetTokens.OPEN_QUOTE;
+          { pushState(RAW_STRING); return KtTokens.OPEN_QUOTE;
           }
         case 129: break;
         case 21: 
-          { return JetTokens.COLON     ;
+          { return KtTokens.COLON     ;
           }
         case 130: break;
         case 57: 
-          { return JetTokens.LTEQ      ;
+          { return KtTokens.LTEQ      ;
           }
         case 131: break;
         case 46: 
-          { return JetTokens.ARROW     ;
+          { return KtTokens.ARROW     ;
           }
         case 132: break;
         case 32: 
-          { popState(); return JetTokens.IDENTIFIER;
+          { popState(); return KtTokens.IDENTIFIER;
           }
         case 133: break;
         case 22: 
-          { return JetTokens.LBRACKET  ;
+          { return KtTokens.LBRACKET  ;
           }
         case 134: break;
         case 69: 
-          { yypushback(2); return JetTokens.INTEGER_LITERAL;
+          { yypushback(2); return KtTokens.INTEGER_LITERAL;
           }
         case 135: break;
         case 10: 
-          { return JetTokens.CHARACTER_LITERAL;
+          { return KtTokens.CHARACTER_LITERAL;
           }
         case 136: break;
         case 80: 
-          { return JetTokens.VAR_KEYWORD ;
+          { return KtTokens.VAR_KEYWORD ;
           }
         case 137: break;
         case 58: 
-          { return JetTokens.GTEQ      ;
+          { return KtTokens.GTEQ      ;
           }
         case 138: break;
         case 2: 
-          { return JetTokens.INTEGER_LITERAL;
+          { return KtTokens.INTEGER_LITERAL;
           }
         case 139: break;
         case 13: 
-          { return JetTokens.RBRACE    ;
+          { return KtTokens.RBRACE    ;
           }
         case 140: break;
         case 95: 
-          { return JetTokens.CLASS_KEYWORD ;
+          { return KtTokens.CLASS_KEYWORD ;
           }
         case 141: break;
         case 75: 
-          { return JetTokens.TRY_KEYWORD ;
+          { return KtTokens.TRY_KEYWORD ;
           }
         case 142: break;
         case 7: 
-          { return JetTokens.EXCL      ;
+          { return KtTokens.EXCL      ;
           }
         case 143: break;
         case 42: 
-          { return JetTokens.EXCLEQ    ;
+          { return KtTokens.EXCLEQ    ;
           }
         case 144: break;
         case 45: 
-          { return JetTokens.MINUSEQ   ;
+          { return KtTokens.MINUSEQ   ;
           }
         case 145: break;
         case 100: 
-          { return JetTokens.PACKAGE_KEYWORD ;
+          { return KtTokens.PACKAGE_KEYWORD ;
           }
         case 146: break;
         case 92: 
-          { return JetTokens.THROW_KEYWORD ;
+          { return KtTokens.THROW_KEYWORD ;
           }
         case 147: break;
         case 93: 
-          { return JetTokens.SUPER_KEYWORD ;
+          { return KtTokens.SUPER_KEYWORD ;
           }
         case 148: break;
         case 68: 
@@ -1061,47 +1061,47 @@ class _JetLexer implements FlexLexer {
           }
         case 149: break;
         case 97: 
-          { return JetTokens.WHILE_KEYWORD ;
+          { return KtTokens.WHILE_KEYWORD ;
           }
         case 150: break;
         case 44: 
-          { return JetTokens.MINUSMINUS;
+          { return KtTokens.MINUSMINUS;
           }
         case 151: break;
         case 101: 
-          { return JetTokens.CONTINUE_KEYWORD ;
+          { return KtTokens.CONTINUE_KEYWORD ;
           }
         case 152: break;
         case 72: 
-          { return JetTokens.NOT_IN;
+          { return KtTokens.NOT_IN;
           }
         case 153: break;
         case 63: 
-          { return JetTokens.DOUBLE_SEMICOLON;
+          { return KtTokens.DOUBLE_SEMICOLON;
           }
         case 154: break;
         case 5: 
-          { return JetTokens.DIV       ;
+          { return KtTokens.DIV       ;
           }
         case 155: break;
         case 82: 
           { int length = yytext().length();
                                     if (length <= 3) { // closing """
                                         popState();
-                                        return JetTokens.CLOSING_QUOTE;
+                                        return KtTokens.CLOSING_QUOTE;
                                     }
                                     else { // some quotes at the end of a string, e.g. """ "foo""""
                                         yypushback(3); // return the closing quotes (""") to the stream
-                                        return JetTokens.REGULAR_STRING_PART;
+                                        return KtTokens.REGULAR_STRING_PART;
                                     }
           }
         case 156: break;
         case 29: 
-          { return JetTokens.REGULAR_STRING_PART;
+          { return KtTokens.REGULAR_STRING_PART;
           }
         case 157: break;
         case 16: 
-          { return JetTokens.QUEST     ;
+          { return KtTokens.QUEST     ;
           }
         case 158: break;
         case 70: 
@@ -1111,23 +1111,23 @@ class _JetLexer implements FlexLexer {
           }
         case 159: break;
         case 60: 
-          { return JetTokens.OROR      ;
+          { return KtTokens.OROR      ;
           }
         case 160: break;
         case 20: 
-          { return JetTokens.PERC      ;
+          { return KtTokens.PERC      ;
           }
         case 161: break;
         case 73: 
-          { return JetTokens.EXCLEQEQEQ;
+          { return KtTokens.EXCLEQEQEQ;
           }
         case 162: break;
         case 61: 
-          { return JetTokens.PERCEQ    ;
+          { return KtTokens.PERCEQ    ;
           }
         case 163: break;
         case 43: 
-          { return JetTokens.RANGE     ;
+          { return KtTokens.RANGE     ;
           }
         case 164: break;
         case 1: 
@@ -1137,23 +1137,23 @@ class _JetLexer implements FlexLexer {
         case 64: 
           { pushState(SHORT_TEMPLATE_ENTRY);
                                                         yypushback(yylength() - 1);
-                                                        return JetTokens.SHORT_TEMPLATE_ENTRY_START;
+                                                        return KtTokens.SHORT_TEMPLATE_ENTRY_START;
           }
         case 166: break;
         case 71: 
-          { return JetTokens.NOT_IS;
+          { return KtTokens.NOT_IS;
           }
         case 167: break;
         case 14: 
-          { return JetTokens.MUL       ;
+          { return KtTokens.MUL       ;
           }
         case 168: break;
         case 23: 
-          { return JetTokens.RBRACKET  ;
+          { return KtTokens.RBRACKET  ;
           }
         case 169: break;
         case 56: 
-          { return JetTokens.PLUSPLUS  ;
+          { return KtTokens.PLUSPLUS  ;
           }
         case 170: break;
         case 39: 
@@ -1163,51 +1163,51 @@ class _JetLexer implements FlexLexer {
           }
         case 171: break;
         case 85: 
-          { return JetTokens.THIS_KEYWORD ;
+          { return KtTokens.THIS_KEYWORD ;
           }
         case 172: break;
         case 8: 
-          { return JetTokens.DOT       ;
+          { return KtTokens.DOT       ;
           }
         case 173: break;
         case 26: 
-          { return JetTokens.SEMICOLON ;
+          { return KtTokens.SEMICOLON ;
           }
         case 174: break;
         case 49: 
-          { return JetTokens.IF_KEYWORD ;
+          { return KtTokens.IF_KEYWORD ;
           }
         case 175: break;
         case 66: 
-          { return JetTokens.ESCAPE_SEQUENCE;
+          { return KtTokens.ESCAPE_SEQUENCE;
           }
         case 176: break;
         case 31: 
-          { popState(); return JetTokens.CLOSING_QUOTE;
+          { popState(); return KtTokens.CLOSING_QUOTE;
           }
         case 177: break;
         case 15: 
-          { return JetTokens.EQ        ;
+          { return KtTokens.EQ        ;
           }
         case 178: break;
         case 28: 
-          { return JetTokens.AT        ;
+          { return KtTokens.AT        ;
           }
         case 179: break;
         case 76: 
-          { return JetTokens.AS_SAFE;
+          { return KtTokens.AS_SAFE;
           }
         case 180: break;
         case 24: 
-          { return JetTokens.LPAR      ;
+          { return KtTokens.LPAR      ;
           }
         case 181: break;
         case 9: 
-          { return JetTokens.MINUS     ;
+          { return KtTokens.MINUS     ;
           }
         case 182: break;
         case 94: 
-          { return JetTokens.FALSE_KEYWORD ;
+          { return KtTokens.FALSE_KEYWORD ;
           }
         case 183: break;
         case 67: 
@@ -1215,89 +1215,89 @@ class _JetLexer implements FlexLexer {
           }
         case 184: break;
         case 77: 
-          { return JetTokens.FUN_KEYWORD ;
+          { return KtTokens.FUN_KEYWORD ;
           }
         case 185: break;
         case 47: 
-          { return JetTokens.IS_KEYWORD ;
+          { return KtTokens.IS_KEYWORD ;
           }
         case 186: break;
         case 30: 
-          { popState(); yypushback(1); return JetTokens.DANGLING_NEWLINE;
+          { popState(); yypushback(1); return KtTokens.DANGLING_NEWLINE;
           }
         case 187: break;
         case 34: 
-          { lBraceCount++; return JetTokens.LBRACE;
+          { lBraceCount++; return KtTokens.LBRACE;
           }
         case 188: break;
         case 84: 
-          { yypushback(3); return JetTokens.EXCL;
+          { yypushback(3); return KtTokens.EXCL;
           }
         case 189: break;
         case 40: 
-          { return JetTokens.DIVEQ     ;
+          { return KtTokens.DIVEQ     ;
           }
         case 190: break;
         case 87: 
-          { return JetTokens.ELSE_KEYWORD ;
+          { return KtTokens.ELSE_KEYWORD ;
           }
         case 191: break;
         case 51: 
-          { return JetTokens.AS_KEYWORD ;
+          { return KtTokens.AS_KEYWORD ;
           }
         case 192: break;
         case 48: 
-          { return JetTokens.IN_KEYWORD ;
+          { return KtTokens.IN_KEYWORD ;
           }
         case 193: break;
         case 53: 
-          { return JetTokens.EQEQ      ;
+          { return KtTokens.EQEQ      ;
           }
         case 194: break;
         case 81: 
-          { return JetTokens.EQEQEQ    ;
+          { return KtTokens.EQEQEQ    ;
           }
         case 195: break;
         case 79: 
-          { return JetTokens.VAL_KEYWORD ;
+          { return KtTokens.VAL_KEYWORD ;
           }
         case 196: break;
         case 90: 
-          { return JetTokens.CAPITALIZED_THIS_KEYWORD ;
+          { return KtTokens.CAPITALIZED_THIS_KEYWORD ;
           }
         case 197: break;
         case 50: 
-          { return JetTokens.MULTEQ    ;
+          { return KtTokens.MULTEQ    ;
           }
         case 198: break;
         case 41: 
           { if (zzCurrentPos == 0) {
-                return JetTokens.SHEBANG_COMMENT;
+                return KtTokens.SHEBANG_COMMENT;
             }
             else {
                 yypushback(yylength() - 1);
-                return JetTokens.HASH;
+                return KtTokens.HASH;
             }
           }
         case 199: break;
         case 12: 
-          { return JetTokens.LBRACE    ;
+          { return KtTokens.LBRACE    ;
           }
         case 200: break;
         case 99: 
-          { return JetTokens.OBJECT_KEYWORD ;
+          { return KtTokens.OBJECT_KEYWORD ;
           }
         case 201: break;
         case 96: 
-          { return JetTokens.BREAK_KEYWORD ;
+          { return KtTokens.BREAK_KEYWORD ;
           }
         case 202: break;
         case 83: 
-          { return JetTokens.BLOCK_COMMENT;
+          { return KtTokens.BLOCK_COMMENT;
           }
         case 203: break;
         case 62: 
-          { return JetTokens.COLONCOLON;
+          { return KtTokens.COLONCOLON;
           }
         case 204: break;
         case 33: 
@@ -1305,7 +1305,7 @@ class _JetLexer implements FlexLexer {
           }
         case 205: break;
         case 6: 
-          { return JetTokens.HASH      ;
+          { return KtTokens.HASH      ;
           }
         case 206: break;
         default:
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/parsing/AbstractJetParsing.java b/compiler/frontend/src/org/jetbrains/kotlin/parsing/AbstractJetParsing.java
index 089d23c6667..b936873c2dc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/parsing/AbstractJetParsing.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/parsing/AbstractJetParsing.java
@@ -22,31 +22,31 @@ import com.intellij.psi.tree.TokenSet;
 import com.intellij.util.containers.Stack;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.TestOnly;
-import org.jetbrains.kotlin.lexer.JetKeywordToken;
-import org.jetbrains.kotlin.lexer.JetToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtKeywordToken;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.utils.strings.StringsKt;
 
 import java.util.HashMap;
 import java.util.Map;
 
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
+import static org.jetbrains.kotlin.lexer.KtTokens.*;
 
 /*package*/ abstract class AbstractJetParsing {
-    private static final Map<String, JetKeywordToken> SOFT_KEYWORD_TEXTS = new HashMap<String, JetKeywordToken>();
+    private static final Map<String, KtKeywordToken> SOFT_KEYWORD_TEXTS = new HashMap<String, KtKeywordToken>();
 
     static {
-        for (IElementType type : JetTokens.SOFT_KEYWORDS.getTypes()) {
-            JetKeywordToken keywordToken = (JetKeywordToken) type;
+        for (IElementType type : KtTokens.SOFT_KEYWORDS.getTypes()) {
+            KtKeywordToken keywordToken = (KtKeywordToken) type;
             assert keywordToken.isSoft();
             SOFT_KEYWORD_TEXTS.put(keywordToken.getValue(), keywordToken);
         }
     }
 
     static {
-        for (IElementType token : JetTokens.KEYWORDS.getTypes()) {
-            assert token instanceof JetKeywordToken : "Must be JetKeywordToken: " + token;
-            assert !((JetKeywordToken) token).isSoft() : "Must not be soft: " + token;
+        for (IElementType token : KtTokens.KEYWORDS.getTypes()) {
+            assert token instanceof KtKeywordToken : "Must be KtKeywordToken: " + token;
+            assert !((KtKeywordToken) token).isSoft() : "Must not be soft: " + token;
         }
     }
 
@@ -65,7 +65,7 @@ import static org.jetbrains.kotlin.lexer.JetTokens.*;
         return myBuilder.rawLookup(-i);
     }
 
-    protected boolean expect(JetToken expectation, String message) {
+    protected boolean expect(KtToken expectation, String message) {
         return expect(expectation, message, null);
     }
 
@@ -77,13 +77,13 @@ import static org.jetbrains.kotlin.lexer.JetTokens.*;
         myBuilder.error(message);
     }
 
-    protected boolean expect(JetToken expectation, String message, TokenSet recoverySet) {
+    protected boolean expect(KtToken expectation, String message, TokenSet recoverySet) {
         if (at(expectation)) {
             advance(); // expectation
             return true;
         }
 
-        if (expectation == JetTokens.IDENTIFIER && "`".equals(myBuilder.getTokenText())) {
+        if (expectation == KtTokens.IDENTIFIER && "`".equals(myBuilder.getTokenText())) {
             advance();
         }
 
@@ -92,7 +92,7 @@ import static org.jetbrains.kotlin.lexer.JetTokens.*;
         return false;
     }
 
-    protected boolean expectNoAdvance(JetToken expectation, String message) {
+    protected boolean expectNoAdvance(KtToken expectation, String message) {
         if (at(expectation)) {
             advance(); // expectation
             return true;
@@ -171,15 +171,15 @@ import static org.jetbrains.kotlin.lexer.JetTokens.*;
     protected boolean at(IElementType expectation) {
         if (_at(expectation)) return true;
         IElementType token = tt();
-        if (token == IDENTIFIER && expectation instanceof JetKeywordToken) {
-            JetKeywordToken expectedKeyword = (JetKeywordToken) expectation;
+        if (token == IDENTIFIER && expectation instanceof KtKeywordToken) {
+            KtKeywordToken expectedKeyword = (KtKeywordToken) expectation;
             if (expectedKeyword.isSoft() && expectedKeyword.getValue().equals(myBuilder.getTokenText())) {
                 myBuilder.remapCurrentToken(expectation);
                 return true;
             }
         }
-        if (expectation == IDENTIFIER && token instanceof JetKeywordToken) {
-            JetKeywordToken keywordToken = (JetKeywordToken) token;
+        if (expectation == IDENTIFIER && token instanceof KtKeywordToken) {
+            KtKeywordToken keywordToken = (KtKeywordToken) token;
             if (keywordToken.isSoft()) {
                 myBuilder.remapCurrentToken(IDENTIFIER);
                 return true;
@@ -217,7 +217,7 @@ import static org.jetbrains.kotlin.lexer.JetTokens.*;
         if (_atSet(set)) return true;
         IElementType token = tt();
         if (token == IDENTIFIER) {
-            JetKeywordToken keywordToken = SOFT_KEYWORD_TEXTS.get(myBuilder.getTokenText());
+            KtKeywordToken keywordToken = SOFT_KEYWORD_TEXTS.get(myBuilder.getTokenText());
             if (keywordToken != null && set.contains(keywordToken)) {
                 myBuilder.remapCurrentToken(keywordToken);
                 return true;
@@ -225,8 +225,8 @@ import static org.jetbrains.kotlin.lexer.JetTokens.*;
         }
         else {
             // We know at this point that <code>set</code> does not contain <code>token</code>
-            if (set.contains(IDENTIFIER) && token instanceof JetKeywordToken) {
-                if (((JetKeywordToken) token).isSoft()) {
+            if (set.contains(IDENTIFIER) && token instanceof KtKeywordToken) {
+                if (((KtKeywordToken) token).isSoft()) {
                     myBuilder.remapCurrentToken(IDENTIFIER);
                     return true;
                 }
@@ -239,7 +239,7 @@ import static org.jetbrains.kotlin.lexer.JetTokens.*;
         return myBuilder.lookAhead(k);
     }
 
-    protected void consumeIf(JetToken token) {
+    protected void consumeIf(KtToken token) {
         if (at(token)) advance(); // token
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/parsing/CommentBinders.kt b/compiler/frontend/src/org/jetbrains/kotlin/parsing/CommentBinders.kt
index f8d167a7bc6..4c01d933753 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/parsing/CommentBinders.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/parsing/CommentBinders.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.parsing
 
 import com.intellij.lang.WhitespacesAndCommentsBinder
 import com.intellij.psi.tree.IElementType
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import com.intellij.openapi.util.text.StringUtil
 
 object PrecedingCommentsBinder : WhitespacesAndCommentsBinder {
@@ -28,7 +28,7 @@ object PrecedingCommentsBinder : WhitespacesAndCommentsBinder {
 
         // 1. bind doc comment
         for (idx in tokens.indices.reversed()) {
-            if (tokens[idx] == JetTokens.DOC_COMMENT) return idx
+            if (tokens[idx] == KtTokens.DOC_COMMENT) return idx
         }
 
         // 2. bind plain comments
@@ -36,10 +36,10 @@ object PrecedingCommentsBinder : WhitespacesAndCommentsBinder {
         tokens@ for (idx in tokens.indices.reversed()) {
             val tokenType = tokens[idx]
             when (tokenType) {
-                JetTokens.WHITE_SPACE -> if (StringUtil.getLineBreakCount(getter[idx]) > 1) break@tokens
+                KtTokens.WHITE_SPACE -> if (StringUtil.getLineBreakCount(getter[idx]) > 1) break@tokens
 
-                in JetTokens.COMMENTS -> {
-                    if (idx == 0 || tokens[idx - 1] == JetTokens.WHITE_SPACE && StringUtil.containsLineBreak(getter[idx - 1])) {
+                in KtTokens.COMMENTS -> {
+                    if (idx == 0 || tokens[idx - 1] == KtTokens.WHITE_SPACE && StringUtil.containsLineBreak(getter[idx - 1])) {
                         result = idx
                     }
                 }
@@ -58,7 +58,7 @@ object PrecedingDocCommentsBinder : WhitespacesAndCommentsBinder {
         if (tokens.isEmpty()) return 0
 
         for (idx in tokens.indices.reversed()) {
-            if (tokens[idx] == JetTokens.DOC_COMMENT) return idx
+            if (tokens[idx] == KtTokens.DOC_COMMENT) return idx
         }
 
         return tokens.size()
@@ -75,9 +75,9 @@ object TrailingCommentsBinder : WhitespacesAndCommentsBinder {
         tokens@ for (idx in tokens.indices) {
             val tokenType = tokens[idx]
             when (tokenType) {
-                JetTokens.WHITE_SPACE -> if (StringUtil.containsLineBreak(getter[idx])) break@tokens
+                KtTokens.WHITE_SPACE -> if (StringUtil.containsLineBreak(getter[idx])) break@tokens
 
-                JetTokens.EOL_COMMENT, JetTokens.BLOCK_COMMENT -> result = idx + 1
+                KtTokens.EOL_COMMENT, KtTokens.BLOCK_COMMENT -> result = idx + 1
 
                 else -> break@tokens
             }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetExpressionParsing.java b/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetExpressionParsing.java
index c308ce75ff4..128c3eadaf0 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetExpressionParsing.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetExpressionParsing.java
@@ -21,18 +21,18 @@ import com.intellij.lang.PsiBuilder;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.JetNodeType;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeType;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.parsing.JetParsing.NameParsingMode;
 
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
 
-import static org.jetbrains.kotlin.JetNodeTypes.*;
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
+import static org.jetbrains.kotlin.KtNodeTypes.*;
+import static org.jetbrains.kotlin.lexer.KtTokens.*;
 import static org.jetbrains.kotlin.parsing.JetParsing.AnnotationParsingMode.DEFAULT;
 import static org.jetbrains.kotlin.parsing.JetParsing.DeclarationParsingMode.LOCAL;
 
@@ -41,12 +41,12 @@ public class JetExpressionParsing extends AbstractJetParsing {
     private static final TokenSet WHEN_CONDITION_RECOVERY_SET_WITH_ARROW = TokenSet.create(RBRACE, IN_KEYWORD, NOT_IN, IS_KEYWORD, NOT_IS, ELSE_KEYWORD, ARROW, DOT);
 
 
-    private static final ImmutableMap<String, JetToken> KEYWORD_TEXTS = tokenSetToMap(KEYWORDS);
+    private static final ImmutableMap<String, KtToken> KEYWORD_TEXTS = tokenSetToMap(KEYWORDS);
 
-    private static ImmutableMap<String, JetToken> tokenSetToMap(TokenSet tokens) {
-        ImmutableMap.Builder<String, JetToken> builder = ImmutableMap.builder();
+    private static ImmutableMap<String, KtToken> tokenSetToMap(TokenSet tokens) {
+        ImmutableMap.Builder<String, KtToken> builder = ImmutableMap.builder();
         for (IElementType token : tokens.getTypes()) {
-            builder.put(token.toString(), (JetToken) token);
+            builder.put(token.toString(), (KtToken) token);
         }
         return builder.build();
     }
@@ -149,7 +149,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
 
         AS(AS_KEYWORD, AS_SAFE) {
             @Override
-            public JetNodeType parseRightHandSide(IElementType operation, JetExpressionParsing parser) {
+            public KtNodeType parseRightHandSide(IElementType operation, JetExpressionParsing parser) {
                 parser.myJetParsing.parseTypeRef();
                 return BINARY_WITH_TYPE;
             }
@@ -162,12 +162,12 @@ public class JetExpressionParsing extends AbstractJetParsing {
 
         MULTIPLICATIVE(MUL, DIV, PERC),
         ADDITIVE(PLUS, MINUS),
-        RANGE(JetTokens.RANGE),
+        RANGE(KtTokens.RANGE),
         SIMPLE_NAME(IDENTIFIER),
-        ELVIS(JetTokens.ELVIS),
+        ELVIS(KtTokens.ELVIS),
         IN_OR_IS(IN_KEYWORD, NOT_IN, IS_KEYWORD, NOT_IS) {
             @Override
-            public JetNodeType parseRightHandSide(IElementType operation, JetExpressionParsing parser) {
+            public KtNodeType parseRightHandSide(IElementType operation, JetExpressionParsing parser) {
                 if (operation == IS_KEYWORD || operation == NOT_IS) {
                     parser.myJetParsing.parseTypeRef();
                     return IS_EXPRESSION;
@@ -180,7 +180,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
         EQUALITY(EQEQ, EXCLEQ, EQEQEQ, EXCLEQEQEQ),
         CONJUNCTION(ANDAND),
         DISJUNCTION(OROR),
-        //        ARROW(JetTokens.ARROW),
+        //        ARROW(KtTokens.ARROW),
         ASSIGNMENT(EQ, PLUSEQ, MINUSEQ, MULTEQ, DIVEQ, PERCEQ),
         ;
 
@@ -210,7 +210,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
          * @param parser the parser object
          * @return node type of the result
          */
-        public JetNodeType parseRightHandSide(IElementType operation, JetExpressionParsing parser) {
+        public KtNodeType parseRightHandSide(IElementType operation, JetExpressionParsing parser) {
             parseHigherPrecedence(parser);
             return BINARY_EXPRESSION;
         }
@@ -312,7 +312,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
 
             parseOperationReference();
 
-            JetNodeType resultType = precedence.parseRightHandSide(operation, this);
+            KtNodeType resultType = precedence.parseRightHandSide(operation, this);
             expression.done(resultType);
             expression = expression.precede();
         }
@@ -763,7 +763,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
                 thisExpression.done(THIS_EXPRESSION);
             }
             else {
-                JetToken keyword = KEYWORD_TEXTS.get(myBuilder.getTokenText());
+                KtToken keyword = KEYWORD_TEXTS.get(myBuilder.getTokenText());
                 if (keyword != null) {
                     myBuilder.remapCurrentToken(keyword);
                     errorAndAdvance("Keyword cannot be used as a reference");
@@ -1041,7 +1041,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
         if (declType != null) {
             // we do not attach preceding comments (non-doc) to local variables because they are likely commenting a few statements below
             closeDeclarationWithCommentBinders(decl, declType,
-                                               declType != JetNodeTypes.PROPERTY && declType != JetNodeTypes.MULTI_VARIABLE_DECLARATION);
+                                               declType != KtNodeTypes.PROPERTY && declType != KtNodeTypes.MULTI_VARIABLE_DECLARATION);
             return true;
         }
         else {
@@ -1128,7 +1128,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
     }
 
     private boolean rollbackOrDrop(PsiBuilder.Marker rollbackMarker,
-            JetToken expected, String expectMessage,
+            KtToken expected, String expectMessage,
             IElementType validForDrop) {
         if (at(expected)) {
             advance(); // dropAt
@@ -1527,7 +1527,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
      * : "continue" getEntryPoint?
      * : "break" getEntryPoint?
      */
-    private void parseJump(JetNodeType type) {
+    private void parseJump(KtNodeType type) {
         assert _at(BREAK_KEYWORD) || _at(CONTINUE_KEYWORD);
 
         PsiBuilder.Marker marker = mark();
@@ -1770,7 +1770,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
         literal.done(OBJECT_LITERAL);
     }
 
-    private void parseOneTokenExpression(JetNodeType type) {
+    private void parseOneTokenExpression(KtNodeType type) {
         PsiBuilder.Marker mark = mark();
         advance();
         mark.done(type);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParserDefinition.java b/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParserDefinition.java
index 8238112a185..ef2a7bbb93b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParserDefinition.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParserDefinition.java
@@ -30,17 +30,17 @@ import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.IFileElementType;
 import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.JetNodeType;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeType;
+import org.jetbrains.kotlin.KtNodeTypes;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
 import org.jetbrains.kotlin.kdoc.lexer.KDocTokens;
 import org.jetbrains.kotlin.kdoc.parser.KDocElementType;
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocLink;
-import org.jetbrains.kotlin.lexer.JetLexer;
-import org.jetbrains.kotlin.lexer.JetTokens;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementType;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.lexer.KotlinLexer;
+import org.jetbrains.kotlin.lexer.KtTokens;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementType;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 public class JetParserDefinition implements ParserDefinition {
     public static final String STD_SCRIPT_SUFFIX = "kts";
@@ -61,7 +61,7 @@ public class JetParserDefinition implements ParserDefinition {
     @Override
     @NotNull
     public Lexer createLexer(Project project) {
-        return new JetLexer();
+        return new KotlinLexer();
     }
 
     @Override
@@ -71,25 +71,25 @@ public class JetParserDefinition implements ParserDefinition {
 
     @Override
     public IFileElementType getFileNodeType() {
-        return JetStubElementTypes.FILE;
+        return KtStubElementTypes.FILE;
     }
 
     @Override
     @NotNull
     public TokenSet getWhitespaceTokens() {
-        return JetTokens.WHITESPACES;
+        return KtTokens.WHITESPACES;
     }
 
     @Override
     @NotNull
     public TokenSet getCommentTokens() {
-        return JetTokens.COMMENTS;
+        return KtTokens.COMMENTS;
     }
 
     @Override
     @NotNull
     public TokenSet getStringLiteralElements() {
-        return JetTokens.STRINGS;
+        return KtTokens.STRINGS;
     }
 
     @Override
@@ -97,12 +97,12 @@ public class JetParserDefinition implements ParserDefinition {
     public PsiElement createElement(ASTNode astNode) {
         IElementType elementType = astNode.getElementType();
 
-        if (elementType instanceof JetStubElementType) {
-            return ((JetStubElementType) elementType).createPsiFromAst(astNode);
+        if (elementType instanceof KtStubElementType) {
+            return ((KtStubElementType) elementType).createPsiFromAst(astNode);
         }
-        else if (elementType == JetNodeTypes.TYPE_CODE_FRAGMENT ||
-                 elementType == JetNodeTypes.EXPRESSION_CODE_FRAGMENT  ||
-                 elementType == JetNodeTypes.BLOCK_CODE_FRAGMENT) {
+        else if (elementType == KtNodeTypes.TYPE_CODE_FRAGMENT ||
+                 elementType == KtNodeTypes.EXPRESSION_CODE_FRAGMENT ||
+                 elementType == KtNodeTypes.BLOCK_CODE_FRAGMENT) {
             return new ASTWrapperPsiElement(astNode);
         }
         else if (elementType instanceof KDocElementType) {
@@ -112,19 +112,19 @@ public class JetParserDefinition implements ParserDefinition {
             return new KDocLink(astNode);
         }
         else {
-            return ((JetNodeType) elementType).createPsi(astNode);
+            return ((KtNodeType) elementType).createPsi(astNode);
         }
     }
 
     @Override
     public PsiFile createFile(FileViewProvider fileViewProvider) {
-        return new JetFile(fileViewProvider, false);
+        return new KtFile(fileViewProvider, false);
     }
 
     @Override
     public SpaceRequirements spaceExistanceTypeBetweenTokens(ASTNode astNode, ASTNode astNode1) {
         IElementType rightTokenType = astNode1.getElementType();
-        if (rightTokenType == JetTokens.GET_KEYWORD || rightTokenType == JetTokens.SET_KEYWORD) {
+        if (rightTokenType == KtTokens.GET_KEYWORD || rightTokenType == KtTokens.SET_KEYWORD) {
             return SpaceRequirements.MUST_LINE_BREAK;
         }
         return SpaceRequirements.MAY;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParsing.java b/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParsing.java
index 05ab883ccde..ade86b34f06 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParsing.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParsing.java
@@ -22,15 +22,15 @@ import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeType;
-import org.jetbrains.kotlin.lexer.JetKeywordToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeType;
+import org.jetbrains.kotlin.lexer.KtKeywordToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
 import java.util.HashMap;
 import java.util.Map;
 
-import static org.jetbrains.kotlin.JetNodeTypes.*;
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
+import static org.jetbrains.kotlin.KtNodeTypes.*;
+import static org.jetbrains.kotlin.lexer.KtTokens.*;
 import static org.jetbrains.kotlin.parsing.JetParsing.AnnotationParsingMode.*;
 import static org.jetbrains.kotlin.parsing.JetParsing.DeclarationParsingMode.*;
 
@@ -41,7 +41,7 @@ public class JetParsing extends AbstractJetParsing {
     public static final Map<String, IElementType> MODIFIER_KEYWORD_MAP = new HashMap<String, IElementType>();
     static {
         for (IElementType softKeyword : MODIFIER_KEYWORDS.getTypes()) {
-            MODIFIER_KEYWORD_MAP.put(((JetKeywordToken) softKeyword).getValue(), softKeyword);
+            MODIFIER_KEYWORD_MAP.put(((KtKeywordToken) softKeyword).getValue(), softKeyword);
         }
     }
 
@@ -643,7 +643,7 @@ public class JetParsing extends AbstractJetParsing {
             return true;
         }
 
-        JetKeywordToken targetKeyword = atTargetKeyword();
+        KtKeywordToken targetKeyword = atTargetKeyword();
         if (mode == FILE_ANNOTATIONS_WHEN_PACKAGE_OMITTED && !(targetKeyword == FILE_KEYWORD && lookahead(1) == COLON)) {
             return false;
         }
@@ -665,7 +665,7 @@ public class JetParsing extends AbstractJetParsing {
         return true;
     }
 
-    private void parseAnnotationTarget(AnnotationParsingMode mode, JetKeywordToken keyword) {
+    private void parseAnnotationTarget(AnnotationParsingMode mode, KtKeywordToken keyword) {
         if (keyword == FILE_KEYWORD && !mode.isFileAnnotationParsingMode && at(keyword) && lookahead(1) == COLON) {
             errorAndAdvance(AT.getValue() + keyword.getValue() + " annotations are only allowed before package declaration", 2);
             return;
@@ -686,9 +686,9 @@ public class JetParsing extends AbstractJetParsing {
     }
 
     @Nullable
-    private JetKeywordToken atTargetKeyword() {
+    private KtKeywordToken atTargetKeyword() {
         for (IElementType target : ANNOTATION_TARGETS.getTypes()) {
-            if (at(target)) return (JetKeywordToken) target;
+            if (at(target)) return (KtKeywordToken) target;
         }
         return null;
     }
@@ -1181,7 +1181,7 @@ public class JetParsing extends AbstractJetParsing {
      *   : modifiers "typealias" SimpleName (typeParameters typeConstraints)? "=" type
      *   ;
      */
-    JetNodeType parseTypeAlias() {
+    KtNodeType parseTypeAlias() {
         assert _at(TYPE_ALIAS_KEYWORD);
 
         advance(); // TYPE_ALIAS_KEYWORD
@@ -2242,10 +2242,10 @@ public class JetParsing extends AbstractJetParsing {
 
         @Override
         public void consume(IElementType item) {
-            if (item == JetTokens.ENUM_KEYWORD) {
+            if (item == KtTokens.ENUM_KEYWORD) {
                 enumDetected = true;
             }
-            else if (item == JetTokens.COMPANION_KEYWORD) {
+            else if (item == KtTokens.COMPANION_KEYWORD) {
                 defaultDetected = true;
             }
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetScriptDefinitionProvider.java b/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetScriptDefinitionProvider.java
index 518309f2524..d10dfc2b6d4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetScriptDefinitionProvider.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetScriptDefinitionProvider.java
@@ -20,7 +20,7 @@ import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.AnalyzerScriptParameter;
 
 import java.util.*;
@@ -40,7 +40,7 @@ public class JetScriptDefinitionProvider {
         addScriptDefinition(standardScript);
     }
 
-    public void markFileAsScript(JetFile file) {
+    public void markFileAsScript(KtFile file) {
         scriptsFiles.add(file);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java
index ef49b867d5d..50163a07150 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java
@@ -25,9 +25,9 @@ import com.intellij.psi.tree.TokenSet;
 import com.intellij.util.containers.Stack;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
+import static org.jetbrains.kotlin.lexer.KtTokens.*;
 
 public class SemanticWhitespaceAwarePsiBuilderImpl extends PsiBuilderAdapter implements SemanticWhitespaceAwarePsiBuilder {
     private final TokenSet complexTokens = TokenSet.create(SAFE_ACCESS, ELVIS, EXCLEXCL);
@@ -77,9 +77,9 @@ public class SemanticWhitespaceAwarePsiBuilderImpl extends PsiBuilderAdapter imp
         for (int i = 1; i <= getCurrentOffset(); i++) {
             IElementType previousToken = rawLookup(-i);
 
-            if (previousToken == JetTokens.BLOCK_COMMENT
-                    || previousToken == JetTokens.DOC_COMMENT
-                    || previousToken == JetTokens.EOL_COMMENT
+            if (previousToken == KtTokens.BLOCK_COMMENT
+                    || previousToken == KtTokens.DOC_COMMENT
+                    || previousToken == KtTokens.EOL_COMMENT
                     || previousToken == SHEBANG_COMMENT) {
                 continue;
             }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/Call.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/Call.java
index 4a824adc219..13c9a216696 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/Call.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/Call.java
@@ -37,10 +37,10 @@ public interface Call {
     ReceiverValue getDispatchReceiver();
 
     @Nullable
-    JetExpression getCalleeExpression();
+    KtExpression getCalleeExpression();
 
     @Nullable
-    JetValueArgumentList getValueArgumentList();
+    KtValueArgumentList getValueArgumentList();
 
     @ReadOnly
     @NotNull
@@ -52,13 +52,13 @@ public interface Call {
 
     @ReadOnly
     @NotNull
-    List<JetTypeProjection> getTypeArguments();
+    List<KtTypeProjection> getTypeArguments();
 
     @Nullable
-    JetTypeArgumentList getTypeArgumentList();
+    KtTypeArgumentList getTypeArgumentList();
 
     @NotNull
-    JetElement getCallElement();
+    KtElement getCallElement();
 
     enum CallType {
         DEFAULT, ARRAY_GET_METHOD, ARRAY_SET_METHOD, INVOKE
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/DebugTextUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/DebugTextUtil.kt
index 0f1fc88ce6a..f9dc7945890 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/DebugTextUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/DebugTextUtil.kt
@@ -17,17 +17,17 @@
 package org.jetbrains.kotlin.psi.debugText
 
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import com.intellij.openapi.diagnostic.Logger
 
 // invoke this instead of getText() when you need debug text to identify some place in PSI without storing the element itself
 // this is need to avoid unnecessary file parses
 // this defaults to get text if the element is not stubbed
-public fun JetElement.getDebugText(): String {
-    if (this !is JetElementImplStub<*> || this.getStub() == null) {
+public fun KtElement.getDebugText(): String {
+    if (this !is KtElementImplStub<*> || this.getStub() == null) {
         return getText()
     }
-    if (this is JetPackageDirective) {
+    if (this is KtPackageDirective) {
         val fqName = getFqName()
         if (fqName.isRoot()) {
             return ""
@@ -38,22 +38,22 @@ public fun JetElement.getDebugText(): String {
 }
 
 
-private object DebugTextBuildingVisitor : JetVisitor<String, Unit>() {
+private object DebugTextBuildingVisitor : KtVisitor<String, Unit>() {
 
     private val LOG = Logger.getInstance(this.javaClass)
 
-    override fun visitJetFile(file: JetFile, data: Unit?): String? {
+    override fun visitJetFile(file: KtFile, data: Unit?): String? {
         return "STUB file: ${file.getName()}"
     }
 
-    override fun visitJetElement(element: JetElement, data: Unit?): String? {
-        if (element is JetElementImplStub<*>) {
+    override fun visitJetElement(element: KtElement, data: Unit?): String? {
+        if (element is KtElementImplStub<*>) {
             LOG.error("getDebugText() is not defined for ${element.javaClass}")
         }
         return element.getText()
     }
 
-    override fun visitImportDirective(importDirective: JetImportDirective, data: Unit?): String? {
+    override fun visitImportDirective(importDirective: KtImportDirective, data: Unit?): String? {
         val importPath = importDirective.getImportPath()
         if (importPath == null) {
             return "import <invalid>"
@@ -62,67 +62,67 @@ private object DebugTextBuildingVisitor : JetVisitor<String, Unit>() {
         return "import ${importPath.getPathStr()}" + aliasStr
     }
 
-    override fun visitImportList(importList: JetImportList, data: Unit?): String? {
+    override fun visitImportList(importList: KtImportList, data: Unit?): String? {
         return renderChildren(importList, separator = "\n")
     }
 
-    override fun visitAnnotationEntry(annotationEntry: JetAnnotationEntry, data: Unit?): String? {
+    override fun visitAnnotationEntry(annotationEntry: KtAnnotationEntry, data: Unit?): String? {
         return render(annotationEntry, annotationEntry.getCalleeExpression(), annotationEntry.getTypeArgumentList())
     }
 
-    override fun visitTypeReference(typeReference: JetTypeReference, data: Unit?): String? {
+    override fun visitTypeReference(typeReference: KtTypeReference, data: Unit?): String? {
         return renderChildren(typeReference, " ")
     }
 
-    override fun visitTypeArgumentList(typeArgumentList: JetTypeArgumentList, data: Unit?): String? {
+    override fun visitTypeArgumentList(typeArgumentList: KtTypeArgumentList, data: Unit?): String? {
         return renderChildren(typeArgumentList, ", ", "<", ">")
     }
 
-    override fun visitTypeConstraintList(list: JetTypeConstraintList, data: Unit?): String? {
+    override fun visitTypeConstraintList(list: KtTypeConstraintList, data: Unit?): String? {
         return renderChildren(list, ", ", "where ", "")
     }
 
-    override fun visitUserType(userType: JetUserType, data: Unit?): String? {
+    override fun visitUserType(userType: KtUserType, data: Unit?): String? {
         return render(userType, userType.getQualifier(), userType.getReferenceExpression(), userType.getTypeArgumentList())
     }
 
-    override fun visitDynamicType(type: JetDynamicType, data: Unit?): String? {
+    override fun visitDynamicType(type: KtDynamicType, data: Unit?): String? {
         return "dynamic"
     }
 
-    override fun visitAnnotation(annotation: JetAnnotation, data: Unit?): String? {
+    override fun visitAnnotation(annotation: KtAnnotation, data: Unit?): String? {
         return renderChildren(annotation, " ", "[", "]")
     }
 
-    override fun visitConstructorCalleeExpression(constructorCalleeExpression: JetConstructorCalleeExpression, data: Unit?): String? {
+    override fun visitConstructorCalleeExpression(constructorCalleeExpression: KtConstructorCalleeExpression, data: Unit?): String? {
         return render(constructorCalleeExpression, constructorCalleeExpression.getConstructorReferenceExpression())
     }
 
-    override fun visitDelegationSpecifier(specifier: JetDelegationSpecifier, data: Unit?): String? {
+    override fun visitDelegationSpecifier(specifier: KtDelegationSpecifier, data: Unit?): String? {
         return render(specifier, specifier.getTypeReference())
     }
 
-    override fun visitDelegationSpecifierList(list: JetDelegationSpecifierList, data: Unit?): String? {
+    override fun visitDelegationSpecifierList(list: KtDelegationSpecifierList, data: Unit?): String? {
         return renderChildren(list, ", ")
     }
 
-    override fun visitTypeParameterList(list: JetTypeParameterList, data: Unit?): String? {
+    override fun visitTypeParameterList(list: KtTypeParameterList, data: Unit?): String? {
         return renderChildren(list, ", ", "<", ">")
     }
 
-    override fun visitDotQualifiedExpression(expression: JetDotQualifiedExpression, data: Unit?): String? {
+    override fun visitDotQualifiedExpression(expression: KtDotQualifiedExpression, data: Unit?): String? {
         return renderChildren(expression, ".")
     }
 
-    override fun visitInitializerList(list: JetInitializerList, data: Unit?): String? {
+    override fun visitInitializerList(list: KtInitializerList, data: Unit?): String? {
         return renderChildren(list, ", ")
     }
 
-    override fun visitParameterList(list: JetParameterList, data: Unit?): String? {
+    override fun visitParameterList(list: KtParameterList, data: Unit?): String? {
         return renderChildren(list, ", ", "(", ")")
     }
 
-    override fun visitEnumEntry(enumEntry: JetEnumEntry, data: Unit?): String? {
+    override fun visitEnumEntry(enumEntry: KtEnumEntry, data: Unit?): String? {
         return buildText {
             append("STUB: ")
             appendInn(enumEntry.getModifierList(), suffix = " ")
@@ -132,7 +132,7 @@ private object DebugTextBuildingVisitor : JetVisitor<String, Unit>() {
         }
     }
 
-    override fun visitFunctionType(functionType: JetFunctionType, data: Unit?): String? {
+    override fun visitFunctionType(functionType: KtFunctionType, data: Unit?): String? {
         return buildText {
             appendInn(functionType.getReceiverTypeReference(), suffix = ".")
             appendInn(functionType.getParameterList())
@@ -140,7 +140,7 @@ private object DebugTextBuildingVisitor : JetVisitor<String, Unit>() {
         }
     }
 
-    override fun visitTypeParameter(parameter: JetTypeParameter, data: Unit?): String? {
+    override fun visitTypeParameter(parameter: KtTypeParameter, data: Unit?): String? {
         return buildText {
             appendInn(parameter.getModifierList(), suffix = " ")
             appendInn(parameter.getNameAsName())
@@ -148,7 +148,7 @@ private object DebugTextBuildingVisitor : JetVisitor<String, Unit>() {
         }
     }
 
-    override fun visitTypeProjection(typeProjection: JetTypeProjection, data: Unit?): String? {
+    override fun visitTypeProjection(typeProjection: KtTypeProjection, data: Unit?): String? {
         return buildText {
             val token = typeProjection.getProjectionKind().getToken()
             appendInn(token?.getValue())
@@ -160,10 +160,10 @@ private object DebugTextBuildingVisitor : JetVisitor<String, Unit>() {
         }
     }
 
-    override fun visitModifierList(list: JetModifierList, data: Unit?): String? {
+    override fun visitModifierList(list: KtModifierList, data: Unit?): String? {
         return buildText {
             var first = true
-            for (modifierKeywordToken in JetTokens.MODIFIER_KEYWORDS_ARRAY) {
+            for (modifierKeywordToken in KtTokens.MODIFIER_KEYWORDS_ARRAY) {
                 if (list.hasModifier(modifierKeywordToken)) {
                     if (!first) {
                         append(" ")
@@ -175,31 +175,31 @@ private object DebugTextBuildingVisitor : JetVisitor<String, Unit>() {
         }
     }
 
-    override fun visitSimpleNameExpression(expression: JetSimpleNameExpression, data: Unit?): String? {
+    override fun visitSimpleNameExpression(expression: KtSimpleNameExpression, data: Unit?): String? {
         return expression.getReferencedName()
     }
 
-    override fun visitNullableType(nullableType: JetNullableType, data: Unit?): String? {
+    override fun visitNullableType(nullableType: KtNullableType, data: Unit?): String? {
         return renderChildren(nullableType, "", "", "?")
     }
 
-    override fun visitAnonymousInitializer(initializer: JetClassInitializer, data: Unit?): String? {
-        val containingDeclaration = JetStubbedPsiUtil.getContainingDeclaration(initializer)
+    override fun visitAnonymousInitializer(initializer: KtClassInitializer, data: Unit?): String? {
+        val containingDeclaration = KtStubbedPsiUtil.getContainingDeclaration(initializer)
         return "initializer in " + (containingDeclaration?.getDebugText() ?: "...")
     }
 
-    override fun visitClassBody(classBody: JetClassBody, data: Unit?): String? {
-        val containingDeclaration = JetStubbedPsiUtil.getContainingDeclaration(classBody)
+    override fun visitClassBody(classBody: KtClassBody, data: Unit?): String? {
+        val containingDeclaration = KtStubbedPsiUtil.getContainingDeclaration(classBody)
         return "class body for " + (containingDeclaration?.getDebugText() ?: "...")
     }
 
-    override fun visitPropertyAccessor(accessor: JetPropertyAccessor, data: Unit?): String? {
-        val containingProperty = JetStubbedPsiUtil.getContainingDeclaration(accessor, javaClass<JetProperty>())
+    override fun visitPropertyAccessor(accessor: KtPropertyAccessor, data: Unit?): String? {
+        val containingProperty = KtStubbedPsiUtil.getContainingDeclaration(accessor, javaClass<KtProperty>())
         val what = (if (accessor.isGetter()) "getter" else "setter")
         return what + " for " + (if (containingProperty != null) containingProperty.getDebugText() else "...")
     }
 
-    override fun visitClass(klass: JetClass, data: Unit?): String? {
+    override fun visitClass(klass: KtClass, data: Unit?): String? {
         return buildText {
             append("STUB: ")
             appendInn(klass.getModifierList(), suffix = " ")
@@ -212,7 +212,7 @@ private object DebugTextBuildingVisitor : JetVisitor<String, Unit>() {
         }
     }
 
-    override fun visitNamedFunction(function: JetNamedFunction, data: Unit?): String? {
+    override fun visitNamedFunction(function: KtNamedFunction, data: Unit?): String? {
         return buildText {
             append("STUB: ")
             appendInn(function.getModifierList(), suffix = " ")
@@ -233,7 +233,7 @@ private object DebugTextBuildingVisitor : JetVisitor<String, Unit>() {
         }
     }
 
-    override fun visitObjectDeclaration(declaration: JetObjectDeclaration, data: Unit?): String? {
+    override fun visitObjectDeclaration(declaration: KtObjectDeclaration, data: Unit?): String? {
         return buildText {
             append("STUB: ")
             appendInn(declaration.getModifierList(), suffix = " ")
@@ -243,7 +243,7 @@ private object DebugTextBuildingVisitor : JetVisitor<String, Unit>() {
         }
     }
 
-    override fun visitParameter(parameter: JetParameter, data: Unit?): String? {
+    override fun visitParameter(parameter: KtParameter, data: Unit?): String? {
         return buildText {
             if (parameter.hasValOrVar()) {
                 if (parameter.isMutable()) append("var ") else append("val ")
@@ -258,7 +258,7 @@ private object DebugTextBuildingVisitor : JetVisitor<String, Unit>() {
         }
     }
 
-    override fun visitProperty(property: JetProperty, data: Unit?): String? {
+    override fun visitProperty(property: KtProperty, data: Unit?): String? {
         return buildText {
             append("STUB: ")
             appendInn(property.getModifierList(), suffix = " ")
@@ -268,7 +268,7 @@ private object DebugTextBuildingVisitor : JetVisitor<String, Unit>() {
         }
     }
 
-    override fun visitTypeConstraint(constraint: JetTypeConstraint, data: Unit?): String? {
+    override fun visitTypeConstraint(constraint: KtTypeConstraint, data: Unit?): String? {
         return buildText {
             appendInn(constraint.getSubjectTypeParameterName())
             appendInn(constraint.getBoundTypeReference(), prefix = " : ")
@@ -281,12 +281,12 @@ private object DebugTextBuildingVisitor : JetVisitor<String, Unit>() {
         return sb.toString()
     }
 
-    fun renderChildren(element: JetElementImplStub<*>, separator: String, prefix: String = "", postfix: String = ""): String? {
-        val childrenTexts = element.getStub()?.getChildrenStubs()?.map { (it?.getPsi() as? JetElement)?.getDebugText() }
+    fun renderChildren(element: KtElementImplStub<*>, separator: String, prefix: String = "", postfix: String = ""): String? {
+        val childrenTexts = element.getStub()?.getChildrenStubs()?.map { (it?.getPsi() as? KtElement)?.getDebugText() }
         return childrenTexts?.filterNotNull()?.join(separator, prefix, postfix) ?: element.getText()
     }
 
-    fun render(element: JetElementImplStub<*>, vararg relevantChildren: JetElement?): String? {
+    fun render(element: KtElementImplStub<*>, vararg relevantChildren: KtElement?): String? {
         if (element.getStub() == null) return element.getText()
         return relevantChildren.filterNotNull().map { it.getDebugText() }.join("", "", "")
     }
@@ -296,7 +296,7 @@ private fun StringBuilder.appendInn(target: Any?, prefix: String = "", suffix: S
     if (target == null) return
     append(prefix)
     append(when (target) {
-               is JetElement -> target.getDebugText()
+               is KtElement -> target.getDebugText()
                else -> target.toString()
            })
     append(suffix)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/EditCommaSeparatedListHelper.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/EditCommaSeparatedListHelper.kt
index 8646a70dabd..b2c129b26e3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/EditCommaSeparatedListHelper.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/EditCommaSeparatedListHelper.kt
@@ -18,18 +18,18 @@ package org.jetbrains.kotlin.psi
 
 import com.intellij.psi.PsiComment
 import com.intellij.psi.PsiWhiteSpace
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.psiUtil.siblings
 
 internal object EditCommaSeparatedListHelper {
-    public fun <TItem: JetElement> addItem(list: JetElement, allItems: List<TItem>, item: TItem): TItem {
+    public fun <TItem: KtElement> addItem(list: KtElement, allItems: List<TItem>, item: TItem): TItem {
         return addItemBefore(list, allItems, item, null)
     }
 
-    public fun <TItem: JetElement> addItemAfter(list: JetElement, allItems: List<TItem>, item: TItem, anchor: TItem?): TItem {
+    public fun <TItem: KtElement> addItemAfter(list: KtElement, allItems: List<TItem>, item: TItem, anchor: TItem?): TItem {
         assert(anchor == null || anchor.getParent() == list)
         if (allItems.isEmpty()) {
-            if (list.getFirstChild().getNode().getElementType() == JetTokens.LPAR) {
+            if (list.getFirstChild().getNode().getElementType() == KtTokens.LPAR) {
                 return list.addAfter(item, list.getFirstChild()) as TItem
             }
             else {
@@ -37,7 +37,7 @@ internal object EditCommaSeparatedListHelper {
             }
         }
         else {
-            var comma = JetPsiFactory(list).createComma()
+            var comma = KtPsiFactory(list).createComma()
             if (anchor != null) {
                 comma = list.addAfter(comma, anchor)
                 return list.addAfter(item, comma) as TItem
@@ -49,7 +49,7 @@ internal object EditCommaSeparatedListHelper {
         }
     }
 
-    public fun <TItem: JetElement> addItemBefore(list: JetElement, allItems: List<TItem>, item: TItem, anchor: TItem?): TItem {
+    public fun <TItem: KtElement> addItemBefore(list: KtElement, allItems: List<TItem>, item: TItem, anchor: TItem?): TItem {
         val anchorAfter: TItem?
         if (allItems.isEmpty()) {
             assert(anchor == null)
@@ -68,11 +68,11 @@ internal object EditCommaSeparatedListHelper {
         return addItemAfter(list, allItems, item, anchorAfter)
     }
 
-    public fun <TItem: JetElement> removeItem(item: TItem) {
+    public fun <TItem: KtElement> removeItem(item: TItem) {
         var comma = item.siblings(withItself = false).firstOrNull { it !is PsiWhiteSpace && it !is PsiComment }
-        if (comma?.getNode()?.getElementType() != JetTokens.COMMA) {
+        if (comma?.getNode()?.getElementType() != KtTokens.COMMA) {
             comma = item.siblings(forward = false, withItself = false).firstOrNull { it !is PsiWhiteSpace && it !is PsiComment }
-            if (comma?.getNode()?.getElementType() != JetTokens.COMMA) {
+            if (comma?.getNode()?.getElementType() != KtTokens.COMMA) {
                 comma = null
             }
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/FindDocComment.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/FindDocComment.kt
index a4fcb9b9dda..0da644e47fc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/FindDocComment.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/FindDocComment.kt
@@ -16,14 +16,14 @@
 
 package org.jetbrains.kotlin.psi.findDocComment
 
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.kdoc.psi.api.KDoc
 import org.jetbrains.kotlin.psi.psiUtil.siblings
 import com.intellij.psi.PsiWhiteSpace
 import com.intellij.psi.PsiComment
 import org.jetbrains.kotlin.psi.psiUtil.allChildren
 
-fun findDocComment(declaration: JetDeclaration): KDoc? {
+fun findDocComment(declaration: KtDeclaration): KDoc? {
     return declaration.allChildren
             .dropWhile { it !is KDoc && (it is PsiWhiteSpace || it is PsiComment) }
             .first() as? KDoc
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionImpl.kt
deleted file mode 100644
index 5a4e9da1de0..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionImpl.kt
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.psi
-
-import com.intellij.lang.ASTNode
-import com.intellij.psi.PsiElement
-import com.intellij.util.IncorrectOperationException
-import org.jetbrains.kotlin.JetNodeType
-
-public abstract class JetExpressionImpl(node: ASTNode) : JetElementImpl(node), JetExpression {
-
-    override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D) = visitor.visitExpression(this, data)
-
-    protected fun findExpressionUnder(type: JetNodeType): JetExpression? {
-        val containerNode = findChildByType<JetContainerNode>(type) ?: return null
-        return containerNode.findChildByClass<JetExpression>(javaClass())
-    }
-
-    override fun replace(newElement: PsiElement): PsiElement {
-        return replaceExpression(this, newElement, { super<JetElementImpl>.replace(it) })
-    }
-
-    companion object {
-        fun replaceExpression(expression: JetExpression, newElement: PsiElement, rawReplaceHandler: (PsiElement) -> PsiElement): PsiElement {
-            val parent = expression.getParent()
-
-            if (newElement is JetExpression) {
-                when (parent) {
-                    is JetExpression -> {
-                        if (JetPsiUtil.areParenthesesNecessary(newElement, expression, parent)) {
-                            return rawReplaceHandler(JetPsiFactory(expression).createExpressionByPattern("($0)", newElement))
-                        }
-                    }
-
-                    is JetSimpleNameStringTemplateEntry -> {
-                        if (newElement !is JetSimpleNameExpression) {
-                            val newEntry = parent.replace(JetPsiFactory(expression).createBlockStringTemplateEntry(newElement)) as JetBlockStringTemplateEntry
-                            return newEntry.getExpression()!!
-                        }
-                    }
-                }
-            }
-
-            return rawReplaceHandler(newElement)
-        }
-    }
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVisitor.java
deleted file mode 100644
index fd9012abb70..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVisitor.java
+++ /dev/null
@@ -1,448 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.psi;
-
-import com.intellij.psi.PsiElementVisitor;
-import org.jetbrains.annotations.NotNull;
-
-public class JetVisitor<R, D> extends PsiElementVisitor {
-    public R visitJetElement(@NotNull JetElement element, D data) {
-        visitElement(element);
-        return null;
-    }
-
-    public R visitDeclaration(@NotNull JetDeclaration dcl, D data) {
-        return visitExpression(dcl, data);
-    }
-
-    public R visitClass(@NotNull JetClass klass, D data) {
-        return visitClassOrObject(klass, data);
-    }
-
-    public R visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, D data) {
-        return visitClassOrObject(declaration, data);
-    }
-
-    public R visitClassOrObject(@NotNull JetClassOrObject classOrObject, D data) {
-        return visitNamedDeclaration(classOrObject, data);
-    }
-
-    public R visitSecondaryConstructor(@NotNull JetSecondaryConstructor constructor, D data) {
-        return visitDeclaration(constructor, data);
-    }
-
-    public R visitPrimaryConstructor(@NotNull JetPrimaryConstructor constructor, D data) {
-        return visitDeclaration(constructor, data);
-    }
-
-    public R visitNamedFunction(@NotNull JetNamedFunction function, D data) {
-        return visitNamedDeclaration(function, data);
-    }
-
-    public R visitProperty(@NotNull JetProperty property, D data) {
-        return visitNamedDeclaration(property, data);
-    }
-
-    public R visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration, D data) {
-        return visitDeclaration(multiDeclaration, data);
-    }
-
-    public R visitMultiDeclarationEntry(@NotNull JetMultiDeclarationEntry multiDeclarationEntry, D data) {
-        return visitNamedDeclaration(multiDeclarationEntry, data);
-    }
-
-    public R visitTypedef(@NotNull JetTypedef typedef, D data) {
-        return visitNamedDeclaration(typedef, data);
-    }
-
-    public R visitJetFile(@NotNull JetFile file, D data) {
-        visitFile(file);
-        return null;
-    }
-
-    public R visitScript(@NotNull JetScript script, D data) {
-        return visitDeclaration(script, data);
-    }
-
-    public R visitImportDirective(@NotNull JetImportDirective importDirective, D data) {
-        return visitJetElement(importDirective, data);
-    }
-
-    public R visitImportList(@NotNull JetImportList importList, D data) {
-        return visitJetElement(importList, data);
-    }
-
-    public R visitFileAnnotationList(@NotNull JetFileAnnotationList fileAnnotationList, D data) {
-        return visitJetElement(fileAnnotationList, data);
-    }
-
-    public R visitClassBody(@NotNull JetClassBody classBody, D data) {
-        return visitJetElement(classBody, data);
-    }
-
-    public R visitModifierList(@NotNull JetModifierList list, D data) {
-        return visitJetElement(list, data);
-    }
-
-    public R visitAnnotation(@NotNull JetAnnotation annotation, D data) {
-        return visitJetElement(annotation, data);
-    }
-
-    public R visitAnnotationEntry(@NotNull JetAnnotationEntry annotationEntry, D data) {
-        return visitJetElement(annotationEntry, data);
-    }
-
-    public R visitAnnotationUseSiteTarget(@NotNull JetAnnotationUseSiteTarget annotationTarget, D data) {
-        return visitJetElement(annotationTarget, data);
-    }
-
-    public R visitConstructorCalleeExpression(@NotNull JetConstructorCalleeExpression constructorCalleeExpression, D data) {
-        return visitJetElement(constructorCalleeExpression, data);
-    }
-
-    public R visitTypeParameterList(@NotNull JetTypeParameterList list, D data) {
-        return visitJetElement(list, data);
-    }
-
-    public R visitTypeParameter(@NotNull JetTypeParameter parameter, D data) {
-        return visitNamedDeclaration(parameter, data);
-    }
-
-    public R visitEnumEntry(@NotNull JetEnumEntry enumEntry, D data) {
-        return visitClass(enumEntry, data);
-    }
-
-    public R visitParameterList(@NotNull JetParameterList list, D data) {
-        return visitJetElement(list, data);
-    }
-
-    public R visitParameter(@NotNull JetParameter parameter, D data) {
-        return visitNamedDeclaration(parameter, data);
-    }
-
-    public R visitDelegationSpecifierList(@NotNull JetDelegationSpecifierList list, D data) {
-        return visitJetElement(list, data);
-    }
-
-    public R visitDelegationSpecifier(@NotNull JetDelegationSpecifier specifier, D data) {
-        return visitJetElement(specifier, data);
-    }
-
-    public R visitDelegationByExpressionSpecifier(@NotNull JetDelegatorByExpressionSpecifier specifier, D data) {
-        return visitDelegationSpecifier(specifier, data);
-    }
-
-    public R visitDelegationToSuperCallSpecifier(@NotNull JetDelegatorToSuperCall call, D data) {
-        return visitDelegationSpecifier(call, data);
-    }
-
-    public R visitDelegationToSuperClassSpecifier(@NotNull JetDelegatorToSuperClass specifier, D data) {
-        return visitDelegationSpecifier(specifier, data);
-    }
-
-    public R visitConstructorDelegationCall(@NotNull JetConstructorDelegationCall call, D data) {
-        return visitJetElement(call, data);
-    }
-
-    public R visitPropertyDelegate(@NotNull JetPropertyDelegate delegate, D data) {
-        return visitJetElement(delegate, data);
-    }
-
-    public R visitTypeReference(@NotNull JetTypeReference typeReference, D data) {
-        return visitJetElement(typeReference, data);
-    }
-
-    public R visitValueArgumentList(@NotNull JetValueArgumentList list, D data) {
-        return visitJetElement(list, data);
-    }
-
-    public R visitArgument(@NotNull JetValueArgument argument, D data) {
-        return visitJetElement(argument, data);
-    }
-
-    public R visitExpression(@NotNull JetExpression expression, D data) {
-        return visitJetElement(expression, data);
-    }
-
-    public R visitLoopExpression(@NotNull JetLoopExpression loopExpression, D data) {
-        return visitExpression(loopExpression, data);
-    }
-
-    public R visitConstantExpression(@NotNull JetConstantExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression, D data) {
-        return visitReferenceExpression(expression, data);
-    }
-
-    public R visitReferenceExpression(@NotNull JetReferenceExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitLabeledExpression(@NotNull JetLabeledExpression expression, D data) {
-        return visitExpressionWithLabel(expression, data);
-    }
-
-    public R visitPrefixExpression(@NotNull JetPrefixExpression expression, D data) {
-        return visitUnaryExpression(expression, data);
-    }
-
-    public R visitPostfixExpression(@NotNull JetPostfixExpression expression, D data) {
-        return visitUnaryExpression(expression, data);
-    }
-
-    public R visitUnaryExpression(@NotNull JetUnaryExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitBinaryExpression(@NotNull JetBinaryExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitReturnExpression(@NotNull JetReturnExpression expression, D data) {
-        return visitExpressionWithLabel(expression, data);
-    }
-
-    public R visitExpressionWithLabel(@NotNull JetExpressionWithLabel expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitThrowExpression(@NotNull JetThrowExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitBreakExpression(@NotNull JetBreakExpression expression, D data) {
-        return visitExpressionWithLabel(expression, data);
-    }
-
-    public R visitContinueExpression(@NotNull JetContinueExpression expression, D data) {
-        return visitExpressionWithLabel(expression, data);
-    }
-
-    public R visitIfExpression(@NotNull JetIfExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitWhenExpression(@NotNull JetWhenExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitTryExpression(@NotNull JetTryExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitForExpression(@NotNull JetForExpression expression, D data) {
-        return visitLoopExpression(expression, data);
-    }
-
-    public R visitWhileExpression(@NotNull JetWhileExpression expression, D data) {
-        return visitLoopExpression(expression, data);
-    }
-
-    public R visitDoWhileExpression(@NotNull JetDoWhileExpression expression, D data) {
-        return visitLoopExpression(expression, data);
-    }
-
-    public R visitFunctionLiteralExpression(@NotNull JetFunctionLiteralExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitAnnotatedExpression(@NotNull JetAnnotatedExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitCallExpression(@NotNull JetCallExpression expression, D data) {
-        return visitReferenceExpression(expression, data);
-    }
-
-    public R visitArrayAccessExpression(@NotNull JetArrayAccessExpression expression, D data) {
-        return visitReferenceExpression(expression, data);
-    }
-
-    public R visitQualifiedExpression(@NotNull JetQualifiedExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitDoubleColonExpression(@NotNull JetDoubleColonExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitCallableReferenceExpression(@NotNull JetCallableReferenceExpression expression, D data) {
-        return visitDoubleColonExpression(expression, data);
-    }
-
-    public R visitClassLiteralExpression(@NotNull JetClassLiteralExpression expression, D data) {
-        return visitDoubleColonExpression(expression, data);
-    }
-
-    public R visitDotQualifiedExpression(@NotNull JetDotQualifiedExpression expression, D data) {
-        return visitQualifiedExpression(expression, data);
-    }
-
-    public R visitSafeQualifiedExpression(@NotNull JetSafeQualifiedExpression expression, D data) {
-        return visitQualifiedExpression(expression, data);
-    }
-
-    public R visitObjectLiteralExpression(@NotNull JetObjectLiteralExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitRootPackageExpression(@NotNull JetRootPackageExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitBlockExpression(@NotNull JetBlockExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitCatchSection(@NotNull JetCatchClause catchClause, D data) {
-        return visitJetElement(catchClause, data);
-    }
-
-    public R visitFinallySection(@NotNull JetFinallySection finallySection, D data) {
-        return visitJetElement(finallySection, data);
-    }
-
-    public R visitTypeArgumentList(@NotNull JetTypeArgumentList typeArgumentList, D data) {
-        return visitJetElement(typeArgumentList, data);
-    }
-
-    public R visitThisExpression(@NotNull JetThisExpression expression, D data) {
-        return visitExpressionWithLabel(expression, data);
-    }
-
-    public R visitSuperExpression(@NotNull JetSuperExpression expression, D data) {
-        return visitExpressionWithLabel(expression, data);
-    }
-
-    public R visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitInitializerList(@NotNull JetInitializerList list, D data) {
-        return visitJetElement(list, data);
-    }
-
-    public R visitAnonymousInitializer(@NotNull JetClassInitializer initializer, D data) {
-        return visitDeclaration(initializer, data);
-    }
-
-    public R visitPropertyAccessor(@NotNull JetPropertyAccessor accessor, D data) {
-        return visitDeclaration(accessor, data);
-    }
-
-    public R visitTypeConstraintList(@NotNull JetTypeConstraintList list, D data) {
-        return visitJetElement(list, data);
-    }
-
-    public R visitTypeConstraint(@NotNull JetTypeConstraint constraint, D data) {
-        return visitJetElement(constraint, data);
-    }
-
-    private R visitTypeElement(@NotNull JetTypeElement type, D data) {
-        return visitJetElement(type, data);
-    }
-
-    public R visitUserType(@NotNull JetUserType type, D data) {
-        return visitTypeElement(type, data);
-    }
-
-    public R visitDynamicType(@NotNull JetDynamicType type, D data) {
-        return visitTypeElement(type, data);
-    }
-
-    public R visitFunctionType(@NotNull JetFunctionType type, D data) {
-        return visitTypeElement(type, data);
-    }
-
-    public R visitSelfType(@NotNull JetSelfType type, D data) {
-        return visitTypeElement(type, data);
-    }
-
-    public R visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitStringTemplateExpression(@NotNull JetStringTemplateExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitNamedDeclaration(@NotNull JetNamedDeclaration declaration, D data) {
-        return visitDeclaration(declaration, data);
-    }
-
-    public R visitNullableType(@NotNull JetNullableType nullableType, D data) {
-        return visitTypeElement(nullableType, data);
-    }
-
-    public R visitTypeProjection(@NotNull JetTypeProjection typeProjection, D data) {
-        return visitJetElement(typeProjection, data);
-    }
-
-    public R visitWhenEntry(@NotNull JetWhenEntry jetWhenEntry, D data) {
-        return visitJetElement(jetWhenEntry, data);
-    }
-
-    public R visitIsExpression(@NotNull JetIsExpression expression, D data) {
-        return visitExpression(expression, data);
-    }
-
-    public R visitWhenConditionIsPattern(@NotNull JetWhenConditionIsPattern condition, D data) {
-        return visitJetElement(condition, data);
-    }
-
-    public R visitWhenConditionInRange(@NotNull JetWhenConditionInRange condition, D data) {
-        return visitJetElement(condition, data);
-    }
-
-    public R visitWhenConditionWithExpression(@NotNull JetWhenConditionWithExpression condition, D data) {
-        return visitJetElement(condition, data);
-    }
-
-    public R visitObjectDeclarationName(@NotNull JetObjectDeclarationName declarationName, D data) {
-        return visitExpression(declarationName, data);
-    }
-
-    public R visitStringTemplateEntry(@NotNull JetStringTemplateEntry entry, D data) {
-        return visitJetElement(entry, data);
-    }
-
-    public R visitStringTemplateEntryWithExpression(@NotNull JetStringTemplateEntryWithExpression entry, D data) {
-        return visitStringTemplateEntry(entry, data);
-    }
-
-    public R visitBlockStringTemplateEntry(@NotNull JetBlockStringTemplateEntry entry, D data) {
-        return visitStringTemplateEntryWithExpression(entry, data);
-    }
-
-    public R visitSimpleNameStringTemplateEntry(@NotNull JetSimpleNameStringTemplateEntry entry, D data) {
-        return visitStringTemplateEntryWithExpression(entry, data);
-    }
-
-    public R visitLiteralStringTemplateEntry(@NotNull JetLiteralStringTemplateEntry entry, D data) {
-        return visitStringTemplateEntry(entry, data);
-    }
-
-    public R visitEscapeStringTemplateEntry(@NotNull JetEscapeStringTemplateEntry entry, D data) {
-        return visitStringTemplateEntry(entry, data);
-    }
-
-    public R visitPackageDirective(@NotNull JetPackageDirective directive, D data) {
-        return visitJetElement(directive, data);
-    }
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVisitorVoid.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVisitorVoid.java
deleted file mode 100644
index d534aa938fc..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVisitorVoid.java
+++ /dev/null
@@ -1,1056 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.psi;
-
-import org.jetbrains.annotations.NotNull;
-
-public class JetVisitorVoid extends JetVisitor<Void, Void> {
-    // methods with void return
-
-    public void visitJetElement(@NotNull JetElement element) {
-        super.visitJetElement(element, null);
-    }
-
-    public void visitDeclaration(@NotNull JetDeclaration dcl) {
-        super.visitDeclaration(dcl, null);
-    }
-
-    public void visitClass(@NotNull JetClass klass) {
-        super.visitClass(klass, null);
-    }
-
-    public void visitClassOrObject(@NotNull JetClassOrObject classOrObject) {
-        super.visitClassOrObject(classOrObject, null);
-    }
-
-    public void visitSecondaryConstructor(@NotNull JetSecondaryConstructor constructor) {
-        super.visitSecondaryConstructor(constructor, null);
-    }
-
-    public void visitPrimaryConstructor(@NotNull JetPrimaryConstructor constructor) {
-        super.visitPrimaryConstructor(constructor, null);
-    }
-
-    public void visitNamedFunction(@NotNull JetNamedFunction function) {
-        super.visitNamedFunction(function, null);
-    }
-
-    public void visitProperty(@NotNull JetProperty property) {
-        super.visitProperty(property, null);
-    }
-
-    public void visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration) {
-        super.visitMultiDeclaration(multiDeclaration, null);
-    }
-
-    public void visitMultiDeclarationEntry(@NotNull JetMultiDeclarationEntry multiDeclarationEntry) {
-        super.visitMultiDeclarationEntry(multiDeclarationEntry, null);
-    }
-
-    public void visitTypedef(@NotNull JetTypedef typedef) {
-        super.visitTypedef(typedef, null);
-    }
-
-    public void visitJetFile(@NotNull JetFile file) {
-        super.visitJetFile(file, null);
-    }
-
-    public void visitScript(@NotNull JetScript script) {
-        super.visitScript(script, null);
-    }
-
-    public void visitImportDirective(@NotNull JetImportDirective importDirective) {
-        super.visitImportDirective(importDirective, null);
-    }
-
-    public void visitImportList(@NotNull JetImportList importList) {
-        super.visitImportList(importList, null);
-    }
-
-    public void visitClassBody(@NotNull JetClassBody classBody) {
-        super.visitClassBody(classBody, null);
-    }
-
-    public void visitModifierList(@NotNull JetModifierList list) {
-        super.visitModifierList(list, null);
-    }
-
-    public void visitAnnotation(@NotNull JetAnnotation annotation) {
-        super.visitAnnotation(annotation, null);
-    }
-
-    public void visitAnnotationEntry(@NotNull JetAnnotationEntry annotationEntry) {
-        super.visitAnnotationEntry(annotationEntry, null);
-    }
-
-    public void visitConstructorCalleeExpression(@NotNull JetConstructorCalleeExpression constructorCalleeExpression) {
-        super.visitConstructorCalleeExpression(constructorCalleeExpression, null);
-    }
-
-    public void visitTypeParameterList(@NotNull JetTypeParameterList list) {
-        super.visitTypeParameterList(list, null);
-    }
-
-    public void visitTypeParameter(@NotNull JetTypeParameter parameter) {
-        super.visitTypeParameter(parameter, null);
-    }
-
-    public void visitEnumEntry(@NotNull JetEnumEntry enumEntry) {
-        super.visitEnumEntry(enumEntry, null);
-    }
-
-    public void visitParameterList(@NotNull JetParameterList list) {
-        super.visitParameterList(list, null);
-    }
-
-    public void visitParameter(@NotNull JetParameter parameter) {
-        super.visitParameter(parameter, null);
-    }
-
-    public void visitDelegationSpecifierList(@NotNull JetDelegationSpecifierList list) {
-        super.visitDelegationSpecifierList(list, null);
-    }
-
-    public void visitDelegationSpecifier(@NotNull JetDelegationSpecifier specifier) {
-        super.visitDelegationSpecifier(specifier, null);
-    }
-
-    public void visitDelegationByExpressionSpecifier(@NotNull JetDelegatorByExpressionSpecifier specifier) {
-        super.visitDelegationByExpressionSpecifier(specifier, null);
-    }
-
-    public void visitDelegationToSuperCallSpecifier(@NotNull JetDelegatorToSuperCall call) {
-        super.visitDelegationToSuperCallSpecifier(call, null);
-    }
-
-    public void visitDelegationToSuperClassSpecifier(@NotNull JetDelegatorToSuperClass specifier) {
-        super.visitDelegationToSuperClassSpecifier(specifier, null);
-    }
-
-    public void visitConstructorDelegationCall(@NotNull JetConstructorDelegationCall call) {
-        super.visitConstructorDelegationCall(call, null);
-    }
-
-    public void visitPropertyDelegate(@NotNull JetPropertyDelegate delegate) {
-        super.visitPropertyDelegate(delegate, null);
-    }
-
-    public void visitTypeReference(@NotNull JetTypeReference typeReference) {
-        super.visitTypeReference(typeReference, null);
-    }
-
-    public void visitValueArgumentList(@NotNull JetValueArgumentList list) {
-        super.visitValueArgumentList(list, null);
-    }
-
-    public void visitArgument(@NotNull JetValueArgument argument) {
-        super.visitArgument(argument, null);
-    }
-
-    public void visitExpression(@NotNull JetExpression expression) {
-        super.visitExpression(expression, null);
-    }
-
-    public void visitLoopExpression(@NotNull JetLoopExpression loopExpression) {
-        super.visitLoopExpression(loopExpression, null);
-    }
-
-    public void visitConstantExpression(@NotNull JetConstantExpression expression) {
-        super.visitConstantExpression(expression, null);
-    }
-
-    public void visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression) {
-        super.visitSimpleNameExpression(expression, null);
-    }
-
-    public void visitReferenceExpression(@NotNull JetReferenceExpression expression) {
-        super.visitReferenceExpression(expression, null);
-    }
-
-    public void visitLabeledExpression(@NotNull JetLabeledExpression expression) {
-        super.visitLabeledExpression(expression, null);
-    }
-
-    public void visitPrefixExpression(@NotNull JetPrefixExpression expression) {
-        super.visitPrefixExpression(expression, null);
-    }
-
-    public void visitPostfixExpression(@NotNull JetPostfixExpression expression) {
-        super.visitPostfixExpression(expression, null);
-    }
-
-    public void visitUnaryExpression(@NotNull JetUnaryExpression expression) {
-        super.visitUnaryExpression(expression, null);
-    }
-
-    public void visitBinaryExpression(@NotNull JetBinaryExpression expression) {
-        super.visitBinaryExpression(expression, null);
-    }
-
-    public void visitReturnExpression(@NotNull JetReturnExpression expression) {
-        super.visitReturnExpression(expression, null);
-    }
-
-    public void visitExpressionWithLabel(@NotNull JetExpressionWithLabel expression) {
-        super.visitExpressionWithLabel(expression, null);
-    }
-
-    public void visitThrowExpression(@NotNull JetThrowExpression expression) {
-        super.visitThrowExpression(expression, null);
-    }
-
-    public void visitBreakExpression(@NotNull JetBreakExpression expression) {
-        super.visitBreakExpression(expression, null);
-    }
-
-    public void visitContinueExpression(@NotNull JetContinueExpression expression) {
-        super.visitContinueExpression(expression, null);
-    }
-
-    public void visitIfExpression(@NotNull JetIfExpression expression) {
-        super.visitIfExpression(expression, null);
-    }
-
-    public void visitWhenExpression(@NotNull JetWhenExpression expression) {
-        super.visitWhenExpression(expression, null);
-    }
-
-    public void visitTryExpression(@NotNull JetTryExpression expression) {
-        super.visitTryExpression(expression, null);
-    }
-
-    public void visitForExpression(@NotNull JetForExpression expression) {
-        super.visitForExpression(expression, null);
-    }
-
-    public void visitWhileExpression(@NotNull JetWhileExpression expression) {
-        super.visitWhileExpression(expression, null);
-    }
-
-    public void visitDoWhileExpression(@NotNull JetDoWhileExpression expression) {
-        super.visitDoWhileExpression(expression, null);
-    }
-
-    public void visitFunctionLiteralExpression(@NotNull JetFunctionLiteralExpression expression) {
-        super.visitFunctionLiteralExpression(expression, null);
-    }
-
-    public void visitAnnotatedExpression(@NotNull JetAnnotatedExpression expression) {
-        super.visitAnnotatedExpression(expression, null);
-    }
-
-    public void visitCallExpression(@NotNull JetCallExpression expression) {
-        super.visitCallExpression(expression, null);
-    }
-
-    public void visitArrayAccessExpression(@NotNull JetArrayAccessExpression expression) {
-        super.visitArrayAccessExpression(expression, null);
-    }
-
-    public void visitQualifiedExpression(@NotNull JetQualifiedExpression expression) {
-        super.visitQualifiedExpression(expression, null);
-    }
-
-    public void visitDoubleColonExpression(@NotNull JetDoubleColonExpression expression) {
-        super.visitDoubleColonExpression(expression, null);
-    }
-
-    public void visitCallableReferenceExpression(@NotNull JetCallableReferenceExpression expression) {
-        super.visitCallableReferenceExpression(expression, null);
-    }
-
-    public void visitClassLiteralExpression(@NotNull JetClassLiteralExpression expression) {
-        super.visitClassLiteralExpression(expression, null);
-    }
-
-    public void visitDotQualifiedExpression(@NotNull JetDotQualifiedExpression expression) {
-        super.visitDotQualifiedExpression(expression, null);
-    }
-
-    public void visitSafeQualifiedExpression(@NotNull JetSafeQualifiedExpression expression) {
-        super.visitSafeQualifiedExpression(expression, null);
-    }
-
-    public void visitObjectLiteralExpression(@NotNull JetObjectLiteralExpression expression) {
-        super.visitObjectLiteralExpression(expression, null);
-    }
-
-    public void visitRootPackageExpression(@NotNull JetRootPackageExpression expression) {
-        super.visitRootPackageExpression(expression, null);
-    }
-
-    public void visitBlockExpression(@NotNull JetBlockExpression expression) {
-        super.visitBlockExpression(expression, null);
-    }
-
-    public void visitCatchSection(@NotNull JetCatchClause catchClause) {
-        super.visitCatchSection(catchClause, null);
-    }
-
-    public void visitFinallySection(@NotNull JetFinallySection finallySection) {
-        super.visitFinallySection(finallySection, null);
-    }
-
-    public void visitTypeArgumentList(@NotNull JetTypeArgumentList typeArgumentList) {
-        super.visitTypeArgumentList(typeArgumentList, null);
-    }
-
-    public void visitThisExpression(@NotNull JetThisExpression expression) {
-        super.visitThisExpression(expression, null);
-    }
-
-    public void visitSuperExpression(@NotNull JetSuperExpression expression) {
-        super.visitSuperExpression(expression, null);
-    }
-
-    public void visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression) {
-        super.visitParenthesizedExpression(expression, null);
-    }
-
-    public void visitInitializerList(@NotNull JetInitializerList list) {
-        super.visitInitializerList(list, null);
-    }
-
-    public void visitAnonymousInitializer(@NotNull JetClassInitializer initializer) {
-        super.visitAnonymousInitializer(initializer, null);
-    }
-
-    public void visitPropertyAccessor(@NotNull JetPropertyAccessor accessor) {
-        super.visitPropertyAccessor(accessor, null);
-    }
-
-    public void visitTypeConstraintList(@NotNull JetTypeConstraintList list) {
-        super.visitTypeConstraintList(list, null);
-    }
-
-    public void visitTypeConstraint(@NotNull JetTypeConstraint constraint) {
-        super.visitTypeConstraint(constraint, null);
-    }
-
-    public void visitUserType(@NotNull JetUserType type) {
-        super.visitUserType(type, null);
-    }
-
-    public void visitDynamicType(@NotNull JetDynamicType type) {
-        super.visitDynamicType(type, null);
-    }
-
-    public void visitFunctionType(@NotNull JetFunctionType type) {
-        super.visitFunctionType(type, null);
-    }
-
-    public void visitSelfType(@NotNull JetSelfType type) {
-        super.visitSelfType(type, null);
-    }
-
-    public void visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS expression) {
-        super.visitBinaryWithTypeRHSExpression(expression, null);
-    }
-
-    public void visitStringTemplateExpression(@NotNull JetStringTemplateExpression expression) {
-        super.visitStringTemplateExpression(expression, null);
-    }
-
-    public void visitNamedDeclaration(@NotNull JetNamedDeclaration declaration) {
-        super.visitNamedDeclaration(declaration, null);
-    }
-
-    public void visitNullableType(@NotNull JetNullableType nullableType) {
-        super.visitNullableType(nullableType, null);
-    }
-
-    public void visitTypeProjection(@NotNull JetTypeProjection typeProjection) {
-        super.visitTypeProjection(typeProjection, null);
-    }
-
-    public void visitWhenEntry(@NotNull JetWhenEntry jetWhenEntry) {
-        super.visitWhenEntry(jetWhenEntry, null);
-    }
-
-    public void visitIsExpression(@NotNull JetIsExpression expression) {
-        super.visitIsExpression(expression, null);
-    }
-
-    public void visitWhenConditionIsPattern(@NotNull JetWhenConditionIsPattern condition) {
-        super.visitWhenConditionIsPattern(condition, null);
-    }
-
-    public void visitWhenConditionInRange(@NotNull JetWhenConditionInRange condition) {
-        super.visitWhenConditionInRange(condition, null);
-    }
-
-    public void visitWhenConditionWithExpression(@NotNull JetWhenConditionWithExpression condition) {
-        super.visitWhenConditionWithExpression(condition, null);
-    }
-
-    public void visitObjectDeclaration(@NotNull JetObjectDeclaration declaration) {
-        super.visitObjectDeclaration(declaration, null);
-    }
-
-    public void visitObjectDeclarationName(@NotNull JetObjectDeclarationName declarationName) {
-        super.visitObjectDeclarationName(declarationName, null);
-    }
-
-    public void visitStringTemplateEntry(@NotNull JetStringTemplateEntry entry) {
-        super.visitStringTemplateEntry(entry, null);
-    }
-
-    public void visitStringTemplateEntryWithExpression(@NotNull JetStringTemplateEntryWithExpression entry) {
-        super.visitStringTemplateEntryWithExpression(entry, null);
-    }
-
-    public void visitBlockStringTemplateEntry(@NotNull JetBlockStringTemplateEntry entry) {
-        super.visitBlockStringTemplateEntry(entry, null);
-    }
-
-    public void visitSimpleNameStringTemplateEntry(@NotNull JetSimpleNameStringTemplateEntry entry) {
-        super.visitSimpleNameStringTemplateEntry(entry, null);
-    }
-
-    public void visitLiteralStringTemplateEntry(@NotNull JetLiteralStringTemplateEntry entry) {
-        super.visitLiteralStringTemplateEntry(entry, null);
-    }
-
-    public void visitEscapeStringTemplateEntry(@NotNull JetEscapeStringTemplateEntry entry) {
-        super.visitEscapeStringTemplateEntry(entry, null);
-    }
-
-    public void visitPackageDirective(@NotNull JetPackageDirective directive) {
-        super.visitPackageDirective(directive, null);
-    }
-
-    // hidden methods
-    @Override
-    public final Void visitJetElement(@NotNull JetElement element, Void data) {
-        visitJetElement(element);
-        return null;
-    }
-
-    @Override
-    public final Void visitDeclaration(@NotNull JetDeclaration dcl, Void data) {
-        visitDeclaration(dcl);
-        return null;
-    }
-
-    @Override
-    public final Void visitClass(@NotNull JetClass klass, Void data) {
-        visitClass(klass);
-        return null;
-    }
-
-    @Override
-    public final Void visitClassOrObject(@NotNull JetClassOrObject classOrObject, Void data) {
-        visitClassOrObject(classOrObject);
-        return null;
-    }
-
-    @Override
-    public final Void visitSecondaryConstructor(@NotNull JetSecondaryConstructor constructor, Void data) {
-        visitSecondaryConstructor(constructor);
-        return null;
-    }
-
-    @Override
-    public final Void visitPrimaryConstructor(@NotNull JetPrimaryConstructor constructor, Void data) {
-        visitPrimaryConstructor(constructor);
-        return null;
-    }
-
-    @Override
-    public final Void visitNamedFunction(@NotNull JetNamedFunction function, Void data) {
-        visitNamedFunction(function);
-        return null;
-    }
-
-    @Override
-    public final Void visitProperty(@NotNull JetProperty property, Void data) {
-        visitProperty(property);
-        return null;
-    }
-
-    @Override
-    public final Void visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration, Void data) {
-        visitMultiDeclaration(multiDeclaration);
-        return null;
-    }
-
-    @Override
-    public final Void visitMultiDeclarationEntry(@NotNull JetMultiDeclarationEntry multiDeclarationEntry, Void data) {
-        visitMultiDeclarationEntry(multiDeclarationEntry);
-        return null;
-    }
-
-    @Override
-    public final Void visitTypedef(@NotNull JetTypedef typedef, Void data) {
-        visitTypedef(typedef);
-        return null;
-    }
-
-    @Override
-    public final Void visitJetFile(@NotNull JetFile file, Void data) {
-        visitJetFile(file);
-        return null;
-    }
-
-    @Override
-    public final Void visitScript(@NotNull JetScript script, Void data) {
-        visitScript(script);
-        return null;
-    }
-
-    @Override
-    public final Void visitImportDirective(@NotNull JetImportDirective importDirective, Void data) {
-        visitImportDirective(importDirective);
-        return null;
-    }
-
-    @Override
-    public final Void visitImportList(@NotNull JetImportList importList, Void data) {
-        visitImportList(importList);
-        return null;
-    }
-
-    @Override
-    public final Void visitClassBody(@NotNull JetClassBody classBody, Void data) {
-        visitClassBody(classBody);
-        return null;
-    }
-
-    @Override
-    public final Void visitModifierList(@NotNull JetModifierList list, Void data) {
-        visitModifierList(list);
-        return null;
-    }
-
-    @Override
-    public final Void visitAnnotation(@NotNull JetAnnotation annotation, Void data) {
-        visitAnnotation(annotation);
-        return null;
-    }
-
-    @Override
-    public final Void visitAnnotationEntry(@NotNull JetAnnotationEntry annotationEntry, Void data) {
-        visitAnnotationEntry(annotationEntry);
-        return null;
-    }
-
-    @Override
-    public final Void visitConstructorCalleeExpression(@NotNull JetConstructorCalleeExpression constructorCalleeExpression, Void data) {
-        visitConstructorCalleeExpression(constructorCalleeExpression);
-        return null;
-    }
-
-    @Override
-    public final Void visitTypeParameterList(@NotNull JetTypeParameterList list, Void data) {
-        visitTypeParameterList(list);
-        return null;
-    }
-
-    @Override
-    public final Void visitTypeParameter(@NotNull JetTypeParameter parameter, Void data) {
-        visitTypeParameter(parameter);
-        return null;
-    }
-
-    @Override
-    public final Void visitEnumEntry(@NotNull JetEnumEntry enumEntry, Void data) {
-        visitEnumEntry(enumEntry);
-        return null;
-    }
-
-    @Override
-    public final Void visitParameterList(@NotNull JetParameterList list, Void data) {
-        visitParameterList(list);
-        return null;
-    }
-
-    @Override
-    public final Void visitParameter(@NotNull JetParameter parameter, Void data) {
-        visitParameter(parameter);
-        return null;
-    }
-
-    @Override
-    public final Void visitDelegationSpecifierList(@NotNull JetDelegationSpecifierList list, Void data) {
-        visitDelegationSpecifierList(list);
-        return null;
-    }
-
-    @Override
-    public final Void visitDelegationSpecifier(@NotNull JetDelegationSpecifier specifier, Void data) {
-        visitDelegationSpecifier(specifier);
-        return null;
-    }
-
-    @Override
-    public final Void visitDelegationByExpressionSpecifier(
-            @NotNull JetDelegatorByExpressionSpecifier specifier, Void data
-    ) {
-        visitDelegationByExpressionSpecifier(specifier);
-        return null;
-    }
-
-    @Override
-    public final Void visitDelegationToSuperCallSpecifier(@NotNull JetDelegatorToSuperCall call, Void data) {
-        visitDelegationToSuperCallSpecifier(call);
-        return null;
-    }
-
-    @Override
-    public final Void visitDelegationToSuperClassSpecifier(@NotNull JetDelegatorToSuperClass specifier, Void data) {
-        visitDelegationToSuperClassSpecifier(specifier);
-        return null;
-    }
-
-    @Override
-    public final Void visitConstructorDelegationCall(@NotNull JetConstructorDelegationCall call, Void data) {
-        visitConstructorDelegationCall(call);
-        return null;
-    }
-
-    @Override
-    public final Void visitPropertyDelegate(@NotNull JetPropertyDelegate delegate, Void data) {
-        visitPropertyDelegate(delegate);
-        return null;
-    }
-
-    @Override
-    public final Void visitTypeReference(@NotNull JetTypeReference typeReference, Void data) {
-        visitTypeReference(typeReference);
-        return null;
-    }
-
-    @Override
-    public final Void visitValueArgumentList(@NotNull JetValueArgumentList list, Void data) {
-        visitValueArgumentList(list);
-        return null;
-    }
-
-    @Override
-    public final Void visitArgument(@NotNull JetValueArgument argument, Void data) {
-        visitArgument(argument);
-        return null;
-    }
-
-    @Override
-    public final Void visitExpression(@NotNull JetExpression expression, Void data) {
-        visitExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitLoopExpression(@NotNull JetLoopExpression loopExpression, Void data) {
-        visitLoopExpression(loopExpression);
-        return null;
-    }
-
-    @Override
-    public final Void visitConstantExpression(@NotNull JetConstantExpression expression, Void data) {
-        visitConstantExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression, Void data) {
-        visitSimpleNameExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitReferenceExpression(@NotNull JetReferenceExpression expression, Void data) {
-        visitReferenceExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitLabeledExpression(@NotNull JetLabeledExpression expression, Void data) {
-        visitLabeledExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitPrefixExpression(@NotNull JetPrefixExpression expression, Void data) {
-        visitPrefixExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitPostfixExpression(@NotNull JetPostfixExpression expression, Void data) {
-        visitPostfixExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitUnaryExpression(@NotNull JetUnaryExpression expression, Void data) {
-        visitUnaryExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitBinaryExpression(@NotNull JetBinaryExpression expression, Void data) {
-        visitBinaryExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitReturnExpression(@NotNull JetReturnExpression expression, Void data) {
-        visitReturnExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitExpressionWithLabel(@NotNull JetExpressionWithLabel expression, Void data) {
-        visitExpressionWithLabel(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitThrowExpression(@NotNull JetThrowExpression expression, Void data) {
-        visitThrowExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitBreakExpression(@NotNull JetBreakExpression expression, Void data) {
-        visitBreakExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitContinueExpression(@NotNull JetContinueExpression expression, Void data) {
-        visitContinueExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitIfExpression(@NotNull JetIfExpression expression, Void data) {
-        visitIfExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitWhenExpression(@NotNull JetWhenExpression expression, Void data) {
-        visitWhenExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitTryExpression(@NotNull JetTryExpression expression, Void data) {
-        visitTryExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitForExpression(@NotNull JetForExpression expression, Void data) {
-        visitForExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitWhileExpression(@NotNull JetWhileExpression expression, Void data) {
-        visitWhileExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitDoWhileExpression(@NotNull JetDoWhileExpression expression, Void data) {
-        visitDoWhileExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitFunctionLiteralExpression(@NotNull JetFunctionLiteralExpression expression, Void data) {
-        visitFunctionLiteralExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitAnnotatedExpression(@NotNull JetAnnotatedExpression expression, Void data) {
-        visitAnnotatedExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitCallExpression(@NotNull JetCallExpression expression, Void data) {
-        visitCallExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitArrayAccessExpression(@NotNull JetArrayAccessExpression expression, Void data) {
-        visitArrayAccessExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitQualifiedExpression(@NotNull JetQualifiedExpression expression, Void data) {
-        visitQualifiedExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitDoubleColonExpression(@NotNull JetDoubleColonExpression expression, Void data) {
-        visitDoubleColonExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitCallableReferenceExpression(@NotNull JetCallableReferenceExpression expression, Void data) {
-        visitCallableReferenceExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitClassLiteralExpression(@NotNull JetClassLiteralExpression expression, Void data) {
-        visitClassLiteralExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitDotQualifiedExpression(@NotNull JetDotQualifiedExpression expression, Void data) {
-        visitDotQualifiedExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitSafeQualifiedExpression(@NotNull JetSafeQualifiedExpression expression, Void data) {
-        visitSafeQualifiedExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitObjectLiteralExpression(@NotNull JetObjectLiteralExpression expression, Void data) {
-        visitObjectLiteralExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitRootPackageExpression(@NotNull JetRootPackageExpression expression, Void data) {
-        visitRootPackageExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitBlockExpression(@NotNull JetBlockExpression expression, Void data) {
-        visitBlockExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitCatchSection(@NotNull JetCatchClause catchClause, Void data) {
-        visitCatchSection(catchClause);
-        return null;
-    }
-
-    @Override
-    public final Void visitFinallySection(@NotNull JetFinallySection finallySection, Void data) {
-        visitFinallySection(finallySection);
-        return null;
-    }
-
-    @Override
-    public final Void visitTypeArgumentList(@NotNull JetTypeArgumentList typeArgumentList, Void data) {
-        visitTypeArgumentList(typeArgumentList);
-        return null;
-    }
-
-    @Override
-    public final Void visitThisExpression(@NotNull JetThisExpression expression, Void data) {
-        visitThisExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitSuperExpression(@NotNull JetSuperExpression expression, Void data) {
-        visitSuperExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression, Void data) {
-        visitParenthesizedExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitInitializerList(@NotNull JetInitializerList list, Void data) {
-        visitInitializerList(list);
-        return null;
-    }
-
-    @Override
-    public final Void visitAnonymousInitializer(@NotNull JetClassInitializer initializer, Void data) {
-        visitAnonymousInitializer(initializer);
-        return null;
-    }
-
-    @Override
-    public final Void visitPropertyAccessor(@NotNull JetPropertyAccessor accessor, Void data) {
-        visitPropertyAccessor(accessor);
-        return null;
-    }
-
-    @Override
-    public final Void visitTypeConstraintList(@NotNull JetTypeConstraintList list, Void data) {
-        visitTypeConstraintList(list);
-        return null;
-    }
-
-    @Override
-    public final Void visitTypeConstraint(@NotNull JetTypeConstraint constraint, Void data) {
-        visitTypeConstraint(constraint);
-        return null;
-    }
-
-    @Override
-    public final Void visitUserType(@NotNull JetUserType type, Void data) {
-        visitUserType(type);
-        return null;
-    }
-
-    @Override
-    public Void visitDynamicType(@NotNull JetDynamicType type, Void data) {
-        visitDynamicType(type);
-        return null;
-    }
-
-    @Override
-    public final Void visitFunctionType(@NotNull JetFunctionType type, Void data) {
-        visitFunctionType(type);
-        return null;
-    }
-
-    @Override
-    public final Void visitSelfType(@NotNull JetSelfType type, Void data) {
-        visitSelfType(type);
-        return null;
-    }
-
-    @Override
-    public final Void visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS expression, Void data) {
-        visitBinaryWithTypeRHSExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitStringTemplateExpression(@NotNull JetStringTemplateExpression expression, Void data) {
-        visitStringTemplateExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitNamedDeclaration(@NotNull JetNamedDeclaration declaration, Void data) {
-        visitNamedDeclaration(declaration);
-        return null;
-    }
-
-    @Override
-    public final Void visitNullableType(@NotNull JetNullableType nullableType, Void data) {
-        visitNullableType(nullableType);
-        return null;
-    }
-
-    @Override
-    public final Void visitTypeProjection(@NotNull JetTypeProjection typeProjection, Void data) {
-        visitTypeProjection(typeProjection);
-        return null;
-    }
-
-    @Override
-    public final Void visitWhenEntry(@NotNull JetWhenEntry jetWhenEntry, Void data) {
-        visitWhenEntry(jetWhenEntry);
-        return null;
-    }
-
-    @Override
-    public final Void visitIsExpression(@NotNull JetIsExpression expression, Void data) {
-        visitIsExpression(expression);
-        return null;
-    }
-
-    @Override
-    public final Void visitWhenConditionIsPattern(@NotNull JetWhenConditionIsPattern condition, Void data) {
-        visitWhenConditionIsPattern(condition);
-        return null;
-    }
-
-    @Override
-    public final Void visitWhenConditionInRange(@NotNull JetWhenConditionInRange condition, Void data) {
-        visitWhenConditionInRange(condition);
-        return null;
-    }
-
-    @Override
-    public final Void visitWhenConditionWithExpression(@NotNull JetWhenConditionWithExpression condition, Void data) {
-        visitWhenConditionWithExpression(condition);
-        return null;
-    }
-
-    @Override
-    public final Void visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, Void data) {
-        visitObjectDeclaration(declaration);
-        return null;
-    }
-
-    @Override
-    public final Void visitObjectDeclarationName(@NotNull JetObjectDeclarationName declarationName, Void data) {
-        visitObjectDeclarationName(declarationName);
-        return null;
-    }
-
-    @Override
-    public final Void visitStringTemplateEntry(@NotNull JetStringTemplateEntry entry, Void data) {
-        visitStringTemplateEntry(entry);
-        return null;
-    }
-
-    @Override
-    public final Void visitStringTemplateEntryWithExpression(@NotNull JetStringTemplateEntryWithExpression entry, Void data) {
-        visitStringTemplateEntryWithExpression(entry);
-        return null;
-    }
-
-    @Override
-    public final Void visitBlockStringTemplateEntry(@NotNull JetBlockStringTemplateEntry entry, Void data) {
-        visitBlockStringTemplateEntry(entry);
-        return null;
-    }
-
-    @Override
-    public final Void visitSimpleNameStringTemplateEntry(@NotNull JetSimpleNameStringTemplateEntry entry, Void data) {
-        visitSimpleNameStringTemplateEntry(entry);
-        return null;
-    }
-
-    @Override
-    public final Void visitLiteralStringTemplateEntry(@NotNull JetLiteralStringTemplateEntry entry, Void data) {
-        visitLiteralStringTemplateEntry(entry);
-        return null;
-    }
-
-    @Override
-    public final Void visitEscapeStringTemplateEntry(@NotNull JetEscapeStringTemplateEntry entry, Void data) {
-        visitEscapeStringTemplateEntry(entry);
-        return null;
-    }
-
-    @Override
-    public Void visitPackageDirective(@NotNull JetPackageDirective directive, Void data) {
-        visitPackageDirective(directive);
-        return null;
-    }
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVisitorVoidWithParameter.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVisitorVoidWithParameter.java
deleted file mode 100644
index d0c02ed6d73..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVisitorVoidWithParameter.java
+++ /dev/null
@@ -1,1025 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.psi;
-
-import org.jetbrains.annotations.NotNull;
-
-public class JetVisitorVoidWithParameter<P> extends JetVisitor<Void, P> {
-
-    // methods with parameter
-
-    public void visitJetElementVoid(@NotNull JetElement element, P data) {
-        super.visitJetElement(element, data);
-    }
-
-    public void visitDeclarationVoid(@NotNull JetDeclaration dcl, P data) {
-        super.visitDeclaration(dcl, data);
-    }
-
-    public void visitClassVoid(@NotNull JetClass klass, P data) {
-        super.visitClass(klass, data);
-    }
-
-    public void visitSecondaryConstructorVoid(@NotNull JetSecondaryConstructor constructor, P data) {
-        super.visitSecondaryConstructor(constructor, data);
-    }
-
-    public void visitPrimaryConstructorVoid(@NotNull JetPrimaryConstructor constructor, P data) {
-        super.visitPrimaryConstructor(constructor, data);
-    }
-
-    public void visitNamedFunctionVoid(@NotNull JetNamedFunction function, P data) {
-        super.visitNamedFunction(function, data);
-    }
-
-    public void visitPropertyVoid(@NotNull JetProperty property, P data) {
-        super.visitProperty(property, data);
-    }
-
-    public void visitMultiDeclarationVoid(@NotNull JetMultiDeclaration multiDeclaration, P data) {
-        super.visitMultiDeclaration(multiDeclaration, data);
-    }
-
-    public void visitMultiDeclarationEntryVoid(@NotNull JetMultiDeclarationEntry multiDeclarationEntry, P data) {
-        super.visitMultiDeclarationEntry(multiDeclarationEntry, data);
-    }
-
-    public void visitTypedefVoid(@NotNull JetTypedef typedef, P data) {
-        super.visitTypedef(typedef, data);
-    }
-
-    public void visitJetFileVoid(@NotNull JetFile file, P data) {
-        super.visitJetFile(file, data);
-    }
-
-    public void visitScriptVoid(@NotNull JetScript script, P data) {
-        super.visitScript(script, data);
-    }
-
-    public void visitImportDirectiveVoid(@NotNull JetImportDirective importDirective, P data) {
-        super.visitImportDirective(importDirective, data);
-    }
-
-    public void visitImportListVoid(@NotNull JetImportList importList, P data) {
-        super.visitImportList(importList, data);
-    }
-
-    public void visitClassBodyVoid(@NotNull JetClassBody classBody, P data) {
-        super.visitClassBody(classBody, data);
-    }
-
-    public void visitModifierListVoid(@NotNull JetModifierList list, P data) {
-        super.visitModifierList(list, data);
-    }
-
-    public void visitAnnotationVoid(@NotNull JetAnnotation annotation, P data) {
-        super.visitAnnotation(annotation, data);
-    }
-
-    public void visitAnnotationEntryVoid(@NotNull JetAnnotationEntry annotationEntry, P data) {
-        super.visitAnnotationEntry(annotationEntry, data);
-    }
-
-    public void visitConstructorCalleeExpressionVoid(@NotNull JetConstructorCalleeExpression constructorCalleeExpression, P data) {
-        super.visitConstructorCalleeExpression(constructorCalleeExpression, data);
-    }
-
-    public void visitTypeParameterListVoid(@NotNull JetTypeParameterList list, P data) {
-        super.visitTypeParameterList(list, data);
-    }
-
-    public void visitTypeParameterVoid(@NotNull JetTypeParameter parameter, P data) {
-        super.visitTypeParameter(parameter, data);
-    }
-
-    public void visitEnumEntryVoid(@NotNull JetEnumEntry enumEntry, P data) {
-        super.visitEnumEntry(enumEntry, data);
-    }
-
-    public void visitParameterListVoid(@NotNull JetParameterList list, P data) {
-        super.visitParameterList(list, data);
-    }
-
-    public void visitParameterVoid(@NotNull JetParameter parameter, P data) {
-        super.visitParameter(parameter, data);
-    }
-
-    public void visitDelegationSpecifierListVoid(@NotNull JetDelegationSpecifierList list, P data) {
-        super.visitDelegationSpecifierList(list, data);
-    }
-
-    public void visitDelegationSpecifierVoid(@NotNull JetDelegationSpecifier specifier, P data) {
-        super.visitDelegationSpecifier(specifier, data);
-    }
-
-    public void visitDelegationByExpressionSpecifierVoid(@NotNull JetDelegatorByExpressionSpecifier specifier, P data) {
-        super.visitDelegationByExpressionSpecifier(specifier, data);
-    }
-
-    public void visitDelegationToSuperCallSpecifierVoid(@NotNull JetDelegatorToSuperCall call, P data) {
-        super.visitDelegationToSuperCallSpecifier(call, data);
-    }
-
-    public void visitDelegationToSuperClassSpecifierVoid(@NotNull JetDelegatorToSuperClass specifier, P data) {
-        super.visitDelegationToSuperClassSpecifier(specifier, data);
-    }
-
-    public void visitDelegationCallVoid(@NotNull JetConstructorDelegationCall call, P data) {
-        super.visitConstructorDelegationCall(call, data);
-    }
-
-    public void visitPropertyDelegateVoid(@NotNull JetPropertyDelegate delegate, P data) {
-        super.visitPropertyDelegate(delegate, data);
-    }
-
-    public void visitTypeReferenceVoid(@NotNull JetTypeReference typeReference, P data) {
-        super.visitTypeReference(typeReference, data);
-    }
-
-    public void visitValueArgumentListVoid(@NotNull JetValueArgumentList list, P data) {
-        super.visitValueArgumentList(list, data);
-    }
-
-    public void visitArgumentVoid(@NotNull JetValueArgument argument, P data) {
-        super.visitArgument(argument, data);
-    }
-
-    public void visitExpressionVoid(@NotNull JetExpression expression, P data) {
-        super.visitExpression(expression, data);
-    }
-
-    public void visitLoopExpressionVoid(@NotNull JetLoopExpression loopExpression, P data) {
-        super.visitLoopExpression(loopExpression, data);
-    }
-
-    public void visitConstantExpressionVoid(@NotNull JetConstantExpression expression, P data) {
-        super.visitConstantExpression(expression, data);
-    }
-
-    public void visitSimpleNameExpressionVoid(@NotNull JetSimpleNameExpression expression, P data) {
-        super.visitSimpleNameExpression(expression, data);
-    }
-
-    public void visitReferenceExpressionVoid(@NotNull JetReferenceExpression expression, P data) {
-        super.visitReferenceExpression(expression, data);
-    }
-
-    public void visitLabeledExpressionVoid(@NotNull JetLabeledExpression expression, P data) {
-        super.visitLabeledExpression(expression, data);
-    }
-
-    public void visitPrefixExpressionVoid(@NotNull JetPrefixExpression expression, P data) {
-        super.visitPrefixExpression(expression, data);
-    }
-
-    public void visitPostfixExpressionVoid(@NotNull JetPostfixExpression expression, P data) {
-        super.visitPostfixExpression(expression, data);
-    }
-
-    public void visitUnaryExpressionVoid(@NotNull JetUnaryExpression expression, P data) {
-        super.visitUnaryExpression(expression, data);
-    }
-
-    public void visitBinaryExpressionVoid(@NotNull JetBinaryExpression expression, P data) {
-        super.visitBinaryExpression(expression, data);
-    }
-
-    public void visitReturnExpressionVoid(@NotNull JetReturnExpression expression, P data) {
-        super.visitReturnExpression(expression, data);
-    }
-
-    public void visitExpressionWithLabelVoid(@NotNull JetExpressionWithLabel expression, P data) {
-        super.visitExpressionWithLabel(expression, data);
-    }
-
-    public void visitThrowExpressionVoid(@NotNull JetThrowExpression expression, P data) {
-        super.visitThrowExpression(expression, data);
-    }
-
-    public void visitBreakExpressionVoid(@NotNull JetBreakExpression expression, P data) {
-        super.visitBreakExpression(expression, data);
-    }
-
-    public void visitContinueExpressionVoid(@NotNull JetContinueExpression expression, P data) {
-        super.visitContinueExpression(expression, data);
-    }
-
-    public void visitIfExpressionVoid(@NotNull JetIfExpression expression, P data) {
-        super.visitIfExpression(expression, data);
-    }
-
-    public void visitWhenExpressionVoid(@NotNull JetWhenExpression expression, P data) {
-        super.visitWhenExpression(expression, data);
-    }
-
-    public void visitTryExpressionVoid(@NotNull JetTryExpression expression, P data) {
-        super.visitTryExpression(expression, data);
-    }
-
-    public void visitForExpressionVoid(@NotNull JetForExpression expression, P data) {
-        super.visitForExpression(expression, data);
-    }
-
-    public void visitWhileExpressionVoid(@NotNull JetWhileExpression expression, P data) {
-        super.visitWhileExpression(expression, data);
-    }
-
-    public void visitDoWhileExpressionVoid(@NotNull JetDoWhileExpression expression, P data) {
-        super.visitDoWhileExpression(expression, data);
-    }
-
-    public void visitFunctionLiteralExpressionVoid(@NotNull JetFunctionLiteralExpression expression, P data) {
-        super.visitFunctionLiteralExpression(expression, data);
-    }
-
-    public void visitAnnotatedExpressionVoid(@NotNull JetAnnotatedExpression expression, P data) {
-        super.visitAnnotatedExpression(expression, data);
-    }
-
-    public void visitCallExpressionVoid(@NotNull JetCallExpression expression, P data) {
-        super.visitCallExpression(expression, data);
-    }
-
-    public void visitArrayAccessExpressionVoid(@NotNull JetArrayAccessExpression expression, P data) {
-        super.visitArrayAccessExpression(expression, data);
-    }
-
-    public void visitQualifiedExpressionVoid(@NotNull JetQualifiedExpression expression, P data) {
-        super.visitQualifiedExpression(expression, data);
-    }
-
-    public void visitDoubleColonExpressionVoid(@NotNull JetDoubleColonExpression expression, P data) {
-        super.visitDoubleColonExpression(expression, data);
-    }
-
-    public void visitCallableReferenceExpressionVoid(@NotNull JetCallableReferenceExpression expression, P data) {
-        super.visitCallableReferenceExpression(expression, data);
-    }
-
-    public void visitClassLiteralExpressionVoid(@NotNull JetClassLiteralExpression expression, P data) {
-        super.visitClassLiteralExpression(expression, data);
-    }
-
-    public void visitDotQualifiedExpressionVoid(@NotNull JetDotQualifiedExpression expression, P data) {
-        super.visitDotQualifiedExpression(expression, data);
-    }
-
-    public void visitSafeQualifiedExpressionVoid(@NotNull JetSafeQualifiedExpression expression, P data) {
-        super.visitSafeQualifiedExpression(expression, data);
-    }
-
-    public void visitObjectLiteralExpressionVoid(@NotNull JetObjectLiteralExpression expression, P data) {
-        super.visitObjectLiteralExpression(expression, data);
-    }
-
-    public void visitRootPackageExpressionVoid(@NotNull JetRootPackageExpression expression, P data) {
-        super.visitRootPackageExpression(expression, data);
-    }
-
-    public void visitBlockExpressionVoid(@NotNull JetBlockExpression expression, P data) {
-        super.visitBlockExpression(expression, data);
-    }
-
-    public void visitCatchSectionVoid(@NotNull JetCatchClause catchClause, P data) {
-        super.visitCatchSection(catchClause, data);
-    }
-
-    public void visitFinallySectionVoid(@NotNull JetFinallySection finallySection, P data) {
-        super.visitFinallySection(finallySection, data);
-    }
-
-    public void visitTypeArgumentListVoid(@NotNull JetTypeArgumentList typeArgumentList, P data) {
-        super.visitTypeArgumentList(typeArgumentList, data);
-    }
-
-    public void visitThisExpressionVoid(@NotNull JetThisExpression expression, P data) {
-        super.visitThisExpression(expression, data);
-    }
-
-    public void visitSuperExpressionVoid(@NotNull JetSuperExpression expression, P data) {
-        super.visitSuperExpression(expression, data);
-    }
-
-    public void visitParenthesizedExpressionVoid(@NotNull JetParenthesizedExpression expression, P data) {
-        super.visitParenthesizedExpression(expression, data);
-    }
-
-    public void visitInitializerListVoid(@NotNull JetInitializerList list, P data) {
-        super.visitInitializerList(list, data);
-    }
-
-    public void visitAnonymousInitializerVoid(@NotNull JetClassInitializer initializer, P data) {
-        super.visitAnonymousInitializer(initializer, data);
-    }
-
-    public void visitPropertyAccessorVoid(@NotNull JetPropertyAccessor accessor, P data) {
-        super.visitPropertyAccessor(accessor, data);
-    }
-
-    public void visitTypeConstraintListVoid(@NotNull JetTypeConstraintList list, P data) {
-        super.visitTypeConstraintList(list, data);
-    }
-
-    public void visitTypeConstraintVoid(@NotNull JetTypeConstraint constraint, P data) {
-        super.visitTypeConstraint(constraint, data);
-    }
-
-    public void visitUserTypeVoid(@NotNull JetUserType type, P data) {
-        super.visitUserType(type, data);
-    }
-
-    public void visitDynamicTypeVoid(@NotNull JetDynamicType type, P data) {
-        super.visitDynamicType(type, data);
-    }
-
-    public void visitFunctionTypeVoid(@NotNull JetFunctionType type, P data) {
-        super.visitFunctionType(type, data);
-    }
-
-    public void visitSelfTypeVoid(@NotNull JetSelfType type, P data) {
-        super.visitSelfType(type, data);
-    }
-
-    public void visitBinaryWithTypeRHSExpressionVoid(@NotNull JetBinaryExpressionWithTypeRHS expression, P data) {
-        super.visitBinaryWithTypeRHSExpression(expression, data);
-    }
-
-    public void visitStringTemplateExpressionVoid(@NotNull JetStringTemplateExpression expression, P data) {
-        super.visitStringTemplateExpression(expression, data);
-    }
-
-    public void visitNamedDeclarationVoid(@NotNull JetNamedDeclaration declaration, P data) {
-        super.visitNamedDeclaration(declaration, data);
-    }
-
-    public void visitNullableTypeVoid(@NotNull JetNullableType nullableType, P data) {
-        super.visitNullableType(nullableType, data);
-    }
-
-    public void visitTypeProjectionVoid(@NotNull JetTypeProjection typeProjection, P data) {
-        super.visitTypeProjection(typeProjection, data);
-    }
-
-    public void visitWhenEntryVoid(@NotNull JetWhenEntry jetWhenEntry, P data) {
-        super.visitWhenEntry(jetWhenEntry, data);
-    }
-
-    public void visitIsExpressionVoid(@NotNull JetIsExpression expression, P data) {
-        super.visitIsExpression(expression, data);
-    }
-
-    public void visitWhenConditionIsPatternVoid(@NotNull JetWhenConditionIsPattern condition, P data) {
-        super.visitWhenConditionIsPattern(condition, data);
-    }
-
-    public void visitWhenConditionInRangeVoid(@NotNull JetWhenConditionInRange condition, P data) {
-        super.visitWhenConditionInRange(condition, data);
-    }
-
-    public void visitWhenConditionWithExpressionVoid(@NotNull JetWhenConditionWithExpression condition, P data) {
-        super.visitWhenConditionWithExpression(condition, data);
-    }
-
-    public void visitObjectDeclarationVoid(@NotNull JetObjectDeclaration declaration, P data) {
-        super.visitObjectDeclaration(declaration, data);
-    }
-
-    public void visitObjectDeclarationNameVoid(@NotNull JetObjectDeclarationName declarationName, P data) {
-        super.visitObjectDeclarationName(declarationName, data);
-    }
-
-    public void visitStringTemplateEntryVoid(@NotNull JetStringTemplateEntry entry, P data) {
-        super.visitStringTemplateEntry(entry, data);
-    }
-
-    public void visitStringTemplateEntryWithExpressionVoid(@NotNull JetStringTemplateEntryWithExpression entry, P data) {
-        super.visitStringTemplateEntryWithExpression(entry, data);
-    }
-
-    public void visitBlockStringTemplateEntryVoid(@NotNull JetBlockStringTemplateEntry entry, P data) {
-        super.visitBlockStringTemplateEntry(entry, data);
-    }
-
-    public void visitSimpleNameStringTemplateEntryVoid(@NotNull JetSimpleNameStringTemplateEntry entry, P data) {
-        super.visitSimpleNameStringTemplateEntry(entry, data);
-    }
-
-    public void visitLiteralStringTemplateEntryVoid(@NotNull JetLiteralStringTemplateEntry entry, P data) {
-        super.visitLiteralStringTemplateEntry(entry, data);
-    }
-
-    public void visitEscapeStringTemplateEntryVoid(@NotNull JetEscapeStringTemplateEntry entry, P data) {
-        super.visitEscapeStringTemplateEntry(entry, data);
-    }
-
-    // hidden methods
-    @Override
-    public final Void visitJetElement(@NotNull JetElement element, P data) {
-        visitJetElementVoid(element, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitDeclaration(@NotNull JetDeclaration dcl, P data) {
-        visitDeclarationVoid(dcl, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitClass(@NotNull JetClass klass, P data) {
-        visitClassVoid(klass, data);
-    	return null;
-    }
-
-    @Override
-    public Void visitPrimaryConstructor(@NotNull JetPrimaryConstructor constructor, P data) {
-        visitPrimaryConstructorVoid(constructor, data);
-        return null;
-    }
-
-    @Override
-    public final Void visitNamedFunction(@NotNull JetNamedFunction function, P data) {
-        visitNamedFunctionVoid(function, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitProperty(@NotNull JetProperty property, P data) {
-        visitPropertyVoid(property, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration, P data) {
-        visitMultiDeclarationVoid(multiDeclaration, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitMultiDeclarationEntry(@NotNull JetMultiDeclarationEntry multiDeclarationEntry, P data) {
-        visitMultiDeclarationEntryVoid(multiDeclarationEntry, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitTypedef(@NotNull JetTypedef typedef, P data) {
-        visitTypedefVoid(typedef, data);
-        return null;
-    }
-
-    @Override
-    public final Void visitJetFile(@NotNull JetFile file, P data) {
-        visitJetFileVoid(file, data);
-        return null;
-    }
-
-    @Override
-    public final Void visitScript(@NotNull JetScript script, P data) {
-        visitScriptVoid(script, data);
-        return null;
-    }
-
-    @Override
-    public final Void visitImportDirective(@NotNull JetImportDirective importDirective, P data) {
-        visitImportDirectiveVoid(importDirective, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitImportList(@NotNull JetImportList importList, P data) {
-        visitImportListVoid(importList, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitClassBody(@NotNull JetClassBody classBody, P data) {
-        visitClassBodyVoid(classBody, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitModifierList(@NotNull JetModifierList list, P data) {
-        visitModifierListVoid(list, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitAnnotation(@NotNull JetAnnotation annotation, P data) {
-        visitAnnotationVoid(annotation, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitAnnotationEntry(@NotNull JetAnnotationEntry annotationEntry, P data) {
-        visitAnnotationEntryVoid(annotationEntry, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitTypeParameterList(@NotNull JetTypeParameterList list, P data) {
-        visitTypeParameterListVoid(list, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitTypeParameter(@NotNull JetTypeParameter parameter, P data) {
-        visitTypeParameterVoid(parameter, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitEnumEntry(@NotNull JetEnumEntry enumEntry, P data) {
-        visitEnumEntryVoid(enumEntry, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitParameterList(@NotNull JetParameterList list, P data) {
-        visitParameterListVoid(list, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitParameter(@NotNull JetParameter parameter, P data) {
-        visitParameterVoid(parameter, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitDelegationSpecifierList(@NotNull JetDelegationSpecifierList list, P data) {
-        visitDelegationSpecifierListVoid(list, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitDelegationSpecifier(@NotNull JetDelegationSpecifier specifier, P data) {
-        visitDelegationSpecifierVoid(specifier, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitDelegationByExpressionSpecifier(
-            @NotNull JetDelegatorByExpressionSpecifier specifier, P data
-    ) {
-        visitDelegationByExpressionSpecifierVoid(specifier, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitDelegationToSuperCallSpecifier(@NotNull JetDelegatorToSuperCall call, P data) {
-        visitDelegationToSuperCallSpecifierVoid(call, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitDelegationToSuperClassSpecifier(@NotNull JetDelegatorToSuperClass specifier, P data) {
-        visitDelegationToSuperClassSpecifierVoid(specifier, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitConstructorDelegationCall(@NotNull JetConstructorDelegationCall call, P data) {
-        visitDelegationCallVoid(call, data);
-        return null;
-    }
-
-    @Override
-    public final Void visitPropertyDelegate(@NotNull JetPropertyDelegate delegate, P data) {
-        visitPropertyDelegateVoid(delegate, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitTypeReference(@NotNull JetTypeReference typeReference, P data) {
-        visitTypeReferenceVoid(typeReference, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitValueArgumentList(@NotNull JetValueArgumentList list, P data) {
-        visitValueArgumentListVoid(list, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitArgument(@NotNull JetValueArgument argument, P data) {
-        visitArgumentVoid(argument, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitExpression(@NotNull JetExpression expression, P data) {
-        visitExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitLoopExpression(@NotNull JetLoopExpression loopExpression, P data) {
-        visitLoopExpressionVoid(loopExpression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitConstantExpression(@NotNull JetConstantExpression expression, P data) {
-        visitConstantExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression, P data) {
-        visitSimpleNameExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitReferenceExpression(@NotNull JetReferenceExpression expression, P data) {
-        visitReferenceExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitLabeledExpression(@NotNull JetLabeledExpression expression, P data) {
-        visitLabeledExpressionVoid(expression, data);
-        return null;
-    }
-
-    @Override
-    public final Void visitPrefixExpression(@NotNull JetPrefixExpression expression, P data) {
-        visitPrefixExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitPostfixExpression(@NotNull JetPostfixExpression expression, P data) {
-        visitPostfixExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitUnaryExpression(@NotNull JetUnaryExpression expression, P data) {
-        visitUnaryExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitBinaryExpression(@NotNull JetBinaryExpression expression, P data) {
-        visitBinaryExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitReturnExpression(@NotNull JetReturnExpression expression, P data) {
-        visitReturnExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitExpressionWithLabel(@NotNull JetExpressionWithLabel expression, P data) {
-        visitExpressionWithLabelVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitThrowExpression(@NotNull JetThrowExpression expression, P data) {
-        visitThrowExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitBreakExpression(@NotNull JetBreakExpression expression, P data) {
-        visitBreakExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitContinueExpression(@NotNull JetContinueExpression expression, P data) {
-        visitContinueExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitIfExpression(@NotNull JetIfExpression expression, P data) {
-        visitIfExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitWhenExpression(@NotNull JetWhenExpression expression, P data) {
-        visitWhenExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitTryExpression(@NotNull JetTryExpression expression, P data) {
-        visitTryExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitForExpression(@NotNull JetForExpression expression, P data) {
-        visitForExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitWhileExpression(@NotNull JetWhileExpression expression, P data) {
-        visitWhileExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitDoWhileExpression(@NotNull JetDoWhileExpression expression, P data) {
-        visitDoWhileExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitFunctionLiteralExpression(@NotNull JetFunctionLiteralExpression expression, P data) {
-        visitFunctionLiteralExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitAnnotatedExpression(@NotNull JetAnnotatedExpression expression, P data) {
-        visitAnnotatedExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitCallExpression(@NotNull JetCallExpression expression, P data) {
-        visitCallExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitArrayAccessExpression(@NotNull JetArrayAccessExpression expression, P data) {
-        visitArrayAccessExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitQualifiedExpression(@NotNull JetQualifiedExpression expression, P data) {
-        visitQualifiedExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitDoubleColonExpression(@NotNull JetDoubleColonExpression expression, P data) {
-        visitDoubleColonExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitCallableReferenceExpression(@NotNull JetCallableReferenceExpression expression, P data) {
-        visitCallableReferenceExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitClassLiteralExpression(@NotNull JetClassLiteralExpression expression, P data) {
-        visitClassLiteralExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitDotQualifiedExpression(@NotNull JetDotQualifiedExpression expression, P data) {
-        visitDotQualifiedExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitSafeQualifiedExpression(@NotNull JetSafeQualifiedExpression expression, P data) {
-        visitSafeQualifiedExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitObjectLiteralExpression(@NotNull JetObjectLiteralExpression expression, P data) {
-        visitObjectLiteralExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitRootPackageExpression(@NotNull JetRootPackageExpression expression, P data) {
-        visitRootPackageExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitBlockExpression(@NotNull JetBlockExpression expression, P data) {
-        visitBlockExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitCatchSection(@NotNull JetCatchClause catchClause, P data) {
-        visitCatchSectionVoid(catchClause, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitFinallySection(@NotNull JetFinallySection finallySection, P data) {
-        visitFinallySectionVoid(finallySection, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitTypeArgumentList(@NotNull JetTypeArgumentList typeArgumentList, P data) {
-        visitTypeArgumentListVoid(typeArgumentList, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitThisExpression(@NotNull JetThisExpression expression, P data) {
-        visitThisExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitSuperExpression(@NotNull JetSuperExpression expression, P data) {
-        visitSuperExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression, P data) {
-        visitParenthesizedExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitInitializerList(@NotNull JetInitializerList list, P data) {
-        visitInitializerListVoid(list, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitAnonymousInitializer(@NotNull JetClassInitializer initializer, P data) {
-        visitAnonymousInitializerVoid(initializer, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitPropertyAccessor(@NotNull JetPropertyAccessor accessor, P data) {
-        visitPropertyAccessorVoid(accessor, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitTypeConstraintList(@NotNull JetTypeConstraintList list, P data) {
-        visitTypeConstraintListVoid(list, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitTypeConstraint(@NotNull JetTypeConstraint constraint, P data) {
-        visitTypeConstraintVoid(constraint, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitUserType(@NotNull JetUserType type, P data) {
-        visitUserTypeVoid(type, data);
-    	return null;
-    }
-
-    @Override
-    public Void visitDynamicType(@NotNull JetDynamicType type, P data) {
-        visitDynamicTypeVoid(type, data);
-        return null;
-    }
-
-    @Override
-    public final Void visitFunctionType(@NotNull JetFunctionType type, P data) {
-        visitFunctionTypeVoid(type, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitSelfType(@NotNull JetSelfType type, P data) {
-        visitSelfTypeVoid(type, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS expression, P data) {
-        visitBinaryWithTypeRHSExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitStringTemplateExpression(@NotNull JetStringTemplateExpression expression, P data) {
-        visitStringTemplateExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitNamedDeclaration(@NotNull JetNamedDeclaration declaration, P data) {
-        visitNamedDeclarationVoid(declaration, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitNullableType(@NotNull JetNullableType nullableType, P data) {
-        visitNullableTypeVoid(nullableType, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitTypeProjection(@NotNull JetTypeProjection typeProjection, P data) {
-        visitTypeProjectionVoid(typeProjection, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitWhenEntry(@NotNull JetWhenEntry jetWhenEntry, P data) {
-        visitWhenEntryVoid(jetWhenEntry, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitIsExpression(@NotNull JetIsExpression expression, P data) {
-        visitIsExpressionVoid(expression, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitWhenConditionIsPattern(@NotNull JetWhenConditionIsPattern condition, P data) {
-        visitWhenConditionIsPatternVoid(condition, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitWhenConditionInRange(@NotNull JetWhenConditionInRange condition, P data) {
-        visitWhenConditionInRangeVoid(condition, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitWhenConditionWithExpression(@NotNull JetWhenConditionWithExpression condition, P data) {
-        visitWhenConditionWithExpressionVoid(condition, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, P data) {
-        visitObjectDeclarationVoid(declaration, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitObjectDeclarationName(@NotNull JetObjectDeclarationName declarationName, P data) {
-        visitObjectDeclarationNameVoid(declarationName, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitStringTemplateEntry(@NotNull JetStringTemplateEntry entry, P data) {
-        visitStringTemplateEntryVoid(entry, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitStringTemplateEntryWithExpression(@NotNull JetStringTemplateEntryWithExpression entry, P data) {
-        visitStringTemplateEntryWithExpressionVoid(entry, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitBlockStringTemplateEntry(@NotNull JetBlockStringTemplateEntry entry, P data) {
-        visitBlockStringTemplateEntryVoid(entry, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitSimpleNameStringTemplateEntry(@NotNull JetSimpleNameStringTemplateEntry entry, P data) {
-        visitSimpleNameStringTemplateEntryVoid(entry, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitLiteralStringTemplateEntry(@NotNull JetLiteralStringTemplateEntry entry, P data) {
-        visitLiteralStringTemplateEntryVoid(entry, data);
-    	return null;
-    }
-
-    @Override
-    public final Void visitEscapeStringTemplateEntry(@NotNull JetEscapeStringTemplateEntry entry, P data) {
-        visitEscapeStringTemplateEntryVoid(entry, data);
-        return null;
-    }
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinDeclarationNavigationPolicy.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinDeclarationNavigationPolicy.kt
index 420f96361a2..6662ff1507a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinDeclarationNavigationPolicy.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinDeclarationNavigationPolicy.kt
@@ -17,6 +17,6 @@
 package org.jetbrains.kotlin.psi
 
 public interface KotlinDeclarationNavigationPolicy {
-    public fun getOriginalElement(declaration: JetDeclaration): JetElement
-    public fun getNavigationElement(declaration: JetDeclaration): JetElement
+    public fun getOriginalElement(declaration: KtDeclaration): KtElement
+    public fun getNavigationElement(declaration: KtDeclaration): KtElement
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinStringLiteralTextEscaper.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinStringLiteralTextEscaper.kt
index f09ed7306b4..b3a0d09cdf7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinStringLiteralTextEscaper.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinStringLiteralTextEscaper.kt
@@ -22,7 +22,7 @@ import gnu.trove.TIntArrayList
 import org.jetbrains.kotlin.psi.psiUtil.getContentRange
 import org.jetbrains.kotlin.psi.psiUtil.isSingleQuoted
 
-public class KotlinStringLiteralTextEscaper(host: JetStringTemplateExpression): LiteralTextEscaper<JetStringTemplateExpression>(host) {
+public class KotlinStringLiteralTextEscaper(host: KtStringTemplateExpression): LiteralTextEscaper<KtStringTemplateExpression>(host) {
     private var sourceOffsets: IntArray? = null
 
     override fun decode(rangeInsideHost: TextRange, outChars: StringBuilder): Boolean {
@@ -38,14 +38,14 @@ public class KotlinStringLiteralTextEscaper(host: JetStringTemplateExpression):
                 continue
             }
             when (child) {
-                is JetLiteralStringTemplateEntry -> {
+                is KtLiteralStringTemplateEntry -> {
                     val textRange = rangeInsideHost.intersection(childRange)!!.shiftRight(-childRange.getStartOffset())
                     outChars.append(child.getText(), textRange.getStartOffset(), textRange.getEndOffset())
                     repeat(textRange.length) {
                         sourceOffsetsList.add(sourceOffset++)
                     }
                 }
-                is JetEscapeStringTemplateEntry -> {
+                is KtEscapeStringTemplateEntry -> {
                     if (!rangeInsideHost.contains(childRange)) {
                         //don't allow injection if its range starts or ends inside escaped sequence
                         return false
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotated.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotated.java
similarity index 83%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotated.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotated.java
index b23a6b17022..eb72207c710 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotated.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotated.java
@@ -20,10 +20,10 @@ import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 
-public interface JetAnnotated extends JetElement {
+public interface KtAnnotated extends KtElement {
     @NotNull
-    List<JetAnnotation> getAnnotations();
+    List<KtAnnotation> getAnnotations();
 
     @NotNull
-    List<JetAnnotationEntry> getAnnotationEntries();
+    List<KtAnnotationEntry> getAnnotationEntries();
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotatedExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotatedExpression.java
similarity index 66%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotatedExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotatedExpression.java
index 27ef7d15bd2..dea9213c860 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotatedExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotatedExpression.java
@@ -19,35 +19,35 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 import org.jetbrains.kotlin.psi.psiUtil.JetPsiUtilKt;
 
 import java.util.List;
 
-public class JetAnnotatedExpression extends JetExpressionImpl implements JetAnnotated, JetAnnotationsContainer {
-    public JetAnnotatedExpression(@NotNull ASTNode node) {
+public class KtAnnotatedExpression extends KtExpressionImpl implements KtAnnotated, KtAnnotationsContainer {
+    public KtAnnotatedExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitAnnotatedExpression(this, data);
     }
 
     @Nullable
-    public JetExpression getBaseExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getBaseExpression() {
+        return findChildByClass(KtExpression.class);
     }
 
     @Override
     @NotNull
-    public List<JetAnnotation> getAnnotations() {
-        return findChildrenByType(JetNodeTypes.ANNOTATION);
+    public List<KtAnnotation> getAnnotations() {
+        return findChildrenByType(KtNodeTypes.ANNOTATION);
     }
 
     @Override
     @NotNull
-    public List<JetAnnotationEntry> getAnnotationEntries() {
+    public List<KtAnnotationEntry> getAnnotationEntries() {
         return JetPsiUtilKt.collectAnnotationEntriesFromStubOrPsi(this);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotation.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotation.java
similarity index 60%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotation.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotation.java
index 79750722ffa..9be742c6cc1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotation.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotation.java
@@ -20,35 +20,35 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.List;
 
-public class JetAnnotation extends JetElementImplStub<KotlinPlaceHolderStub<JetAnnotation>> {
+public class KtAnnotation extends KtElementImplStub<KotlinPlaceHolderStub<KtAnnotation>> {
 
-    public JetAnnotation(@NotNull ASTNode node) {
+    public KtAnnotation(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetAnnotation(KotlinPlaceHolderStub<JetAnnotation> stub) {
-        super(stub, JetStubElementTypes.ANNOTATION);
+    public KtAnnotation(KotlinPlaceHolderStub<KtAnnotation> stub) {
+        super(stub, KtStubElementTypes.ANNOTATION);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitAnnotation(this, data);
     }
 
-    public List<JetAnnotationEntry> getEntries() {
-        return getStubOrPsiChildrenAsList(JetStubElementTypes.ANNOTATION_ENTRY);
+    public List<KtAnnotationEntry> getEntries() {
+        return getStubOrPsiChildrenAsList(KtStubElementTypes.ANNOTATION_ENTRY);
     }
 
     @Nullable
-    public JetAnnotationUseSiteTarget getUseSiteTarget() {
-        return getStubOrPsiChild(JetStubElementTypes.ANNOTATION_TARGET);
+    public KtAnnotationUseSiteTarget getUseSiteTarget() {
+        return getStubOrPsiChild(KtStubElementTypes.ANNOTATION_TARGET);
     }
 
-    public void removeEntry(@NotNull JetAnnotationEntry entry) {
+    public void removeEntry(@NotNull KtAnnotationEntry entry) {
         if (getEntries().size() > 1) {
             entry.delete();
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotationEntry.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotationEntry.java
similarity index 54%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotationEntry.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotationEntry.java
index 3397be9c182..330b32cb311 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotationEntry.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotationEntry.java
@@ -20,32 +20,32 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.stubs.KotlinAnnotationEntryStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetAnnotationEntry extends JetElementImplStub<KotlinAnnotationEntryStub> implements JetCallElement {
-    public JetAnnotationEntry(@NotNull ASTNode node) {
+public class KtAnnotationEntry extends KtElementImplStub<KotlinAnnotationEntryStub> implements KtCallElement {
+    public KtAnnotationEntry(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetAnnotationEntry(@NotNull KotlinAnnotationEntryStub stub) {
-        super(stub, JetStubElementTypes.ANNOTATION_ENTRY);
+    public KtAnnotationEntry(@NotNull KotlinAnnotationEntryStub stub) {
+        super(stub, KtStubElementTypes.ANNOTATION_ENTRY);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitAnnotationEntry(this, data);
     }
 
 
     @Nullable @IfNotParsed
-    public JetTypeReference getTypeReference() {
-        JetConstructorCalleeExpression calleeExpression = getCalleeExpression();
+    public KtTypeReference getTypeReference() {
+        KtConstructorCalleeExpression calleeExpression = getCalleeExpression();
         if (calleeExpression == null) {
             return null;
         }
@@ -53,36 +53,36 @@ public class JetAnnotationEntry extends JetElementImplStub<KotlinAnnotationEntry
     }
 
     @Override
-    public JetConstructorCalleeExpression getCalleeExpression() {
-        return getStubOrPsiChild(JetStubElementTypes.CONSTRUCTOR_CALLEE);
+    public KtConstructorCalleeExpression getCalleeExpression() {
+        return getStubOrPsiChild(KtStubElementTypes.CONSTRUCTOR_CALLEE);
     }
 
     @Override
-    public JetValueArgumentList getValueArgumentList() {
+    public KtValueArgumentList getValueArgumentList() {
         KotlinAnnotationEntryStub stub = getStub();
         if (stub != null && !stub.hasValueArguments()) {
             return null;
         }
-        return (JetValueArgumentList) findChildByType(JetNodeTypes.VALUE_ARGUMENT_LIST);
+        return (KtValueArgumentList) findChildByType(KtNodeTypes.VALUE_ARGUMENT_LIST);
     }
 
     @NotNull
     @Override
     public List<? extends ValueArgument> getValueArguments() {
-        JetValueArgumentList list = getValueArgumentList();
-        return list != null ? list.getArguments() : Collections.<JetValueArgument>emptyList();
+        KtValueArgumentList list = getValueArgumentList();
+        return list != null ? list.getArguments() : Collections.<KtValueArgument>emptyList();
     }
 
     @NotNull
     @Override
-    public List<JetFunctionLiteralArgument> getFunctionLiteralArguments() {
+    public List<KtFunctionLiteralArgument> getFunctionLiteralArguments() {
         return Collections.emptyList();
     }
 
     @NotNull
     @Override
-    public List<JetTypeProjection> getTypeArguments() {
-        JetTypeArgumentList typeArgumentList = getTypeArgumentList();
+    public List<KtTypeProjection> getTypeArguments() {
+        KtTypeArgumentList typeArgumentList = getTypeArgumentList();
         if (typeArgumentList == null) {
             return Collections.emptyList();
         }
@@ -90,14 +90,14 @@ public class JetAnnotationEntry extends JetElementImplStub<KotlinAnnotationEntry
     }
 
     @Override
-    public JetTypeArgumentList getTypeArgumentList() {
-        JetTypeReference typeReference = getTypeReference();
+    public KtTypeArgumentList getTypeArgumentList() {
+        KtTypeReference typeReference = getTypeReference();
         if (typeReference == null) {
             return null;
         }
-        JetTypeElement typeElement = typeReference.getTypeElement();
-        if (typeElement instanceof JetUserType) {
-            JetUserType userType = (JetUserType) typeElement;
+        KtTypeElement typeElement = typeReference.getTypeElement();
+        if (typeElement instanceof KtUserType) {
+            KtUserType userType = (KtUserType) typeElement;
             return userType.getTypeArgumentList();
         }
         return null;
@@ -105,17 +105,17 @@ public class JetAnnotationEntry extends JetElementImplStub<KotlinAnnotationEntry
 
     @Nullable
     public PsiElement getAtSymbol() {
-        return findChildByType(JetTokens.AT);
+        return findChildByType(KtTokens.AT);
     }
 
     @Nullable
-    public JetAnnotationUseSiteTarget getUseSiteTarget() {
-        JetAnnotationUseSiteTarget target = getStubOrPsiChild(JetStubElementTypes.ANNOTATION_TARGET);
+    public KtAnnotationUseSiteTarget getUseSiteTarget() {
+        KtAnnotationUseSiteTarget target = getStubOrPsiChild(KtStubElementTypes.ANNOTATION_TARGET);
 
         if (target == null) {
             PsiElement parent = getParentByStub();
-            if (parent instanceof JetAnnotation) {
-                return ((JetAnnotation) parent).getUseSiteTarget();
+            if (parent instanceof KtAnnotation) {
+                return ((KtAnnotation) parent).getUseSiteTarget();
             }
         }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotationUseSiteTarget.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotationUseSiteTarget.kt
similarity index 61%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotationUseSiteTarget.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotationUseSiteTarget.kt
index 7ed1703e3cd..45dee4b1d8b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotationUseSiteTarget.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotationUseSiteTarget.kt
@@ -19,20 +19,20 @@ package org.jetbrains.kotlin.psi
 import com.intellij.lang.ASTNode
 import com.intellij.psi.impl.source.tree.TreeElement
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
-import org.jetbrains.kotlin.lexer.JetKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.stubs.KotlinAnnotationEntryStub
 import org.jetbrains.kotlin.psi.stubs.KotlinAnnotationUseSiteTargetStub
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 
-public class JetAnnotationUseSiteTarget : JetElementImplStub<KotlinAnnotationUseSiteTargetStub> {
+public class KtAnnotationUseSiteTarget : KtElementImplStub<KotlinAnnotationUseSiteTargetStub> {
 
     constructor(node: ASTNode) : super(node)
 
-    constructor(stub: KotlinAnnotationUseSiteTargetStub) : super(stub, JetStubElementTypes.ANNOTATION_TARGET)
+    constructor(stub: KotlinAnnotationUseSiteTargetStub) : super(stub, KtStubElementTypes.ANNOTATION_TARGET)
 
-    override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D) = visitor.visitAnnotationUseSiteTarget(this, data)
+    override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D) = visitor.visitAnnotationUseSiteTarget(this, data)
 
     public fun getAnnotationUseSiteTarget(): AnnotationUseSiteTarget {
         val targetString = stub?.getUseSiteTarget()
@@ -46,14 +46,14 @@ public class JetAnnotationUseSiteTarget : JetElementImplStub<KotlinAnnotationUse
 
         val node = getFirstChild().getNode()
         return when (node.getElementType()) {
-            JetTokens.FIELD_KEYWORD -> AnnotationUseSiteTarget.FIELD
-            JetTokens.FILE_KEYWORD -> AnnotationUseSiteTarget.FILE
-            JetTokens.PROPERTY_KEYWORD -> AnnotationUseSiteTarget.PROPERTY
-            JetTokens.GET_KEYWORD -> AnnotationUseSiteTarget.PROPERTY_GETTER
-            JetTokens.SET_KEYWORD -> AnnotationUseSiteTarget.PROPERTY_SETTER
-            JetTokens.RECEIVER_KEYWORD -> AnnotationUseSiteTarget.RECEIVER
-            JetTokens.PARAM_KEYWORD -> AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER
-            JetTokens.SETPARAM_KEYWORD -> AnnotationUseSiteTarget.SETTER_PARAMETER
+            KtTokens.FIELD_KEYWORD -> AnnotationUseSiteTarget.FIELD
+            KtTokens.FILE_KEYWORD -> AnnotationUseSiteTarget.FILE
+            KtTokens.PROPERTY_KEYWORD -> AnnotationUseSiteTarget.PROPERTY
+            KtTokens.GET_KEYWORD -> AnnotationUseSiteTarget.PROPERTY_GETTER
+            KtTokens.SET_KEYWORD -> AnnotationUseSiteTarget.PROPERTY_SETTER
+            KtTokens.RECEIVER_KEYWORD -> AnnotationUseSiteTarget.RECEIVER
+            KtTokens.PARAM_KEYWORD -> AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER
+            KtTokens.SETPARAM_KEYWORD -> AnnotationUseSiteTarget.SETTER_PARAMETER
             else -> throw IllegalStateException("Unknown annotation target " + node.getText())
         }
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotationsContainer.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotationsContainer.java
similarity index 91%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotationsContainer.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotationsContainer.java
index 326d9c5b3f9..4fb342c8d59 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetAnnotationsContainer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtAnnotationsContainer.java
@@ -16,5 +16,5 @@
 
 package org.jetbrains.kotlin.psi;
 
-public interface JetAnnotationsContainer extends JetElement {
+public interface KtAnnotationsContainer extends KtElement {
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetArrayAccessExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtArrayAccessExpression.java
similarity index 70%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetArrayAccessExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtArrayAccessExpression.java
index 78861624fbe..b565b9bcdbc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetArrayAccessExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtArrayAccessExpression.java
@@ -23,35 +23,35 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetArrayAccessExpression extends JetExpressionImpl implements JetReferenceExpression {
-    public JetArrayAccessExpression(@NotNull ASTNode node) {
+public class KtArrayAccessExpression extends KtExpressionImpl implements KtReferenceExpression {
+    public KtArrayAccessExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitArrayAccessExpression(this, data);
     }
 
     @Nullable @IfNotParsed
-    public JetExpression getArrayExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getArrayExpression() {
+        return findChildByClass(KtExpression.class);
     }
 
     @NotNull
-    public List<JetExpression> getIndexExpressions() {
-        return PsiTreeUtil.getChildrenOfTypeAsList(getIndicesNode(), JetExpression.class);
+    public List<KtExpression> getIndexExpressions() {
+        return PsiTreeUtil.getChildrenOfTypeAsList(getIndicesNode(), KtExpression.class);
     }
 
     @NotNull
-    public JetContainerNode getIndicesNode() {
-        JetContainerNode indicesNode = findChildByType(JetNodeTypes.INDICES);
+    public KtContainerNode getIndicesNode() {
+        KtContainerNode indicesNode = findChildByType(KtNodeTypes.INDICES);
         assert indicesNode != null : "Can't be null because of parser";
         return indicesNode;
     }
@@ -68,11 +68,11 @@ public class JetArrayAccessExpression extends JetExpressionImpl implements JetRe
 
     @Nullable
     public PsiElement getLeftBracket() {
-        return getIndicesNode().findChildByType(JetTokens.LBRACKET);
+        return getIndicesNode().findChildByType(KtTokens.LBRACKET);
     }
 
     @Nullable
     public PsiElement getRightBracket() {
-        return getIndicesNode().findChildByType(JetTokens.RBRACKET);
+        return getIndicesNode().findChildByType(KtTokens.RBRACKET);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetBinaryExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtBinaryExpression.java
similarity index 70%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetBinaryExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtBinaryExpression.java
index a884bacb4c3..aa3b2f73822 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetBinaryExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtBinaryExpression.java
@@ -21,25 +21,25 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
-public class JetBinaryExpression extends JetExpressionImpl implements JetOperationExpression {
-    public JetBinaryExpression(@NotNull ASTNode node) {
+public class KtBinaryExpression extends KtExpressionImpl implements KtOperationExpression {
+    public KtBinaryExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitBinaryExpression(this, data);
     }
 
     @Nullable @IfNotParsed
-    public JetExpression getLeft() {
+    public KtExpression getLeft() {
         ASTNode node = getOperationReference().getNode().getTreePrev();
         while (node != null) {
             PsiElement psi = node.getPsi();
-            if (psi instanceof JetExpression) {
-                return (JetExpression) psi;
+            if (psi instanceof KtExpression) {
+                return (KtExpression) psi;
             }
             node = node.getTreePrev();
         }
@@ -48,12 +48,12 @@ public class JetBinaryExpression extends JetExpressionImpl implements JetOperati
     }
 
     @Nullable @IfNotParsed
-    public JetExpression getRight() {
+    public KtExpression getRight() {
         ASTNode node = getOperationReference().getNode().getTreeNext();
         while (node != null) {
             PsiElement psi = node.getPsi();
-            if (psi instanceof JetExpression) {
-                return (JetExpression) psi;
+            if (psi instanceof KtExpression) {
+                return (KtExpression) psi;
             }
             node = node.getTreeNext();
         }
@@ -63,8 +63,8 @@ public class JetBinaryExpression extends JetExpressionImpl implements JetOperati
 
     @Override
     @NotNull
-    public JetSimpleNameExpression getOperationReference() {
-        return (JetSimpleNameExpression) findChildByType(JetNodeTypes.OPERATION_REFERENCE);
+    public KtSimpleNameExpression getOperationReference() {
+        return (KtSimpleNameExpression) findChildByType(KtNodeTypes.OPERATION_REFERENCE);
     }
 
     @NotNull
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetBinaryExpressionWithTypeRHS.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtBinaryExpressionWithTypeRHS.java
similarity index 64%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetBinaryExpressionWithTypeRHS.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtBinaryExpressionWithTypeRHS.java
index 2208fed498e..2c40c74c069 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetBinaryExpressionWithTypeRHS.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtBinaryExpressionWithTypeRHS.java
@@ -20,32 +20,32 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
-public class JetBinaryExpressionWithTypeRHS extends JetExpressionImpl implements JetOperationExpression {
-    public JetBinaryExpressionWithTypeRHS(@NotNull ASTNode node) {
+public class KtBinaryExpressionWithTypeRHS extends KtExpressionImpl implements KtOperationExpression {
+    public KtBinaryExpressionWithTypeRHS(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitBinaryWithTypeRHSExpression(this, data);
     }
 
     @NotNull
-    public JetExpression getLeft() {
-        JetExpression left = findChildByClass(JetExpression.class);
+    public KtExpression getLeft() {
+        KtExpression left = findChildByClass(KtExpression.class);
         assert left != null;
         return left;
     }
 
     @Nullable @IfNotParsed
-    public JetTypeReference getRight() {
+    public KtTypeReference getRight() {
         ASTNode node = getOperationReference().getNode();
         while (node != null) {
             PsiElement psi = node.getPsi();
-            if (psi instanceof JetTypeReference) {
-                return (JetTypeReference) psi;
+            if (psi instanceof KtTypeReference) {
+                return (KtTypeReference) psi;
             }
             node = node.getTreeNext();
         }
@@ -55,8 +55,8 @@ public class JetBinaryExpressionWithTypeRHS extends JetExpressionImpl implements
 
     @Override
     @NotNull
-    public JetSimpleNameExpression getOperationReference() {
-        return (JetSimpleNameExpression) findChildByType(JetNodeTypes.OPERATION_REFERENCE);
+    public KtSimpleNameExpression getOperationReference() {
+        return (KtSimpleNameExpression) findChildByType(KtNodeTypes.OPERATION_REFERENCE);
     }
 
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetBlockCodeFragment.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtBlockCodeFragment.kt
similarity index 84%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetBlockCodeFragment.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtBlockCodeFragment.kt
index 4150f7a04f3..0cec2747b03 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetBlockCodeFragment.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtBlockCodeFragment.kt
@@ -18,16 +18,16 @@ package org.jetbrains.kotlin.psi
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.JetNodeTypes
+import org.jetbrains.kotlin.KtNodeTypes
 
-public class JetBlockCodeFragment(
+public class KtBlockCodeFragment(
         project: Project,
         name: String,
         text: CharSequence,
         imports: String?,
         context: PsiElement?
-) : JetCodeFragment(project, name, text, imports, JetNodeTypes.BLOCK_CODE_FRAGMENT, context) {
+) : KtCodeFragment(project, name, text, imports, KtNodeTypes.BLOCK_CODE_FRAGMENT, context) {
 
-    override fun getContentElement() = findChildByClass(javaClass<JetBlockExpression>())
+    override fun getContentElement() = findChildByClass(javaClass<KtBlockExpression>())
                                                 ?: throw IllegalStateException("Block expression should be parsed for BlockCodeFragment")
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetBlockCodeFragmentType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtBlockCodeFragmentType.java
similarity index 90%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetBlockCodeFragmentType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtBlockCodeFragmentType.java
index e9d19046501..1ef1eefb08c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetBlockCodeFragmentType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtBlockCodeFragmentType.java
@@ -24,12 +24,12 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.parsing.JetParser;
-import org.jetbrains.kotlin.psi.stubs.elements.JetFileElementType;
+import org.jetbrains.kotlin.psi.stubs.elements.KtFileElementType;
 
-public class JetBlockCodeFragmentType extends JetFileElementType {
+public class KtBlockCodeFragmentType extends KtFileElementType {
     private static final String NAME = "kotlin.BLOCK_CODE_FRAGMENT";
 
-    public JetBlockCodeFragmentType() {
+    public KtBlockCodeFragmentType() {
         super(NAME);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetBlockExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtBlockExpression.java
similarity index 78%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetBlockExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtBlockExpression.java
index e1a4c1620f7..3f200e06f69 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetBlockExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtBlockExpression.java
@@ -23,13 +23,13 @@ import com.intellij.psi.PsiModifiableCodeBlock;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.ReadOnly;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
 import java.util.Arrays;
 import java.util.List;
 
-public class JetBlockExpression extends JetExpressionImpl implements JetStatementExpression, PsiModifiableCodeBlock {
-    public JetBlockExpression(@NotNull ASTNode node) {
+public class KtBlockExpression extends KtExpressionImpl implements KtStatementExpression, PsiModifiableCodeBlock {
+    public KtBlockExpression(@NotNull ASTNode node) {
         super(node);
     }
 
@@ -40,14 +40,14 @@ public class JetBlockExpression extends JetExpressionImpl implements JetStatemen
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitBlockExpression(this, data);
     }
 
     @ReadOnly
     @NotNull
-    public List<JetExpression> getStatements() {
-        return Arrays.asList(findChildrenByClass(JetExpression.class));
+    public List<KtExpression> getStatements() {
+        return Arrays.asList(findChildrenByClass(KtExpression.class));
     }
 
     @Nullable
@@ -58,11 +58,11 @@ public class JetBlockExpression extends JetExpressionImpl implements JetStatemen
 
     @Nullable
     public PsiElement getRBrace() {
-        return findChildByType(JetTokens.RBRACE);
+        return findChildByType(KtTokens.RBRACE);
     }
 
     @Nullable
     public PsiElement getLBrace() {
-        return findChildByType(JetTokens.LBRACE);
+        return findChildByType(KtTokens.LBRACE);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetBlockStringTemplateEntry.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtBlockStringTemplateEntry.java
similarity index 78%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetBlockStringTemplateEntry.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtBlockStringTemplateEntry.java
index fb72c385147..e97f62836a5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetBlockStringTemplateEntry.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtBlockStringTemplateEntry.java
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 
-public class JetBlockStringTemplateEntry extends JetStringTemplateEntryWithExpression {
-    public JetBlockStringTemplateEntry(@NotNull ASTNode node) {
+public class KtBlockStringTemplateEntry extends KtStringTemplateEntryWithExpression {
+    public KtBlockStringTemplateEntry(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitBlockStringTemplateEntry(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetBreakExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtBreakExpression.java
similarity index 78%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetBreakExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtBreakExpression.java
index e9196a2a3ff..3f15272030b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetBreakExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtBreakExpression.java
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 
-public class JetBreakExpression extends JetExpressionWithLabel implements JetStatementExpression {
-    public JetBreakExpression(@NotNull ASTNode node) {
+public class KtBreakExpression extends KtExpressionWithLabel implements KtStatementExpression {
+    public KtBreakExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitBreakExpression(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetCallElement.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtCallElement.java
similarity index 74%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetCallElement.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtCallElement.java
index 39614698f4a..7ec499defa9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetCallElement.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtCallElement.java
@@ -21,22 +21,22 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-public interface JetCallElement extends JetElement {
+public interface KtCallElement extends KtElement {
     @Nullable
-    JetExpression getCalleeExpression();
+    KtExpression getCalleeExpression();
 
     @Nullable
-    JetValueArgumentList getValueArgumentList();
+    KtValueArgumentList getValueArgumentList();
 
     @NotNull
     List<? extends ValueArgument> getValueArguments();
 
     @NotNull
-    List<JetFunctionLiteralArgument> getFunctionLiteralArguments();
+    List<KtFunctionLiteralArgument> getFunctionLiteralArguments();
 
     @NotNull
-    List<JetTypeProjection> getTypeArguments();
+    List<KtTypeProjection> getTypeArguments();
 
     @Nullable
-    JetTypeArgumentList getTypeArgumentList();
+    KtTypeArgumentList getTypeArgumentList();
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetCallExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtCallExpression.java
similarity index 56%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetCallExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtCallExpression.java
index c13a4abfc88..bd3bb2b8570 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetCallExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtCallExpression.java
@@ -20,37 +20,37 @@ import com.google.common.collect.Lists;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetCallExpression extends JetExpressionImpl implements JetCallElement, JetReferenceExpression {
-    public JetCallExpression(@NotNull ASTNode node) {
+public class KtCallExpression extends KtExpressionImpl implements KtCallElement, KtReferenceExpression {
+    public KtCallExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitCallExpression(this, data);
     }
 
     @Override
     @Nullable
-    public JetExpression getCalleeExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getCalleeExpression() {
+        return findChildByClass(KtExpression.class);
     }
 
     @Override
     @Nullable
-    public JetValueArgumentList getValueArgumentList() {
-        return (JetValueArgumentList) findChildByType(JetNodeTypes.VALUE_ARGUMENT_LIST);
+    public KtValueArgumentList getValueArgumentList() {
+        return (KtValueArgumentList) findChildByType(KtNodeTypes.VALUE_ARGUMENT_LIST);
     }
 
     @Override
     @Nullable
-    public JetTypeArgumentList getTypeArgumentList() {
-        return (JetTypeArgumentList) findChildByType(JetNodeTypes.TYPE_ARGUMENT_LIST);
+    public KtTypeArgumentList getTypeArgumentList() {
+        return (KtTypeArgumentList) findChildByType(KtNodeTypes.TYPE_ARGUMENT_LIST);
     }
 
     /**
@@ -60,20 +60,20 @@ public class JetCallExpression extends JetExpressionImpl implements JetCallEleme
      */
     @Override
     @NotNull
-    public List<JetFunctionLiteralArgument> getFunctionLiteralArguments() {
-        return findChildrenByType(JetNodeTypes.FUNCTION_LITERAL_ARGUMENT);
+    public List<KtFunctionLiteralArgument> getFunctionLiteralArguments() {
+        return findChildrenByType(KtNodeTypes.FUNCTION_LITERAL_ARGUMENT);
     }
 
     @Override
     @NotNull
-    public List<JetValueArgument> getValueArguments() {
-        JetValueArgumentList list = getValueArgumentList();
-        List<JetValueArgument> valueArgumentsInParentheses = list != null ? list.getArguments() : Collections.<JetValueArgument>emptyList();
-        List<JetFunctionLiteralArgument> functionLiteralArguments = getFunctionLiteralArguments();
+    public List<KtValueArgument> getValueArguments() {
+        KtValueArgumentList list = getValueArgumentList();
+        List<KtValueArgument> valueArgumentsInParentheses = list != null ? list.getArguments() : Collections.<KtValueArgument>emptyList();
+        List<KtFunctionLiteralArgument> functionLiteralArguments = getFunctionLiteralArguments();
         if (functionLiteralArguments.isEmpty()) {
             return valueArgumentsInParentheses;
         }
-        List<JetValueArgument> allValueArguments = Lists.newArrayList();
+        List<KtValueArgument> allValueArguments = Lists.newArrayList();
         allValueArguments.addAll(valueArgumentsInParentheses);
         allValueArguments.addAll(functionLiteralArguments);
         return allValueArguments;
@@ -81,8 +81,8 @@ public class JetCallExpression extends JetExpressionImpl implements JetCallEleme
 
     @Override
     @NotNull
-    public List<JetTypeProjection> getTypeArguments() {
-        JetTypeArgumentList list = getTypeArgumentList();
-        return list != null ? list.getArguments() : Collections.<JetTypeProjection>emptyList();
+    public List<KtTypeProjection> getTypeArguments() {
+        KtTypeArgumentList list = getTypeArgumentList();
+        return list != null ? list.getArguments() : Collections.<KtTypeProjection>emptyList();
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetCallableDeclaration.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtCallableDeclaration.java
similarity index 71%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetCallableDeclaration.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtCallableDeclaration.java
index 377f42ab4b3..356b2f48778 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetCallableDeclaration.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtCallableDeclaration.java
@@ -22,21 +22,21 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-public interface JetCallableDeclaration extends JetNamedDeclaration, JetTypeParameterListOwner {
+public interface KtCallableDeclaration extends KtNamedDeclaration, KtTypeParameterListOwner {
     @Nullable
-    JetParameterList getValueParameterList();
+    KtParameterList getValueParameterList();
 
     @NotNull
-    List<JetParameter> getValueParameters();
+    List<KtParameter> getValueParameters();
 
     @Nullable
-    JetTypeReference getReceiverTypeReference();
+    KtTypeReference getReceiverTypeReference();
 
     @Nullable
-    JetTypeReference getTypeReference();
+    KtTypeReference getTypeReference();
 
     @Nullable
-    JetTypeReference setTypeReference(@Nullable JetTypeReference typeRef);
+    KtTypeReference setTypeReference(@Nullable KtTypeReference typeRef);
 
     @Nullable
     PsiElement getColon();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetCallableReferenceExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtCallableReferenceExpression.java
similarity index 74%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetCallableReferenceExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtCallableReferenceExpression.java
index a3ccbf44349..b1546719e34 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetCallableReferenceExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtCallableReferenceExpression.java
@@ -20,17 +20,17 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 
-public class JetCallableReferenceExpression extends JetDoubleColonExpression {
-    public JetCallableReferenceExpression(@NotNull ASTNode node) {
+public class KtCallableReferenceExpression extends KtDoubleColonExpression {
+    public KtCallableReferenceExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @NotNull
-    public JetSimpleNameExpression getCallableReference() {
+    public KtSimpleNameExpression getCallableReference() {
         PsiElement psi = getDoubleColonTokenReference();
         while (psi != null) {
-            if (psi instanceof JetSimpleNameExpression) {
-                return (JetSimpleNameExpression) psi;
+            if (psi instanceof KtSimpleNameExpression) {
+                return (KtSimpleNameExpression) psi;
             }
             psi = psi.getNextSibling();
         }
@@ -39,7 +39,7 @@ public class JetCallableReferenceExpression extends JetDoubleColonExpression {
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitCallableReferenceExpression(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetCatchClause.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtCatchClause.java
similarity index 64%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetCatchClause.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtCatchClause.java
index ff1dba1e6fc..2e357ec5f96 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetCatchClause.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtCatchClause.java
@@ -19,36 +19,36 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
 import java.util.List;
 
-public class JetCatchClause extends JetElementImpl {
-    public JetCatchClause(@NotNull ASTNode node) {
+public class KtCatchClause extends KtElementImpl {
+    public KtCatchClause(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitCatchSection(this, data);
     }
 
     @Nullable @IfNotParsed
-    public JetParameterList getParameterList() {
-        return (JetParameterList) findChildByType(JetNodeTypes.VALUE_PARAMETER_LIST);
+    public KtParameterList getParameterList() {
+        return (KtParameterList) findChildByType(KtNodeTypes.VALUE_PARAMETER_LIST);
     }
 
     @Nullable @IfNotParsed
-    public JetParameter getCatchParameter() {
-        JetParameterList list = getParameterList();
+    public KtParameter getCatchParameter() {
+        KtParameterList list = getParameterList();
         if (list == null) return null;
-        List<JetParameter> parameters = list.getParameters();
+        List<KtParameter> parameters = list.getParameters();
         return parameters.size() == 1 ? parameters.get(0) : null;
     }
 
 
     @Nullable @IfNotParsed
-    public JetExpression getCatchBody() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getCatchBody() {
+        return findChildByClass(KtExpression.class);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClass.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtClass.kt
similarity index 63%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetClass.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtClass.kt
index bfc8a7c9467..7464f8d3222 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClass.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtClass.kt
@@ -21,38 +21,38 @@ import com.intellij.openapi.util.text.StringUtil
 import com.intellij.psi.PsiElement
 import com.intellij.psi.tree.TokenSet
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.stubs.KotlinClassStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import java.util.*
 
-public open class JetClass : JetClassOrObject {
+public open class KtClass : KtClassOrObject {
     public constructor(node: ASTNode) : super(node)
-    public constructor(stub: KotlinClassStub) : super(stub, JetStubElementTypes.CLASS)
+    public constructor(stub: KotlinClassStub) : super(stub, KtStubElementTypes.CLASS)
 
-    override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D): R {
+    override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D): R {
         return visitor.visitClass(this, data)
     }
 
     private val _stub: KotlinClassStub?
         get() = stub as? KotlinClassStub
 
-    public fun getColon(): PsiElement? = findChildByType(JetTokens.COLON)
+    public fun getColon(): PsiElement? = findChildByType(KtTokens.COLON)
 
-    public fun getProperties(): List<JetProperty> = getBody()?.getProperties().orEmpty()
+    public fun getProperties(): List<KtProperty> = getBody()?.getProperties().orEmpty()
 
     public fun isInterface(): Boolean =
-        _stub?.isInterface() ?: (findChildByType<PsiElement>(JetTokens.INTERFACE_KEYWORD) != null)
+        _stub?.isInterface() ?: (findChildByType<PsiElement>(KtTokens.INTERFACE_KEYWORD) != null)
 
-    public fun isEnum(): Boolean = hasModifier(JetTokens.ENUM_KEYWORD)
-    public fun isSealed(): Boolean = hasModifier(JetTokens.SEALED_KEYWORD)
-    public fun isInner(): Boolean = hasModifier(JetTokens.INNER_KEYWORD)
+    public fun isEnum(): Boolean = hasModifier(KtTokens.ENUM_KEYWORD)
+    public fun isSealed(): Boolean = hasModifier(KtTokens.SEALED_KEYWORD)
+    public fun isInner(): Boolean = hasModifier(KtTokens.INNER_KEYWORD)
 
     override fun isEquivalentTo(another: PsiElement?): Boolean {
         if (super.isEquivalentTo(another)) {
             return true
         }
-        if (another is JetClass) {
+        if (another is KtClass) {
             val fq1 = getQualifiedName()
             val fq2 = another.getQualifiedName()
             return fq1 != null && fq2 != null && fq1 == fq2
@@ -68,13 +68,13 @@ public open class JetClass : JetClassOrObject {
         }
 
         val parts = ArrayList<String>()
-        var current: JetClassOrObject? = this
+        var current: KtClassOrObject? = this
         while (current != null) {
             parts.add(current.getName()!!)
-            current = PsiTreeUtil.getParentOfType<JetClassOrObject>(current, javaClass<JetClassOrObject>())
+            current = PsiTreeUtil.getParentOfType<KtClassOrObject>(current, javaClass<KtClassOrObject>())
         }
         val file = getContainingFile()
-        if (file !is JetFile) return null
+        if (file !is KtFile) return null
         val fileQualifiedName = file.getPackageFqName().asString()
         if (!fileQualifiedName.isEmpty()) {
             parts.add(fileQualifiedName)
@@ -83,7 +83,7 @@ public open class JetClass : JetClassOrObject {
         return StringUtil.join(parts, ".")
     }
 
-    public fun getCompanionObjects(): List<JetObjectDeclaration> = getBody()?.getAllCompanionObjects().orEmpty()
+    public fun getCompanionObjects(): List<KtObjectDeclaration> = getBody()?.getAllCompanionObjects().orEmpty()
 
-    public fun getClassOrInterfaceKeyword(): PsiElement? = findChildByType(TokenSet.create(JetTokens.CLASS_KEYWORD, JetTokens.INTERFACE_KEYWORD))
+    public fun getClassOrInterfaceKeyword(): PsiElement? = findChildByType(TokenSet.create(KtTokens.CLASS_KEYWORD, KtTokens.INTERFACE_KEYWORD))
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassBody.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtClassBody.java
similarity index 58%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassBody.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtClassBody.java
index c0c9c71a31c..15c54919891 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassBody.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtClassBody.java
@@ -24,56 +24,56 @@ import kotlin.CollectionsKt;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.Arrays;
 import java.util.List;
 
-import static org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes.*;
+import static org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes.*;
 
-public class JetClassBody extends JetElementImplStub<KotlinPlaceHolderStub<JetClassBody>> implements JetDeclarationContainer {
+public class KtClassBody extends KtElementImplStub<KotlinPlaceHolderStub<KtClassBody>> implements KtDeclarationContainer {
 
-    public JetClassBody(@NotNull ASTNode node) {
+    public KtClassBody(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetClassBody(@NotNull KotlinPlaceHolderStub<JetClassBody> stub) {
+    public KtClassBody(@NotNull KotlinPlaceHolderStub<KtClassBody> stub) {
         super(stub, CLASS_BODY);
     }
 
     @Override
     @NotNull
-    public List<JetDeclaration> getDeclarations() {
-        return Arrays.asList(getStubOrPsiChildren(DECLARATION_TYPES, JetDeclaration.ARRAY_FACTORY));
+    public List<KtDeclaration> getDeclarations() {
+        return Arrays.asList(getStubOrPsiChildren(DECLARATION_TYPES, KtDeclaration.ARRAY_FACTORY));
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitClassBody(this, data);
     }
 
     @NotNull
-    public List<JetClassInitializer> getAnonymousInitializers() {
-        return findChildrenByType(JetNodeTypes.ANONYMOUS_INITIALIZER);
+    public List<KtClassInitializer> getAnonymousInitializers() {
+        return findChildrenByType(KtNodeTypes.ANONYMOUS_INITIALIZER);
     }
 
     @NotNull
-    /* package-protected */ List<JetSecondaryConstructor> getSecondaryConstructors() {
-        return getStubOrPsiChildrenAsList(JetStubElementTypes.SECONDARY_CONSTRUCTOR);
+    /* package-protected */ List<KtSecondaryConstructor> getSecondaryConstructors() {
+        return getStubOrPsiChildrenAsList(KtStubElementTypes.SECONDARY_CONSTRUCTOR);
     }
 
     @NotNull
-    public List<JetProperty> getProperties() {
-        return getStubOrPsiChildrenAsList(JetStubElementTypes.PROPERTY);
+    public List<KtProperty> getProperties() {
+        return getStubOrPsiChildrenAsList(KtStubElementTypes.PROPERTY);
     }
 
     @NotNull
-    public List<JetObjectDeclaration> getAllCompanionObjects() {
-        List<JetObjectDeclaration> result = Lists.newArrayList();
-        for (JetObjectDeclaration declaration : getStubOrPsiChildrenAsList(JetStubElementTypes.OBJECT_DECLARATION)) {
+    public List<KtObjectDeclaration> getAllCompanionObjects() {
+        List<KtObjectDeclaration> result = Lists.newArrayList();
+        for (KtObjectDeclaration declaration : getStubOrPsiChildrenAsList(KtStubElementTypes.OBJECT_DECLARATION)) {
             if (declaration.isCompanion()) {
                 result.add(declaration);
             }
@@ -83,13 +83,13 @@ public class JetClassBody extends JetElementImplStub<KotlinPlaceHolderStub<JetCl
 
     @Nullable
     public PsiElement getRBrace() {
-        ASTNode[] children = getNode().getChildren(TokenSet.create(JetTokens.RBRACE));
+        ASTNode[] children = getNode().getChildren(TokenSet.create(KtTokens.RBRACE));
         return children.length == 1 ? children[0].getPsi() : null;
     }
 
     @Nullable
     public PsiElement getLBrace() {
-        ASTNode[] children = getNode().getChildren(TokenSet.create(JetTokens.LBRACE));
+        ASTNode[] children = getNode().getChildren(TokenSet.create(KtTokens.LBRACE));
         return children.length == 1 ? children[0].getPsi() : null;
     }
 
@@ -97,12 +97,12 @@ public class JetClassBody extends JetElementImplStub<KotlinPlaceHolderStub<JetCl
      * @return annotations that do not belong to any declaration due to incomplete code or syntax errors
      */
     @NotNull
-    public List<JetAnnotationEntry> getDanglingAnnotations() {
+    public List<KtAnnotationEntry> getDanglingAnnotations() {
         return CollectionsKt.flatMap(
                 getStubOrPsiChildrenAsList(MODIFIER_LIST),
-                new Function1<JetModifierList, Iterable<JetAnnotationEntry>>() {
+                new Function1<KtModifierList, Iterable<KtAnnotationEntry>>() {
                     @Override
-                    public Iterable<JetAnnotationEntry> invoke(JetModifierList modifierList) {
+                    public Iterable<KtAnnotationEntry> invoke(KtModifierList modifierList) {
                         return modifierList.getAnnotationEntries();
                     }
                 });
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassInitializer.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtClassInitializer.java
similarity index 60%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassInitializer.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtClassInitializer.java
index 07a912181f7..ec8f4f83f5f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassInitializer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtClassInitializer.java
@@ -20,33 +20,33 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
-public class JetClassInitializer extends JetDeclarationStub<KotlinPlaceHolderStub<JetClassInitializer>> implements JetStatementExpression {
-    public JetClassInitializer(@NotNull ASTNode node) {
+public class KtClassInitializer extends KtDeclarationStub<KotlinPlaceHolderStub<KtClassInitializer>> implements KtStatementExpression {
+    public KtClassInitializer(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetClassInitializer(@NotNull KotlinPlaceHolderStub<JetClassInitializer> stub) {
-        super(stub, JetStubElementTypes.ANONYMOUS_INITIALIZER);
+    public KtClassInitializer(@NotNull KotlinPlaceHolderStub<KtClassInitializer> stub) {
+        super(stub, KtStubElementTypes.ANONYMOUS_INITIALIZER);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitAnonymousInitializer(this, data);
     }
 
     @Nullable
-    public JetExpression getBody() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getBody() {
+        return findChildByClass(KtExpression.class);
     }
 
     @Nullable
     public PsiElement getOpenBraceNode() {
-        JetExpression body = getBody();
-        return (body instanceof JetBlockExpression) ? ((JetBlockExpression) body).getLBrace() : null;
+        KtExpression body = getBody();
+        return (body instanceof KtBlockExpression) ? ((KtBlockExpression) body).getLBrace() : null;
     }
 
     @NotNull
@@ -57,6 +57,6 @@ public class JetClassInitializer extends JetDeclarationStub<KotlinPlaceHolderStu
 
     @Nullable
     public PsiElement getInitKeyword() {
-        return findChildByType(JetTokens.INIT_KEYWORD);
+        return findChildByType(KtTokens.INIT_KEYWORD);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassLiteralExpression.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtClassLiteralExpression.kt
similarity index 82%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassLiteralExpression.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtClassLiteralExpression.kt
index 444be0a52d6..98741849ef4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassLiteralExpression.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtClassLiteralExpression.kt
@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.psi
 
 import com.intellij.lang.ASTNode
 
-public class JetClassLiteralExpression(node: ASTNode) : JetDoubleColonExpression(node) {
-    override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D): R {
+public class KtClassLiteralExpression(node: ASTNode) : KtDoubleColonExpression(node) {
+    override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D): R {
         return visitor.visitClassLiteralExpression(this, data)
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtClassOrObject.kt
similarity index 51%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtClassOrObject.kt
index 148d92d043c..7823afcbaff 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtClassOrObject.kt
@@ -25,89 +25,89 @@ import com.intellij.psi.impl.CheckUtil
 import com.intellij.psi.impl.source.codeStyle.CodeEditUtil
 import com.intellij.psi.stubs.IStubElementType
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.JetNodeTypes
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.KtNodeTypes
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 
-abstract public class JetClassOrObject :
-        JetTypeParameterListOwnerStub<KotlinClassOrObjectStub<out JetClassOrObject>>, JetDeclarationContainer, JetNamedDeclaration {
+abstract public class KtClassOrObject :
+        KtTypeParameterListOwnerStub<KotlinClassOrObjectStub<out KtClassOrObject>>, KtDeclarationContainer, KtNamedDeclaration {
     public constructor(node: ASTNode) : super(node)
-    public constructor(stub: KotlinClassOrObjectStub<out JetClassOrObject>, nodeType: IStubElementType<*, *>) : super(stub, nodeType)
+    public constructor(stub: KotlinClassOrObjectStub<out KtClassOrObject>, nodeType: IStubElementType<*, *>) : super(stub, nodeType)
 
-    public fun getDelegationSpecifierList(): JetDelegationSpecifierList? = getStubOrPsiChild(JetStubElementTypes.DELEGATION_SPECIFIER_LIST)
-    open public fun getDelegationSpecifiers(): List<JetDelegationSpecifier> = getDelegationSpecifierList()?.getDelegationSpecifiers().orEmpty()
+    public fun getDelegationSpecifierList(): KtDelegationSpecifierList? = getStubOrPsiChild(KtStubElementTypes.DELEGATION_SPECIFIER_LIST)
+    open public fun getDelegationSpecifiers(): List<KtDelegationSpecifier> = getDelegationSpecifierList()?.getDelegationSpecifiers().orEmpty()
 
-    public fun addDelegationSpecifier(delegationSpecifier: JetDelegationSpecifier): JetDelegationSpecifier {
+    public fun addDelegationSpecifier(delegationSpecifier: KtDelegationSpecifier): KtDelegationSpecifier {
         getDelegationSpecifierList()?.let {
             return EditCommaSeparatedListHelper.addItem(it, getDelegationSpecifiers(), delegationSpecifier)
         }
 
-        val psiFactory = JetPsiFactory(this)
+        val psiFactory = KtPsiFactory(this)
         val specifierListToAdd = psiFactory.createDelegatorToSuperCall("A()").replace(delegationSpecifier).getParent()
         val colon = addBefore(psiFactory.createColon(), getBody())
-        return (addAfter(specifierListToAdd, colon) as JetDelegationSpecifierList).getDelegationSpecifiers().first()
+        return (addAfter(specifierListToAdd, colon) as KtDelegationSpecifierList).getDelegationSpecifiers().first()
     }
 
-    public fun removeDelegationSpecifier(delegationSpecifier: JetDelegationSpecifier) {
+    public fun removeDelegationSpecifier(delegationSpecifier: KtDelegationSpecifier) {
         val specifierList = getDelegationSpecifierList() ?: return
         assert(delegationSpecifier.getParent() === specifierList)
 
         if (specifierList.getDelegationSpecifiers().size() > 1) {
-            EditCommaSeparatedListHelper.removeItem<JetElement>(delegationSpecifier)
+            EditCommaSeparatedListHelper.removeItem<KtElement>(delegationSpecifier)
         }
         else {
-            deleteChildRange(findChildByType<PsiElement>(JetTokens.COLON) ?: specifierList, specifierList)
+            deleteChildRange(findChildByType<PsiElement>(KtTokens.COLON) ?: specifierList, specifierList)
         }
     }
 
-    public fun getAnonymousInitializers(): List<JetClassInitializer> = getBody()?.getAnonymousInitializers().orEmpty()
+    public fun getAnonymousInitializers(): List<KtClassInitializer> = getBody()?.getAnonymousInitializers().orEmpty()
 
-    public fun getNameAsDeclaration(): JetObjectDeclarationName? =
-            findChildByType<PsiElement>(JetNodeTypes.OBJECT_DECLARATION_NAME) as JetObjectDeclarationName?
+    public fun getNameAsDeclaration(): KtObjectDeclarationName? =
+            findChildByType<PsiElement>(KtNodeTypes.OBJECT_DECLARATION_NAME) as KtObjectDeclarationName?
 
-    public fun getBody(): JetClassBody? = getStubOrPsiChild(JetStubElementTypes.CLASS_BODY)
+    public fun getBody(): KtClassBody? = getStubOrPsiChild(KtStubElementTypes.CLASS_BODY)
 
-    public fun getOrCreateBody(): JetClassBody = getBody() ?: add(JetPsiFactory(this).createEmptyClassBody()) as JetClassBody
+    public fun getOrCreateBody(): KtClassBody = getBody() ?: add(KtPsiFactory(this).createEmptyClassBody()) as KtClassBody
 
-    public fun addDeclaration(declaration: JetDeclaration): JetDeclaration {
+    public fun addDeclaration(declaration: KtDeclaration): KtDeclaration {
         val body = getOrCreateBody()
         val anchor = PsiTreeUtil.skipSiblingsBackward(body.getRBrace() ?: body.getLastChild()!!, javaClass<PsiWhiteSpace>())
-        return body.addAfter(declaration, anchor) as JetDeclaration
+        return body.addAfter(declaration, anchor) as KtDeclaration
     }
 
-    public fun addDeclarationAfter(declaration: JetDeclaration, anchor: PsiElement?): JetDeclaration {
+    public fun addDeclarationAfter(declaration: KtDeclaration, anchor: PsiElement?): KtDeclaration {
         val anchorBefore = anchor ?: getDeclarations().lastOrNull() ?: return addDeclaration(declaration)
-        return getOrCreateBody().addAfter(declaration, anchorBefore) as JetDeclaration
+        return getOrCreateBody().addAfter(declaration, anchorBefore) as KtDeclaration
     }
 
-    public fun addDeclarationBefore(declaration: JetDeclaration, anchor: PsiElement?): JetDeclaration {
+    public fun addDeclarationBefore(declaration: KtDeclaration, anchor: PsiElement?): KtDeclaration {
         val anchorAfter = anchor ?: getDeclarations().firstOrNull() ?: return addDeclaration(declaration)
-        return getOrCreateBody().addBefore(declaration, anchorAfter) as JetDeclaration
+        return getOrCreateBody().addBefore(declaration, anchorAfter) as KtDeclaration
     }
 
-    public fun isTopLevel(): Boolean = getStub()?.isTopLevel() ?: (getParent() is JetFile)
+    public fun isTopLevel(): Boolean = getStub()?.isTopLevel() ?: (getParent() is KtFile)
 
-    public fun isLocal(): Boolean = getStub()?.isLocal() ?: JetPsiUtil.isLocal(this)
+    public fun isLocal(): Boolean = getStub()?.isLocal() ?: KtPsiUtil.isLocal(this)
     
     override fun getDeclarations() = getBody()?.getDeclarations().orEmpty()
 
     override fun getPresentation(): ItemPresentation? = ItemPresentationProviders.getItemPresentation(this)
 
-    public fun getPrimaryConstructor(): JetPrimaryConstructor? = getStubOrPsiChild(JetStubElementTypes.PRIMARY_CONSTRUCTOR)
+    public fun getPrimaryConstructor(): KtPrimaryConstructor? = getStubOrPsiChild(KtStubElementTypes.PRIMARY_CONSTRUCTOR)
 
-    public fun getPrimaryConstructorModifierList(): JetModifierList? = getPrimaryConstructor()?.getModifierList()
-    public fun getPrimaryConstructorParameterList(): JetParameterList? = getPrimaryConstructor()?.getValueParameterList()
-    public fun getPrimaryConstructorParameters(): List<JetParameter> = getPrimaryConstructorParameterList()?.getParameters().orEmpty()
+    public fun getPrimaryConstructorModifierList(): KtModifierList? = getPrimaryConstructor()?.getModifierList()
+    public fun getPrimaryConstructorParameterList(): KtParameterList? = getPrimaryConstructor()?.getValueParameterList()
+    public fun getPrimaryConstructorParameters(): List<KtParameter> = getPrimaryConstructorParameterList()?.getParameters().orEmpty()
 
     public fun hasExplicitPrimaryConstructor(): Boolean = getPrimaryConstructor() != null
 
     public fun hasPrimaryConstructor(): Boolean = hasExplicitPrimaryConstructor() || !hasSecondaryConstructors()
     private fun hasSecondaryConstructors(): Boolean = !getSecondaryConstructors().isEmpty()
 
-    public fun getSecondaryConstructors(): List<JetSecondaryConstructor> = getBody()?.getSecondaryConstructors().orEmpty()
+    public fun getSecondaryConstructors(): List<KtSecondaryConstructor> = getBody()?.getSecondaryConstructors().orEmpty()
 
-    public fun isAnnotation(): Boolean = hasModifier(JetTokens.ANNOTATION_KEYWORD)
+    public fun isAnnotation(): Boolean = hasModifier(KtTokens.ANNOTATION_KEYWORD)
 
     public override fun delete() {
         CheckUtil.checkWritable(this);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetCodeFragment.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtCodeFragment.kt
similarity index 80%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetCodeFragment.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtCodeFragment.kt
index 0e6935e49e0..0871d17fc1b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetCodeFragment.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtCodeFragment.kt
@@ -24,21 +24,21 @@ import com.intellij.psi.impl.source.tree.FileElement
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.tree.IElementType
 import com.intellij.testFramework.LightVirtualFile
-import org.jetbrains.kotlin.idea.JetFileType
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.idea.KotlinFileType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.addToStdlib.check
 import java.util.*
 
-public abstract class JetCodeFragment(
+public abstract class KtCodeFragment(
         private val _project: Project,
         name: String,
         text: CharSequence,
         imports: String?, // Should be separated by JetCodeFragment.IMPORT_SEPARATOR
         elementType: IElementType,
         private val context: PsiElement?
-): JetFile((PsiManager.getInstance(_project) as PsiManagerEx).getFileManager().createFileViewProvider(LightVirtualFile(name, JetFileType.INSTANCE, text), true), false), JavaCodeFragment {
+): KtFile((PsiManager.getInstance(_project) as PsiManagerEx).getFileManager().createFileViewProvider(LightVirtualFile(name, KotlinFileType.INSTANCE, text), true), false), JavaCodeFragment {
 
-    private var viewProvider = super<JetFile>.getViewProvider() as SingleRootFileViewProvider
+    private var viewProvider = super<KtFile>.getViewProvider() as SingleRootFileViewProvider
     private var myImports = LinkedHashSet<String>()
     private val additionalContextForLambda: PsiElement? by lazy {
         this.getCopyableUserData(ADDITIONAL_CONTEXT_FOR_LAMBDA)?.invoke()
@@ -57,7 +57,7 @@ public abstract class JetCodeFragment(
     private var superType: PsiType? = null
     private var exceptionHandler: JavaCodeFragment.ExceptionHandler? = null
 
-    public abstract fun getContentElement(): JetElement?
+    public abstract fun getContentElement(): KtElement?
 
     override fun forceResolveScope(scope: GlobalSearchScope?) {
         resolveScope = scope
@@ -71,13 +71,13 @@ public abstract class JetCodeFragment(
 
     override fun getContext() = additionalContextForLambda ?: context
 
-    override fun getResolveScope() = context?.getResolveScope() ?: super<JetFile>.getResolveScope()
+    override fun getResolveScope() = context?.getResolveScope() ?: super<KtFile>.getResolveScope()
 
-    override fun clone(): JetCodeFragment {
-        val clone = cloneImpl(calcTreeElement().clone() as FileElement) as JetCodeFragment
+    override fun clone(): KtCodeFragment {
+        val clone = cloneImpl(calcTreeElement().clone() as FileElement) as KtCodeFragment
         clone.setOriginalFile(this)
         clone.myImports = myImports
-        clone.viewProvider = SingleRootFileViewProvider(PsiManager.getInstance(_project), LightVirtualFile(getName(), JetFileType.INSTANCE, getText()), true)
+        clone.viewProvider = SingleRootFileViewProvider(PsiManager.getInstance(_project), LightVirtualFile(getName(), KotlinFileType.INSTANCE, getText()), true)
         clone.viewProvider.forceCachedPsi(clone)
         return clone
     }
@@ -105,8 +105,8 @@ public abstract class JetCodeFragment(
         myImports.addAll(imports.split(IMPORT_SEPARATOR))
     }
 
-    public fun importsAsImportList(): JetImportList? {
-        return JetPsiFactory(this).createFile(myImports.join("\n")).getImportList()
+    public fun importsAsImportList(): KtImportList? {
+        return KtPsiFactory(this).createFile(myImports.join("\n")).getImportList()
     }
 
     override fun setVisibilityChecker(checker: JavaCodeFragment.VisibilityChecker?) { }
@@ -131,7 +131,7 @@ public abstract class JetCodeFragment(
 
     companion object {
         public val IMPORT_SEPARATOR: String = ","
-        public val RUNTIME_TYPE_EVALUATOR: Key<Function1<JetExpression, JetType?>> = Key.create("RUNTIME_TYPE_EVALUATOR")
-        public val ADDITIONAL_CONTEXT_FOR_LAMBDA: Key<Function0<JetElement?>> = Key.create("ADDITIONAL_CONTEXT_FOR_LAMBDA")
+        public val RUNTIME_TYPE_EVALUATOR: Key<Function1<KtExpression, KtType?>> = Key.create("RUNTIME_TYPE_EVALUATOR")
+        public val ADDITIONAL_CONTEXT_FOR_LAMBDA: Key<Function0<KtElement?>> = Key.create("ADDITIONAL_CONTEXT_FOR_LAMBDA")
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstantExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstantExpression.java
similarity index 81%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstantExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstantExpression.java
index dc38c150b11..e6bc0c6b19e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstantExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstantExpression.java
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 
-public class JetConstantExpression extends JetExpressionImpl {
-    public JetConstantExpression(@NotNull ASTNode node) {
+public class KtConstantExpression extends KtExpressionImpl {
+    public KtConstantExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitConstantExpression(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructor.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstructor.kt
similarity index 68%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructor.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstructor.kt
index 70194003328..8758bfbb053 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructor.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstructor.kt
@@ -21,21 +21,20 @@ import com.intellij.navigation.ItemPresentationProviders
 import com.intellij.psi.PsiElement
 import com.intellij.psi.search.SearchScope
 import com.intellij.util.IncorrectOperationException
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetPlaceHolderStubElementType
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtPlaceHolderStubElementType
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 
-public abstract class JetConstructor<T : JetConstructor<T>> : JetDeclarationStub<KotlinPlaceHolderStub<T>>, JetFunction {
+public abstract class KtConstructor<T : KtConstructor<T>> : KtDeclarationStub<KotlinPlaceHolderStub<T>>, KtFunction {
     protected constructor(node: ASTNode) : super(node)
-    protected constructor(stub: KotlinPlaceHolderStub<T>, nodeType: JetPlaceHolderStubElementType<T>) : super(stub, nodeType)
+    protected constructor(stub: KotlinPlaceHolderStub<T>, nodeType: KtPlaceHolderStubElementType<T>) : super(stub, nodeType)
 
-    public abstract fun getContainingClassOrObject(): JetClassOrObject
+    public abstract fun getContainingClassOrObject(): KtClassOrObject
 
     override fun isLocal() = false
 
-    override fun getValueParameterList() = getStubOrPsiChild(JetStubElementTypes.VALUE_PARAMETER_LIST)
+    override fun getValueParameterList() = getStubOrPsiChild(KtStubElementTypes.VALUE_PARAMETER_LIST)
 
     override fun getValueParameters() = getValueParameterList()?.getParameters() ?: emptyList()
 
@@ -44,11 +43,11 @@ public abstract class JetConstructor<T : JetConstructor<T>> : JetDeclarationStub
     override fun getTypeReference() = null
 
     @Throws(IncorrectOperationException::class)
-    override fun setTypeReference(typeRef: JetTypeReference?) = throw IncorrectOperationException("setTypeReference to constructor")
+    override fun setTypeReference(typeRef: KtTypeReference?) = throw IncorrectOperationException("setTypeReference to constructor")
 
-    override fun getColon() = findChildByType<PsiElement>(JetTokens.COLON)
+    override fun getColon() = findChildByType<PsiElement>(KtTokens.COLON)
 
-    override fun getBodyExpression(): JetBlockExpression? = null
+    override fun getBodyExpression(): KtBlockExpression? = null
 
     override fun getEqualsToken() = null
 
@@ -62,13 +61,13 @@ public abstract class JetConstructor<T : JetConstructor<T>> : JetDeclarationStub
 
     override fun getTypeConstraintList() = null
 
-    override fun getTypeConstraints() = emptyList<JetTypeConstraint>()
+    override fun getTypeConstraints() = emptyList<KtTypeConstraint>()
 
-    override fun getTypeParameters() = emptyList<JetTypeParameter>()
+    override fun getTypeParameters() = emptyList<KtTypeParameter>()
 
     override fun getName(): String? = getContainingClassOrObject().getName()
 
-    override fun getNameAsSafeName() = JetPsiUtil.safeName(getName())
+    override fun getNameAsSafeName() = KtPsiUtil.safeName(getName())
 
     override fun getFqName() = null
 
@@ -81,14 +80,14 @@ public abstract class JetConstructor<T : JetConstructor<T>> : JetDeclarationStub
 
     override fun getPresentation() = ItemPresentationProviders.getItemPresentation(this)
 
-    public open fun getConstructorKeyword(): PsiElement? = findChildByType(JetTokens.CONSTRUCTOR_KEYWORD)
+    public open fun getConstructorKeyword(): PsiElement? = findChildByType(KtTokens.CONSTRUCTOR_KEYWORD)
 
     public fun hasConstructorKeyword(): Boolean = getStub() != null || getConstructorKeyword() != null
 
     override fun getTextOffset(): Int {
         return getConstructorKeyword()?.getTextOffset()
                ?: getValueParameterList()?.getTextOffset()
-               ?: super<JetDeclarationStub>.getTextOffset()
+               ?: super<KtDeclarationStub>.getTextOffset()
     }
 
     override fun getUseScope(): SearchScope {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructorCalleeExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstructorCalleeExpression.java
similarity index 53%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructorCalleeExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstructorCalleeExpression.java
index 11c923ac85d..6ed2def78a1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructorCalleeExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstructorCalleeExpression.java
@@ -20,38 +20,38 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
-public class JetConstructorCalleeExpression extends JetExpressionImplStub<KotlinPlaceHolderStub<JetConstructorCalleeExpression>> {
-    public JetConstructorCalleeExpression(@NotNull ASTNode node) {
+public class KtConstructorCalleeExpression extends KtExpressionImplStub<KotlinPlaceHolderStub<KtConstructorCalleeExpression>> {
+    public KtConstructorCalleeExpression(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetConstructorCalleeExpression(@NotNull KotlinPlaceHolderStub<JetConstructorCalleeExpression> stub) {
-        super(stub, JetStubElementTypes.CONSTRUCTOR_CALLEE);
+    public KtConstructorCalleeExpression(@NotNull KotlinPlaceHolderStub<KtConstructorCalleeExpression> stub) {
+        super(stub, KtStubElementTypes.CONSTRUCTOR_CALLEE);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitConstructorCalleeExpression(this, data);
     }
 
     @Nullable @IfNotParsed
-    public JetTypeReference getTypeReference() {
-        return getStubOrPsiChild(JetStubElementTypes.TYPE_REFERENCE);
+    public KtTypeReference getTypeReference() {
+        return getStubOrPsiChild(KtStubElementTypes.TYPE_REFERENCE);
     }
 
     @Nullable @IfNotParsed
-    public JetSimpleNameExpression getConstructorReferenceExpression() {
-        JetTypeReference typeReference = getTypeReference();
+    public KtSimpleNameExpression getConstructorReferenceExpression() {
+        KtTypeReference typeReference = getTypeReference();
         if (typeReference == null) {
             return null;
         }
-        JetTypeElement typeElement = typeReference.getTypeElement();
-        if (!(typeElement instanceof JetUserType)) {
+        KtTypeElement typeElement = typeReference.getTypeElement();
+        if (!(typeElement instanceof KtUserType)) {
             return null;
         }
-        return ((JetUserType) typeElement).getReferenceExpression();
+        return ((KtUserType) typeElement).getReferenceExpression();
     }
 
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructorDelegationCall.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstructorDelegationCall.java
similarity index 60%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructorDelegationCall.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstructorDelegationCall.java
index 68dbb36cb16..0f06533565e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructorDelegationCall.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstructorDelegationCall.java
@@ -19,59 +19,59 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetConstructorDelegationCall extends JetElementImpl implements JetCallElement {
-    public JetConstructorDelegationCall(@NotNull ASTNode node) {
+public class KtConstructorDelegationCall extends KtElementImpl implements KtCallElement {
+    public KtConstructorDelegationCall(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
     @Nullable
-    public JetValueArgumentList getValueArgumentList() {
-        return (JetValueArgumentList) findChildByType(JetNodeTypes.VALUE_ARGUMENT_LIST);
+    public KtValueArgumentList getValueArgumentList() {
+        return (KtValueArgumentList) findChildByType(KtNodeTypes.VALUE_ARGUMENT_LIST);
     }
 
     @Override
     @NotNull
     public List<? extends ValueArgument> getValueArguments() {
-        JetValueArgumentList list = getValueArgumentList();
-        return list != null ? list.getArguments() : Collections.<JetValueArgument>emptyList();
+        KtValueArgumentList list = getValueArgumentList();
+        return list != null ? list.getArguments() : Collections.<KtValueArgument>emptyList();
     }
 
     @NotNull
     @Override
-    public List<JetFunctionLiteralArgument> getFunctionLiteralArguments() {
+    public List<KtFunctionLiteralArgument> getFunctionLiteralArguments() {
         return Collections.emptyList();
     }
 
     @NotNull
     @Override
-    public List<JetTypeProjection> getTypeArguments() {
+    public List<KtTypeProjection> getTypeArguments() {
         return Collections.emptyList();
     }
 
     @Override
-    public JetTypeArgumentList getTypeArgumentList() {
+    public KtTypeArgumentList getTypeArgumentList() {
         return null;
     }
 
     @Nullable
     @Override
-    public JetConstructorDelegationReferenceExpression getCalleeExpression() {
-        return findChildByClass(JetConstructorDelegationReferenceExpression.class);
+    public KtConstructorDelegationReferenceExpression getCalleeExpression() {
+        return findChildByClass(KtConstructorDelegationReferenceExpression.class);
     }
 
     public boolean isImplicit() {
-        JetConstructorDelegationReferenceExpression callee = getCalleeExpression();
+        KtConstructorDelegationReferenceExpression callee = getCalleeExpression();
         return callee != null && callee.getFirstChild() == null;
     }
 
     public boolean isCallToThis() {
-        JetConstructorDelegationReferenceExpression callee = getCalleeExpression();
+        KtConstructorDelegationReferenceExpression callee = getCalleeExpression();
         return callee != null && callee.isThis();
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructorDelegationReferenceExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstructorDelegationReferenceExpression.java
similarity index 71%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructorDelegationReferenceExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstructorDelegationReferenceExpression.java
index 0822cbd086d..a8b772b13e4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructorDelegationReferenceExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtConstructorDelegationReferenceExpression.java
@@ -18,14 +18,14 @@ package org.jetbrains.kotlin.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-public class JetConstructorDelegationReferenceExpression extends JetExpressionImpl implements JetReferenceExpression {
-    public JetConstructorDelegationReferenceExpression(@NotNull ASTNode node) {
+public class KtConstructorDelegationReferenceExpression extends KtExpressionImpl implements KtReferenceExpression {
+    public KtConstructorDelegationReferenceExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     public boolean isThis() {
-        return findChildByType(JetTokens.THIS_KEYWORD) != null;
+        return findChildByType(KtTokens.THIS_KEYWORD) != null;
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetContainerNode.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtContainerNode.java
similarity index 91%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetContainerNode.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtContainerNode.java
index 47aa286397f..0f1aa81cb29 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetContainerNode.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtContainerNode.java
@@ -21,8 +21,8 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 
-public class JetContainerNode extends JetElementImpl {
-    public JetContainerNode(@NotNull ASTNode node) {
+public class KtContainerNode extends KtElementImpl {
+    public KtContainerNode(@NotNull ASTNode node) {
         super(node);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetContinueExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtContinueExpression.java
similarity index 78%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetContinueExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtContinueExpression.java
index 36f8b320541..706f1cf5889 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetContinueExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtContinueExpression.java
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 
-public class JetContinueExpression extends JetExpressionWithLabel implements JetStatementExpression {
-    public JetContinueExpression(@NotNull ASTNode node) {
+public class KtContinueExpression extends KtExpressionWithLabel implements KtStatementExpression {
+    public KtContinueExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitContinueExpression(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclaration.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclaration.java
similarity index 72%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclaration.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclaration.java
index ef26811f345..278b0743590 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclaration.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclaration.java
@@ -21,14 +21,14 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.kdoc.psi.api.KDoc;
 
-public interface JetDeclaration extends JetExpression, JetModifierListOwner {
-    JetDeclaration[] EMPTY_ARRAY = new JetDeclaration[0];
+public interface KtDeclaration extends KtExpression, KtModifierListOwner {
+    KtDeclaration[] EMPTY_ARRAY = new KtDeclaration[0];
 
-    ArrayFactory<JetDeclaration> ARRAY_FACTORY = new ArrayFactory<JetDeclaration>() {
+    ArrayFactory<KtDeclaration> ARRAY_FACTORY = new ArrayFactory<KtDeclaration>() {
         @NotNull
         @Override
-        public JetDeclaration[] create(int count) {
-            return count == 0 ? EMPTY_ARRAY : new JetDeclaration[count];
+        public KtDeclaration[] create(int count) {
+            return count == 0 ? EMPTY_ARRAY : new KtDeclaration[count];
         }
     };
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationContainer.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationContainer.java
similarity index 89%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationContainer.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationContainer.java
index c63728b5a30..ee5639844d5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationContainer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationContainer.java
@@ -21,8 +21,8 @@ import org.jetbrains.annotations.ReadOnly;
 
 import java.util.List;
 
-public interface JetDeclarationContainer {
+public interface KtDeclarationContainer {
     @NotNull
     @ReadOnly
-    List<JetDeclaration> getDeclarations();
+    List<KtDeclaration> getDeclarations();
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationImpl.java
similarity index 65%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationImpl.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationImpl.java
index fdb0b6b60a5..0768a81eb81 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationImpl.java
@@ -19,60 +19,60 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 import org.jetbrains.kotlin.kdoc.psi.api.KDoc;
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken;
 import org.jetbrains.kotlin.psi.addRemoveModifier.AddRemoveModifierKt;
 import org.jetbrains.kotlin.psi.findDocComment.FindDocCommentKt;
 
 import java.util.Collections;
 import java.util.List;
 
-abstract class JetDeclarationImpl extends JetExpressionImpl implements JetDeclaration {
-    public JetDeclarationImpl(@NotNull ASTNode node) {
+abstract class KtDeclarationImpl extends KtExpressionImpl implements KtDeclaration {
+    public KtDeclarationImpl(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
     @Nullable
-    public JetModifierList getModifierList() {
-        return (JetModifierList) findChildByType(JetNodeTypes.MODIFIER_LIST);
+    public KtModifierList getModifierList() {
+        return (KtModifierList) findChildByType(KtNodeTypes.MODIFIER_LIST);
     }
 
     @Override
-    public boolean hasModifier(@NotNull JetModifierKeywordToken modifier) {
-        JetModifierList modifierList = getModifierList();
+    public boolean hasModifier(@NotNull KtModifierKeywordToken modifier) {
+        KtModifierList modifierList = getModifierList();
         return modifierList != null && modifierList.hasModifier(modifier);
     }
 
     @Override
-    public void addModifier(@NotNull JetModifierKeywordToken modifier) {
+    public void addModifier(@NotNull KtModifierKeywordToken modifier) {
         AddRemoveModifierKt.addModifier(this, modifier);
     }
 
     @Override
-    public void removeModifier(@NotNull JetModifierKeywordToken modifier) {
+    public void removeModifier(@NotNull KtModifierKeywordToken modifier) {
         AddRemoveModifierKt.removeModifier(this, modifier);
     }
 
     @NotNull
     @Override
-    public JetAnnotationEntry addAnnotationEntry(@NotNull JetAnnotationEntry annotationEntry) {
+    public KtAnnotationEntry addAnnotationEntry(@NotNull KtAnnotationEntry annotationEntry) {
         return AddRemoveModifierKt.addAnnotationEntry(this, annotationEntry);
     }
 
     @NotNull
     @Override
-    public List<JetAnnotationEntry> getAnnotationEntries() {
-        JetModifierList modifierList = getModifierList();
+    public List<KtAnnotationEntry> getAnnotationEntries() {
+        KtModifierList modifierList = getModifierList();
         if (modifierList == null) return Collections.emptyList();
         return modifierList.getAnnotationEntries();
     }
 
     @NotNull
     @Override
-    public List<JetAnnotation> getAnnotations() {
-        JetModifierList modifierList = getModifierList();
+    public List<KtAnnotation> getAnnotations() {
+        KtModifierList modifierList = getModifierList();
         if (modifierList == null) return Collections.emptyList();
         return modifierList.getAnnotations();
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationModifierList.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationModifierList.java
similarity index 71%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationModifierList.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationModifierList.java
index 0439550387d..41bb866132e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationModifierList.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationModifierList.java
@@ -19,14 +19,14 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.stubs.KotlinModifierListStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
-public class JetDeclarationModifierList extends JetModifierList {
-    public JetDeclarationModifierList(@NotNull ASTNode node) {
+public class KtDeclarationModifierList extends KtModifierList {
+    public KtDeclarationModifierList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetDeclarationModifierList(@NotNull KotlinModifierListStub stub) {
-        super(stub, JetStubElementTypes.MODIFIER_LIST);
+    public KtDeclarationModifierList(@NotNull KotlinModifierListStub stub) {
+        super(stub, KtStubElementTypes.MODIFIER_LIST);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationStub.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationStub.java
similarity index 90%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationStub.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationStub.java
index 140162bfdef..d50a8bb7f5b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationStub.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationStub.java
@@ -27,14 +27,14 @@ import org.jetbrains.kotlin.kdoc.psi.api.KDoc;
 import org.jetbrains.kotlin.psi.findDocComment.FindDocCommentKt;
 import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub;
 
-abstract class JetDeclarationStub<T extends StubElement<?>> extends JetModifierListOwnerStub<T> implements JetDeclaration {
+abstract class KtDeclarationStub<T extends StubElement<?>> extends KtModifierListOwnerStub<T> implements KtDeclaration {
     private long modificationStamp = 0;
 
-    public JetDeclarationStub(@NotNull T stub, @NotNull IStubElementType nodeType) {
+    public KtDeclarationStub(@NotNull T stub, @NotNull IStubElementType nodeType) {
         super(stub, nodeType);
     }
 
-    public JetDeclarationStub(@NotNull ASTNode node) {
+    public KtDeclarationStub(@NotNull ASTNode node) {
         super(node);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationWithBody.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationWithBody.java
similarity index 87%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationWithBody.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationWithBody.java
index 08e2781248d..85d4e138d8e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDeclarationWithBody.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDeclarationWithBody.java
@@ -22,9 +22,9 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-public interface JetDeclarationWithBody extends JetDeclaration {
+public interface KtDeclarationWithBody extends KtDeclaration {
     @Nullable
-    JetExpression getBodyExpression();
+    KtExpression getBodyExpression();
 
     @Nullable
     PsiElement getEqualsToken();
@@ -40,6 +40,6 @@ public interface JetDeclarationWithBody extends JetDeclaration {
     boolean hasDeclaredReturnType();
 
     @NotNull
-    List<JetParameter> getValueParameters();
+    List<KtParameter> getValueParameters();
 }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegationSpecifier.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegationSpecifier.java
similarity index 52%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegationSpecifier.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegationSpecifier.java
index 585adeb8f8c..747a2b7a8cd 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegationSpecifier.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegationSpecifier.java
@@ -22,47 +22,47 @@ import com.intellij.util.ArrayFactory;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
-public class JetDelegationSpecifier extends JetElementImplStub<KotlinPlaceHolderStub<? extends JetDelegationSpecifier>> {
+public class KtDelegationSpecifier extends KtElementImplStub<KotlinPlaceHolderStub<? extends KtDelegationSpecifier>> {
 
-    private static final JetDelegationSpecifier[] EMPTY_ARRAY = new JetDelegationSpecifier[0];
+    private static final KtDelegationSpecifier[] EMPTY_ARRAY = new KtDelegationSpecifier[0];
 
-    public static ArrayFactory<JetDelegationSpecifier> ARRAY_FACTORY = new ArrayFactory<JetDelegationSpecifier>() {
+    public static ArrayFactory<KtDelegationSpecifier> ARRAY_FACTORY = new ArrayFactory<KtDelegationSpecifier>() {
         @NotNull
         @Override
-        public JetDelegationSpecifier[] create(int count) {
-            return count == 0 ? EMPTY_ARRAY : new JetDelegationSpecifier[count];
+        public KtDelegationSpecifier[] create(int count) {
+            return count == 0 ? EMPTY_ARRAY : new KtDelegationSpecifier[count];
         }
     };
 
-    public JetDelegationSpecifier(@NotNull ASTNode node) {
+    public KtDelegationSpecifier(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetDelegationSpecifier(
-            @NotNull KotlinPlaceHolderStub<? extends JetDelegationSpecifier> stub,
+    public KtDelegationSpecifier(
+            @NotNull KotlinPlaceHolderStub<? extends KtDelegationSpecifier> stub,
             @NotNull IStubElementType nodeType) {
         super(stub, nodeType);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitDelegationSpecifier(this, data);
     }
 
     @Nullable
-    public JetTypeReference getTypeReference() {
-        return getStubOrPsiChild(JetStubElementTypes.TYPE_REFERENCE);
+    public KtTypeReference getTypeReference() {
+        return getStubOrPsiChild(KtStubElementTypes.TYPE_REFERENCE);
     }
 
     @Nullable
-    public JetUserType getTypeAsUserType() {
-        JetTypeReference reference = getTypeReference();
+    public KtUserType getTypeAsUserType() {
+        KtTypeReference reference = getTypeReference();
         if (reference != null) {
-            JetTypeElement element = reference.getTypeElement();
-            if (element instanceof JetUserType) {
-                return ((JetUserType) element);
+            KtTypeElement element = reference.getTypeElement();
+            if (element instanceof KtUserType) {
+                return ((KtUserType) element);
             }
         }
         return null;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegationSpecifierList.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegationSpecifierList.java
similarity index 57%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegationSpecifierList.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegationSpecifierList.java
index b3c9ece5d81..86b5e708f86 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegationSpecifierList.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegationSpecifierList.java
@@ -19,26 +19,26 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.Arrays;
 import java.util.List;
 
-public class JetDelegationSpecifierList extends JetElementImplStub<KotlinPlaceHolderStub<JetDelegationSpecifierList>> {
-    public JetDelegationSpecifierList(@NotNull ASTNode node) {
+public class KtDelegationSpecifierList extends KtElementImplStub<KotlinPlaceHolderStub<KtDelegationSpecifierList>> {
+    public KtDelegationSpecifierList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetDelegationSpecifierList(@NotNull KotlinPlaceHolderStub<JetDelegationSpecifierList> stub) {
-        super(stub, JetStubElementTypes.DELEGATION_SPECIFIER_LIST);
+    public KtDelegationSpecifierList(@NotNull KotlinPlaceHolderStub<KtDelegationSpecifierList> stub) {
+        super(stub, KtStubElementTypes.DELEGATION_SPECIFIER_LIST);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitDelegationSpecifierList(this, data);
     }
 
-    public List<JetDelegationSpecifier> getDelegationSpecifiers() {
-        return Arrays.asList(getStubOrPsiChildren(JetStubElementTypes.DELEGATION_SPECIFIER_TYPES, JetDelegationSpecifier.ARRAY_FACTORY));
+    public List<KtDelegationSpecifier> getDelegationSpecifiers() {
+        return Arrays.asList(getStubOrPsiChildren(KtStubElementTypes.DELEGATION_SPECIFIER_TYPES, KtDelegationSpecifier.ARRAY_FACTORY));
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegatorByExpressionSpecifier.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegatorByExpressionSpecifier.java
similarity index 63%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegatorByExpressionSpecifier.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegatorByExpressionSpecifier.java
index 7e66646324c..5315b65841c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegatorByExpressionSpecifier.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegatorByExpressionSpecifier.java
@@ -20,24 +20,24 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
-public class JetDelegatorByExpressionSpecifier extends JetDelegationSpecifier {
-    public JetDelegatorByExpressionSpecifier(@NotNull ASTNode node) {
+public class KtDelegatorByExpressionSpecifier extends KtDelegationSpecifier {
+    public KtDelegatorByExpressionSpecifier(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetDelegatorByExpressionSpecifier(@NotNull KotlinPlaceHolderStub<? extends JetDelegationSpecifier> stub) {
-        super(stub, JetStubElementTypes.DELEGATOR_BY);
+    public KtDelegatorByExpressionSpecifier(@NotNull KotlinPlaceHolderStub<? extends KtDelegationSpecifier> stub) {
+        super(stub, KtStubElementTypes.DELEGATOR_BY);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitDelegationByExpressionSpecifier(this, data);
     }
 
     @Nullable @IfNotParsed
-    public JetExpression getDelegateExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getDelegateExpression() {
+        return findChildByClass(KtExpression.class);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegatorToSuperCall.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegatorToSuperCall.java
similarity index 56%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegatorToSuperCall.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegatorToSuperCall.java
index a960d9bb921..fa9cde1c2fe 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegatorToSuperCall.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegatorToSuperCall.java
@@ -19,61 +19,61 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetDelegatorToSuperCall extends JetDelegationSpecifier implements JetCallElement {
-    public JetDelegatorToSuperCall(@NotNull ASTNode node) {
+public class KtDelegatorToSuperCall extends KtDelegationSpecifier implements KtCallElement {
+    public KtDelegatorToSuperCall(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetDelegatorToSuperCall(@NotNull KotlinPlaceHolderStub<? extends JetDelegationSpecifier> stub) {
-        super(stub, JetStubElementTypes.DELEGATOR_SUPER_CALL);
+    public KtDelegatorToSuperCall(@NotNull KotlinPlaceHolderStub<? extends KtDelegationSpecifier> stub) {
+        super(stub, KtStubElementTypes.DELEGATOR_SUPER_CALL);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitDelegationToSuperCallSpecifier(this, data);
     }
 
     @NotNull
     @Override
-    public JetConstructorCalleeExpression getCalleeExpression() {
-        return getRequiredStubOrPsiChild(JetStubElementTypes.CONSTRUCTOR_CALLEE);
+    public KtConstructorCalleeExpression getCalleeExpression() {
+        return getRequiredStubOrPsiChild(KtStubElementTypes.CONSTRUCTOR_CALLEE);
     }
 
     @Override
     @Nullable
-    public JetValueArgumentList getValueArgumentList() {
-        return (JetValueArgumentList) findChildByType(JetNodeTypes.VALUE_ARGUMENT_LIST);
+    public KtValueArgumentList getValueArgumentList() {
+        return (KtValueArgumentList) findChildByType(KtNodeTypes.VALUE_ARGUMENT_LIST);
     }
 
     @Override
     @NotNull
     public List<? extends ValueArgument> getValueArguments() {
-        JetValueArgumentList list = getValueArgumentList();
-        return list != null ? list.getArguments() : Collections.<JetValueArgument>emptyList();
+        KtValueArgumentList list = getValueArgumentList();
+        return list != null ? list.getArguments() : Collections.<KtValueArgument>emptyList();
     }
 
     @NotNull
     @Override
-    public List<JetFunctionLiteralArgument> getFunctionLiteralArguments() {
+    public List<KtFunctionLiteralArgument> getFunctionLiteralArguments() {
         return Collections.emptyList();
     }
 
     @Override
-    public JetTypeReference getTypeReference() {
+    public KtTypeReference getTypeReference() {
         return getCalleeExpression().getTypeReference();
     }
 
     @NotNull
     @Override
-    public List<JetTypeProjection> getTypeArguments() {
-        JetTypeArgumentList typeArgumentList = getTypeArgumentList();
+    public List<KtTypeProjection> getTypeArguments() {
+        KtTypeArgumentList typeArgumentList = getTypeArgumentList();
         if (typeArgumentList == null) {
             return Collections.emptyList();
         }
@@ -81,8 +81,8 @@ public class JetDelegatorToSuperCall extends JetDelegationSpecifier implements J
     }
 
     @Override
-    public JetTypeArgumentList getTypeArgumentList() {
-        JetUserType userType = getTypeAsUserType();
+    public KtTypeArgumentList getTypeArgumentList() {
+        KtUserType userType = getTypeAsUserType();
         return userType != null ? userType.getTypeArgumentList() : null;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegatorToSuperClass.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegatorToSuperClass.java
similarity index 67%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegatorToSuperClass.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegatorToSuperClass.java
index 45b85312368..0ff5e003965 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDelegatorToSuperClass.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDelegatorToSuperClass.java
@@ -19,19 +19,19 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
-public class JetDelegatorToSuperClass extends JetDelegationSpecifier {
-    public JetDelegatorToSuperClass(@NotNull ASTNode node) {
+public class KtDelegatorToSuperClass extends KtDelegationSpecifier {
+    public KtDelegatorToSuperClass(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetDelegatorToSuperClass(@NotNull KotlinPlaceHolderStub<? extends JetDelegationSpecifier> stub) {
-        super(stub, JetStubElementTypes.DELEGATOR_SUPER_CLASS);
+    public KtDelegatorToSuperClass(@NotNull KotlinPlaceHolderStub<? extends KtDelegationSpecifier> stub) {
+        super(stub, KtStubElementTypes.DELEGATOR_SUPER_CLASS);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitDelegationToSuperClassSpecifier(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDoWhileExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDoWhileExpression.java
similarity index 77%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDoWhileExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDoWhileExpression.java
index acd412b5618..52fd24b880e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDoWhileExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDoWhileExpression.java
@@ -20,15 +20,15 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-public class JetDoWhileExpression extends JetWhileExpressionBase {
-    public JetDoWhileExpression(@NotNull ASTNode node) {
+public class KtDoWhileExpression extends KtWhileExpressionBase {
+    public KtDoWhileExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitDoWhileExpression(this, data);
     }
 
@@ -36,6 +36,6 @@ public class JetDoWhileExpression extends JetWhileExpressionBase {
     @IfNotParsed
     public PsiElement getWhileKeyword() {
         //noinspection ConstantConditions
-        return findChildByType(JetTokens.WHILE_KEYWORD);
+        return findChildByType(KtTokens.WHILE_KEYWORD);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDotQualifiedExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDotQualifiedExpression.java
similarity index 53%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDotQualifiedExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDotQualifiedExpression.java
index d87b47362ed..21c3761736e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDotQualifiedExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDotQualifiedExpression.java
@@ -20,67 +20,67 @@ import com.intellij.lang.ASTNode;
 import com.intellij.openapi.diagnostic.Logger;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetToken;
+import org.jetbrains.kotlin.lexer.KtToken;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
-import static org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes.INSIDE_DIRECTIVE_EXPRESSIONS;
+import static org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes.INSIDE_DIRECTIVE_EXPRESSIONS;
 
-public class JetDotQualifiedExpression extends JetExpressionImplStub<KotlinPlaceHolderStub<JetDotQualifiedExpression>>
-        implements JetQualifiedExpression {
+public class KtDotQualifiedExpression extends KtExpressionImplStub<KotlinPlaceHolderStub<KtDotQualifiedExpression>>
+        implements KtQualifiedExpression {
 
-    private static final Logger LOG = Logger.getInstance(JetDotQualifiedExpression.class);
+    private static final Logger LOG = Logger.getInstance(KtDotQualifiedExpression.class);
 
-    public JetDotQualifiedExpression(@NotNull ASTNode node) {
+    public KtDotQualifiedExpression(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetDotQualifiedExpression(@NotNull KotlinPlaceHolderStub<JetDotQualifiedExpression> stub) {
-        super(stub, JetStubElementTypes.DOT_QUALIFIED_EXPRESSION);
+    public KtDotQualifiedExpression(@NotNull KotlinPlaceHolderStub<KtDotQualifiedExpression> stub) {
+        super(stub, KtStubElementTypes.DOT_QUALIFIED_EXPRESSION);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitDotQualifiedExpression(this, data);
     }
 
     @NotNull
     @Override
-    public JetExpression getReceiverExpression() {
-        KotlinPlaceHolderStub<JetDotQualifiedExpression> stub = getStub();
+    public KtExpression getReceiverExpression() {
+        KotlinPlaceHolderStub<KtDotQualifiedExpression> stub = getStub();
         if (stub != null) {
-            JetExpression[] childExpressionsByStub = getChildExpressionsByStub(stub);
+            KtExpression[] childExpressionsByStub = getChildExpressionsByStub(stub);
             if (childExpressionsByStub != null) {
                 return childExpressionsByStub[0];
             }
         }
-        return JetQualifiedExpressionImpl.INSTANCE$.getReceiverExpression(this);
+        return KtQualifiedExpressionImpl.INSTANCE$.getReceiverExpression(this);
     }
 
     @Nullable
     @Override
-    public JetExpression getSelectorExpression() {
-        KotlinPlaceHolderStub<JetDotQualifiedExpression> stub = getStub();
+    public KtExpression getSelectorExpression() {
+        KotlinPlaceHolderStub<KtDotQualifiedExpression> stub = getStub();
         if (stub != null) {
-            JetExpression[] childExpressionsByStub = getChildExpressionsByStub(stub);
+            KtExpression[] childExpressionsByStub = getChildExpressionsByStub(stub);
             if (childExpressionsByStub != null && childExpressionsByStub.length == 2) {
                 return childExpressionsByStub[1];
             }
         }
-        return JetQualifiedExpressionImpl.INSTANCE$.getSelectorExpression(this);
+        return KtQualifiedExpressionImpl.INSTANCE$.getSelectorExpression(this);
     }
 
 
     @Nullable
-    private JetExpression[] getChildExpressionsByStub(@NotNull KotlinPlaceHolderStub<JetDotQualifiedExpression> stub) {
-        if (stub.getParentStubOfType(JetImportDirective.class) == null && stub.getParentStubOfType(JetPackageDirective.class) == null) {
+    private KtExpression[] getChildExpressionsByStub(@NotNull KotlinPlaceHolderStub<KtDotQualifiedExpression> stub) {
+        if (stub.getParentStubOfType(KtImportDirective.class) == null && stub.getParentStubOfType(KtPackageDirective.class) == null) {
             LOG.error("JetDotQualifiedExpression should only have stubs inside import or package directives.\n " +
                       "Stubs were created for:\n " + getText() +
                       "\nFile text:\n" + getContainingFile().getText());
             return null;
         }
         else {
-            JetExpression[] expressions = stub.getChildrenByType(INSIDE_DIRECTIVE_EXPRESSIONS, JetExpression.ARRAY_FACTORY);
+            KtExpression[] expressions = stub.getChildrenByType(INSIDE_DIRECTIVE_EXPRESSIONS, KtExpression.ARRAY_FACTORY);
             if (expressions.length < 1 || expressions.length > 2) {
                 LOG.error("Invalid stub structure. DOT_QUALIFIED_EXPRESSION must have one or two children. Was: " + expressions.length +
                           "\nFile text:\n" + getContainingFile().getText());
@@ -93,12 +93,12 @@ public class JetDotQualifiedExpression extends JetExpressionImplStub<KotlinPlace
     @NotNull
     @Override
     public ASTNode getOperationTokenNode() {
-        return JetQualifiedExpressionImpl.INSTANCE$.getOperationTokenNode(this);
+        return KtQualifiedExpressionImpl.INSTANCE$.getOperationTokenNode(this);
     }
 
     @NotNull
     @Override
-    public JetToken getOperationSign() {
-        return JetQualifiedExpressionImpl.INSTANCE$.getOperationSign(this);
+    public KtToken getOperationSign() {
+        return KtQualifiedExpressionImpl.INSTANCE$.getOperationSign(this);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDoubleColonExpression.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDoubleColonExpression.kt
similarity index 69%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDoubleColonExpression.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDoubleColonExpression.kt
index 80c70e028e9..9f462242efa 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDoubleColonExpression.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDoubleColonExpression.kt
@@ -18,17 +18,17 @@ package org.jetbrains.kotlin.psi
 
 import com.intellij.lang.ASTNode
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.JetNodeTypes
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.KtNodeTypes
+import org.jetbrains.kotlin.lexer.KtTokens
 
-public abstract class JetDoubleColonExpression(node: ASTNode) : JetExpressionImpl(node) {
-    public val typeReference: JetTypeReference?
-        get() = findChildByType(JetNodeTypes.TYPE_REFERENCE)
+public abstract class KtDoubleColonExpression(node: ASTNode) : KtExpressionImpl(node) {
+    public val typeReference: KtTypeReference?
+        get() = findChildByType(KtNodeTypes.TYPE_REFERENCE)
 
     public val doubleColonTokenReference: PsiElement
-        get() = findChildByType(JetTokens.COLONCOLON)!!
+        get() = findChildByType(KtTokens.COLONCOLON)!!
 
-    public fun setTypeReference(typeReference: JetTypeReference) {
+    public fun setTypeReference(typeReference: KtTypeReference) {
         val oldTypeReference = this.typeReference
         if (oldTypeReference != null) {
             oldTypeReference.replace(typeReference)
@@ -38,7 +38,7 @@ public abstract class JetDoubleColonExpression(node: ASTNode) : JetExpressionImp
         }
     }
 
-    override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D): R {
+    override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D): R {
         return visitor.visitDoubleColonExpression(this, data)
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDynamicType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDynamicType.java
similarity index 66%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetDynamicType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtDynamicType.java
index 6076e85ec63..82605c3c27d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDynamicType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtDynamicType.java
@@ -19,28 +19,28 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetDynamicType extends JetElementImplStub<KotlinPlaceHolderStub<JetDynamicType>> implements JetTypeElement {
-    public JetDynamicType(@NotNull ASTNode node) {
+public class KtDynamicType extends KtElementImplStub<KotlinPlaceHolderStub<KtDynamicType>> implements KtTypeElement {
+    public KtDynamicType(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetDynamicType(@NotNull KotlinPlaceHolderStub<JetDynamicType> stub) {
-        super(stub, JetStubElementTypes.DYNAMIC_TYPE);
+    public KtDynamicType(@NotNull KotlinPlaceHolderStub<KtDynamicType> stub) {
+        super(stub, KtStubElementTypes.DYNAMIC_TYPE);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitDynamicType(this, data);
     }
 
     @NotNull
     @Override
-    public List<JetTypeReference> getTypeArgumentsAsTypes() {
+    public List<KtTypeReference> getTypeArgumentsAsTypes() {
         return Collections.emptyList();
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetElement.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtElement.kt
similarity index 66%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetElement.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtElement.kt
index 38446d35773..f3a263b14c1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetElement.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtElement.kt
@@ -19,21 +19,21 @@ package org.jetbrains.kotlin.psi
 import com.intellij.psi.NavigatablePsiElement
 import com.intellij.psi.PsiReference
 
-public interface JetElement : NavigatablePsiElement {
-    public fun getContainingJetFile(): JetFile
+public interface KtElement : NavigatablePsiElement {
+    public fun getContainingJetFile(): KtFile
 
-    public fun <D> acceptChildren(visitor: JetVisitor<Void, D>, data: D)
+    public fun <D> acceptChildren(visitor: KtVisitor<Void, D>, data: D)
 
-    public fun <R, D> accept(visitor: JetVisitor<R, D>, data: D): R
+    public fun <R, D> accept(visitor: KtVisitor<R, D>, data: D): R
 
     @Deprecated("Don't use getReference() on JetElement for the choice is unpredictable")
     override fun getReference(): PsiReference?
 }
 
-public fun JetElement.getModificationStamp(): Long {
+public fun KtElement.getModificationStamp(): Long {
     return when (this) {
-        is JetFile -> this.modificationStamp
-        is JetDeclarationStub<*> -> this.modificationStamp
-        else -> (parent as JetElement).getModificationStamp()
+        is KtFile -> this.modificationStamp
+        is KtDeclarationStub<*> -> this.modificationStamp
+        else -> (parent as KtElement).getModificationStamp()
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetElementImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtElementImpl.java
similarity index 76%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetElementImpl.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtElementImpl.java
index 3cfc3013cfd..9508aba36a3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetElementImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtElementImpl.java
@@ -27,8 +27,8 @@ import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
 
-public class JetElementImpl extends ASTWrapperPsiElement implements JetElement {
-    public JetElementImpl(@NotNull ASTNode node) {
+public class KtElementImpl extends ASTWrapperPsiElement implements KtElement {
+    public KtElementImpl(@NotNull ASTNode node) {
         super(node);
     }
 
@@ -45,8 +45,8 @@ public class JetElementImpl extends ASTWrapperPsiElement implements JetElement {
 
     @Override
     public final void accept(@NotNull PsiElementVisitor visitor) {
-        if (visitor instanceof JetVisitor) {
-            accept((JetVisitor) visitor, null);
+        if (visitor instanceof KtVisitor) {
+            accept((KtVisitor) visitor, null);
         }
         else {
             visitor.visitElement(this);
@@ -55,19 +55,19 @@ public class JetElementImpl extends ASTWrapperPsiElement implements JetElement {
 
     @NotNull
     @Override
-    public JetFile getContainingJetFile() {
+    public KtFile getContainingJetFile() {
         PsiFile file = getContainingFile();
-        assert file instanceof JetFile : "JetElement not inside JetFile: " + file + " " + file.getText();
-        return (JetFile) file;
+        assert file instanceof KtFile : "JetElement not inside JetFile: " + file + " " + file.getText();
+        return (KtFile) file;
     }
 
     @Override
-    public <D> void acceptChildren(@NotNull JetVisitor<Void, D> visitor, D data) {
-        JetPsiUtil.visitChildren(this, visitor, data);
+    public <D> void acceptChildren(@NotNull KtVisitor<Void, D> visitor, D data) {
+        KtPsiUtil.visitChildren(this, visitor, data);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitJetElement(this, data);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetElementImplStub.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtElementImplStub.java
similarity index 68%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetElementImplStub.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtElementImplStub.java
index 3b09077070f..b826d3775aa 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetElementImplStub.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtElementImplStub.java
@@ -25,18 +25,18 @@ import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementType;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementType;
 
 import java.util.Arrays;
 import java.util.List;
 
-public class JetElementImplStub<T extends StubElement<?>> extends StubBasedPsiElementBase<T>
-        implements JetElement, StubBasedPsiElement<T> {
-    public JetElementImplStub(@NotNull T stub, @NotNull IStubElementType nodeType) {
+public class KtElementImplStub<T extends StubElement<?>> extends StubBasedPsiElementBase<T>
+        implements KtElement, StubBasedPsiElement<T> {
+    public KtElementImplStub(@NotNull T stub, @NotNull IStubElementType nodeType) {
         super(stub, nodeType);
     }
 
-    public JetElementImplStub(@NotNull ASTNode node) {
+    public KtElementImplStub(@NotNull ASTNode node) {
         super(node);
     }
 
@@ -53,8 +53,8 @@ public class JetElementImplStub<T extends StubElement<?>> extends StubBasedPsiEl
 
     @Override
     public final void accept(@NotNull PsiElementVisitor visitor) {
-        if (visitor instanceof JetVisitor) {
-            accept((JetVisitor) visitor, null);
+        if (visitor instanceof KtVisitor) {
+            accept((KtVisitor) visitor, null);
         }
         else {
             visitor.visitElement(this);
@@ -63,25 +63,25 @@ public class JetElementImplStub<T extends StubElement<?>> extends StubBasedPsiEl
 
     @NotNull
     @Override
-    public JetFile getContainingJetFile() {
+    public KtFile getContainingJetFile() {
         PsiFile file = getContainingFile();
-        assert file instanceof JetFile : "JetElement not inside JetFile: " + file + " " + file.getText();
-        return (JetFile) file;
+        assert file instanceof KtFile : "JetElement not inside JetFile: " + file + " " + file.getText();
+        return (KtFile) file;
     }
 
     @Override
-    public <D> void acceptChildren(@NotNull JetVisitor<Void, D> visitor, D data) {
+    public <D> void acceptChildren(@NotNull KtVisitor<Void, D> visitor, D data) {
         PsiElement child = getFirstChild();
         while (child != null) {
-            if (child instanceof JetElement) {
-                ((JetElement) child).accept(visitor, data);
+            if (child instanceof KtElement) {
+                ((KtElement) child).accept(visitor, data);
             }
             child = child.getNextSibling();
         }
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitJetElement(this, data);
     }
 
@@ -99,8 +99,8 @@ public class JetElementImplStub<T extends StubElement<?>> extends StubBasedPsiEl
     }
 
     @NotNull
-    protected <PsiT extends JetElementImplStub<?>, StubT extends StubElement> List<PsiT> getStubOrPsiChildrenAsList(
-            @NotNull JetStubElementType<StubT, PsiT> elementType
+    protected <PsiT extends KtElementImplStub<?>, StubT extends StubElement> List<PsiT> getStubOrPsiChildrenAsList(
+            @NotNull KtStubElementType<StubT, PsiT> elementType
     ) {
         return Arrays.asList(getStubOrPsiChildren(elementType, elementType.getArrayFactory()));
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetEnumEntry.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtEnumEntry.java
similarity index 77%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetEnumEntry.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtEnumEntry.java
index c444a5cdb7a..34e64eb1ea9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetEnumEntry.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtEnumEntry.java
@@ -26,47 +26,47 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub;
 import org.jetbrains.kotlin.psi.stubs.KotlinClassStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetEnumEntry extends JetClass {
-    public JetEnumEntry(@NotNull ASTNode node) {
+public class KtEnumEntry extends KtClass {
+    public KtEnumEntry(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetEnumEntry(@NotNull KotlinClassStub stub) {
+    public KtEnumEntry(@NotNull KotlinClassStub stub) {
         super(stub);
     }
 
     @Override
     public String getName() {
-        KotlinClassOrObjectStub<? extends JetClassOrObject> classStub = getStub();
+        KotlinClassOrObjectStub<? extends KtClassOrObject> classStub = getStub();
         if (classStub != null) {
             return classStub.getName();
         }
 
-        JetObjectDeclarationName nameAsDeclaration = getNameAsDeclaration();
+        KtObjectDeclarationName nameAsDeclaration = getNameAsDeclaration();
         return nameAsDeclaration == null ? "<Anonymous>" : nameAsDeclaration.getName();
     }
 
     @Override
     public PsiElement getNameIdentifier() {
-        JetObjectDeclarationName nameAsDeclaration = getNameAsDeclaration();
+        KtObjectDeclarationName nameAsDeclaration = getNameAsDeclaration();
         return nameAsDeclaration == null ? null : nameAsDeclaration.getNameIdentifier();
     }
 
     @Override
     public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
-        JetObjectDeclarationName nameAsDeclaration = getNameAsDeclaration();
+        KtObjectDeclarationName nameAsDeclaration = getNameAsDeclaration();
         return nameAsDeclaration == null ? null : nameAsDeclaration.setName(name);
     }
 
     @NotNull
     @Override
-    public List<JetDelegationSpecifier> getDelegationSpecifiers() {
-        JetInitializerList initializerList = getInitializerList();
+    public List<KtDelegationSpecifier> getDelegationSpecifiers() {
+        KtInitializerList initializerList = getInitializerList();
         if (initializerList == null) {
             return Collections.emptyList();
         }
@@ -78,12 +78,12 @@ public class JetEnumEntry extends JetClass {
     }
 
     @Nullable
-    public JetInitializerList getInitializerList() {
-        return getStubOrPsiChild(JetStubElementTypes.INITIALIZER_LIST);
+    public KtInitializerList getInitializerList() {
+        return getStubOrPsiChild(KtStubElementTypes.INITIALIZER_LIST);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitEnumEntry(this, data);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetEnumEntrySuperclassReferenceExpression.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtEnumEntrySuperclassReferenceExpression.kt
similarity index 73%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetEnumEntrySuperclassReferenceExpression.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtEnumEntrySuperclassReferenceExpression.kt
index e901e0b4251..b49dfa05a9b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetEnumEntrySuperclassReferenceExpression.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtEnumEntrySuperclassReferenceExpression.kt
@@ -20,31 +20,31 @@ import com.intellij.lang.ASTNode
 import com.intellij.psi.PsiElement
 import com.intellij.psi.tree.IElementType
 import com.intellij.psi.tree.TokenSet
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.SpecialNames
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.psi.stubs.KotlinEnumEntrySuperclassReferenceExpressionStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 
 // This node represents "fake" reference expression for ENUM_ENTRY(arguments) constructor syntax
 // It uses the superclass enum node to provide access to the real constructor name
-public class JetEnumEntrySuperclassReferenceExpression:
-        JetExpressionImplStub<KotlinEnumEntrySuperclassReferenceExpressionStub>, JetSimpleNameExpression {
+public class KtEnumEntrySuperclassReferenceExpression :
+        KtExpressionImplStub<KotlinEnumEntrySuperclassReferenceExpressionStub>, KtSimpleNameExpression {
 
     public constructor(node: ASTNode) : super(node)
 
     public constructor(stub: KotlinEnumEntrySuperclassReferenceExpressionStub) :
-            super(stub, JetStubElementTypes.ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION)
+            super(stub, KtStubElementTypes.ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION)
 
     // It is the owner enum class (not an enum entry but the whole enum)
-    private val referencedElement: JetClass
+    private val referencedElement: KtClass
             get() = calcReferencedElement()!!
 
-    private fun calcReferencedElement(): JetClass? {
-        val owner = this.getStrictParentOfType<JetEnumEntry>() as? JetEnumEntry
-        return owner?.getParent()?.getParent() as? JetClass
+    private fun calcReferencedElement(): KtClass? {
+        val owner = this.getStrictParentOfType<KtEnumEntry>() as? KtEnumEntry
+        return owner?.getParent()?.getParent() as? KtClass
     }
 
     override fun getReferencedName(): String {
@@ -52,8 +52,8 @@ public class JetEnumEntrySuperclassReferenceExpression:
         if (stub != null) {
             return stub.getReferencedName()
         }
-        val text = (getReferencedNameElement() as JetNamedDeclaration).nameAsSafeName.asString()
-        return JetPsiUtil.unquoteIdentifierOrFieldReference(text)
+        val text = (getReferencedNameElement() as KtNamedDeclaration).nameAsSafeName.asString()
+        return KtPsiUtil.unquoteIdentifierOrFieldReference(text)
     }
 
     override fun getReferencedNameAsName(): Name {
@@ -72,7 +72,7 @@ public class JetEnumEntrySuperclassReferenceExpression:
         return getReferencedNameElement().getNode()!!.getElementType()
     }
 
-    override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D): R {
+    override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D): R {
         return visitor.visitSimpleNameExpression(this, data)
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetEscapeStringTemplateEntry.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtEscapeStringTemplateEntry.java
similarity index 82%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetEscapeStringTemplateEntry.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtEscapeStringTemplateEntry.java
index c615fb341b7..46c5f864ac8 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetEscapeStringTemplateEntry.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtEscapeStringTemplateEntry.java
@@ -20,13 +20,13 @@ import com.intellij.lang.ASTNode;
 import com.intellij.openapi.util.text.StringUtil;
 import org.jetbrains.annotations.NotNull;
 
-public class JetEscapeStringTemplateEntry extends JetStringTemplateEntry {
-    public JetEscapeStringTemplateEntry(@NotNull ASTNode node) {
+public class KtEscapeStringTemplateEntry extends KtStringTemplateEntry {
+    public KtEscapeStringTemplateEntry(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitEscapeStringTemplateEntry(this, data);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpression.java
similarity index 67%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpression.java
index e3cd5cc2ad5..182283bc78d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpression.java
@@ -19,17 +19,17 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.util.ArrayFactory;
 import org.jetbrains.annotations.NotNull;
 
-public interface JetExpression extends JetElement {
-    JetExpression[] EMPTY_ARRAY = new JetExpression[0];
+public interface KtExpression extends KtElement {
+    KtExpression[] EMPTY_ARRAY = new KtExpression[0];
 
-    ArrayFactory<JetExpression> ARRAY_FACTORY = new ArrayFactory<JetExpression>() {
+    ArrayFactory<KtExpression> ARRAY_FACTORY = new ArrayFactory<KtExpression>() {
         @NotNull
         @Override
-        public JetExpression[] create(int count) {
-            return count == 0 ? EMPTY_ARRAY : new JetExpression[count];
+        public KtExpression[] create(int count) {
+            return count == 0 ? EMPTY_ARRAY : new KtExpression[count];
         }
     };
 
     @Override
-    <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data);
+    <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data);
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionCodeFragment.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionCodeFragment.kt
similarity index 81%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionCodeFragment.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionCodeFragment.kt
index 408ee445d87..0ce01f8084f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionCodeFragment.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionCodeFragment.kt
@@ -18,15 +18,15 @@ package org.jetbrains.kotlin.psi
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.JetNodeTypes
+import org.jetbrains.kotlin.KtNodeTypes
 
-public class JetExpressionCodeFragment(
+public class KtExpressionCodeFragment(
         project: Project,
         name: String,
         text: CharSequence,
         imports: String?,
         context: PsiElement?
-) : JetCodeFragment(project, name, text, imports, JetNodeTypes.EXPRESSION_CODE_FRAGMENT, context) {
+) : KtCodeFragment(project, name, text, imports, KtNodeTypes.EXPRESSION_CODE_FRAGMENT, context) {
 
-    override fun getContentElement() = findChildByClass(javaClass<JetExpression>())
+    override fun getContentElement() = findChildByClass(javaClass<KtExpression>())
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionCodeFragmentType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionCodeFragmentType.java
similarity index 89%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionCodeFragmentType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionCodeFragmentType.java
index ccf7a8ef1ae..0a7cbd1bb5d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionCodeFragmentType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionCodeFragmentType.java
@@ -24,12 +24,12 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.parsing.JetParser;
-import org.jetbrains.kotlin.psi.stubs.elements.JetFileElementType;
+import org.jetbrains.kotlin.psi.stubs.elements.KtFileElementType;
 
-public class JetExpressionCodeFragmentType extends JetFileElementType {
+public class KtExpressionCodeFragmentType extends KtFileElementType {
     private static final String NAME = "kotlin.EXPRESSION_CODE_FRAGMENT";
 
-    public JetExpressionCodeFragmentType() {
+    public KtExpressionCodeFragmentType() {
         super(NAME);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionImpl.kt
new file mode 100644
index 00000000000..adba23417cb
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionImpl.kt
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.psi
+
+import com.intellij.lang.ASTNode
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.KtNodeType
+
+public abstract class KtExpressionImpl(node: ASTNode) : KtElementImpl(node), KtExpression {
+
+    override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D) = visitor.visitExpression(this, data)
+
+    protected fun findExpressionUnder(type: KtNodeType): KtExpression? {
+        val containerNode = findChildByType<KtContainerNode>(type) ?: return null
+        return containerNode.findChildByClass<KtExpression>(javaClass())
+    }
+
+    override fun replace(newElement: PsiElement): PsiElement {
+        return replaceExpression(this, newElement, { super<KtElementImpl>.replace(it) })
+    }
+
+    companion object {
+        fun replaceExpression(expression: KtExpression, newElement: PsiElement, rawReplaceHandler: (PsiElement) -> PsiElement): PsiElement {
+            val parent = expression.getParent()
+
+            if (newElement is KtExpression) {
+                when (parent) {
+                    is KtExpression -> {
+                        if (KtPsiUtil.areParenthesesNecessary(newElement, expression, parent)) {
+                            return rawReplaceHandler(KtPsiFactory(expression).createExpressionByPattern("($0)", newElement))
+                        }
+                    }
+
+                    is KtSimpleNameStringTemplateEntry -> {
+                        if (newElement !is KtSimpleNameExpression) {
+                            val newEntry = parent.replace(KtPsiFactory(expression).createBlockStringTemplateEntry(newElement)) as KtBlockStringTemplateEntry
+                            return newEntry.getExpression()!!
+                        }
+                    }
+                }
+            }
+
+            return rawReplaceHandler(newElement)
+        }
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionImplStub.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionImplStub.java
similarity index 78%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionImplStub.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionImplStub.java
index fb6bc600c2b..96810b664c7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionImplStub.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionImplStub.java
@@ -24,24 +24,24 @@ import com.intellij.util.IncorrectOperationException;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 
-public abstract class JetExpressionImplStub<T extends StubElement<?>> extends JetElementImplStub<T> implements JetExpression {
-    public JetExpressionImplStub(@NotNull T stub, @NotNull IStubElementType nodeType) {
+public abstract class KtExpressionImplStub<T extends StubElement<?>> extends KtElementImplStub<T> implements KtExpression {
+    public KtExpressionImplStub(@NotNull T stub, @NotNull IStubElementType nodeType) {
         super(stub, nodeType);
     }
 
-    public JetExpressionImplStub(@NotNull ASTNode node) {
+    public KtExpressionImplStub(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitExpression(this, data);
     }
 
     @NotNull
     @Override
     public PsiElement replace(@NotNull PsiElement newElement) throws IncorrectOperationException {
-        return JetExpressionImpl.Companion.replaceExpression(this, newElement, new Function1<PsiElement, PsiElement>() {
+        return KtExpressionImpl.Companion.replaceExpression(this, newElement, new Function1<PsiElement, PsiElement>() {
             @Override
             public PsiElement invoke(PsiElement element) {
                 return rawReplace(element);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionWithLabel.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionWithLabel.kt
similarity index 63%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionWithLabel.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionWithLabel.kt
index 08e5d7d3dff..b8853bf46d5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetExpressionWithLabel.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionWithLabel.kt
@@ -17,19 +17,19 @@
 package org.jetbrains.kotlin.psi
 
 import com.intellij.lang.ASTNode
-import org.jetbrains.kotlin.JetNodeTypes
+import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.name.Name
 
-open public class JetExpressionWithLabel(node: ASTNode) : JetExpressionImpl(node) {
+open public class KtExpressionWithLabel(node: ASTNode) : KtExpressionImpl(node) {
 
-    public fun getTargetLabel(): JetSimpleNameExpression? =
-            labelQualifier?.findChildByType(JetNodeTypes.LABEL) as? JetSimpleNameExpression
+    public fun getTargetLabel(): KtSimpleNameExpression? =
+            labelQualifier?.findChildByType(KtNodeTypes.LABEL) as? KtSimpleNameExpression
 
-    public val labelQualifier: JetContainerNode?
-        get() = findChildByType(JetNodeTypes.LABEL_QUALIFIER)
+    public val labelQualifier: KtContainerNode?
+        get() = findChildByType(KtNodeTypes.LABEL_QUALIFIER)
 
     public fun getLabelName(): String? = getTargetLabel()?.getReferencedName()
     public fun getLabelNameAsName(): Name? = getTargetLabel()?.getReferencedNameAsName()
 
-    override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D) = visitor.visitExpressionWithLabel(this, data)
+    override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D) = visitor.visitExpressionWithLabel(this, data)
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFile.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFile.java
similarity index 63%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetFile.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtFile.java
index b1711976242..4263a3654b3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFile.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFile.java
@@ -30,23 +30,23 @@ import kotlin.ArraysKt;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.stubs.KotlinFileStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetPlaceHolderStubElementType;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtPlaceHolderStubElementType;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
-public class JetFile extends PsiFileBase implements JetDeclarationContainer, JetAnnotated, JetElement, PsiClassOwner {
+public class KtFile extends PsiFileBase implements KtDeclarationContainer, KtAnnotated, KtElement, PsiClassOwner {
 
     private final boolean isCompiled;
 
-    public JetFile(FileViewProvider viewProvider, boolean compiled) {
+    public KtFile(FileViewProvider viewProvider, boolean compiled) {
         super(viewProvider, KotlinLanguage.INSTANCE);
         this.isCompiled = compiled;
     }
@@ -63,7 +63,7 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
     @Override
     @NotNull
     public FileType getFileType() {
-        return JetFileType.INSTANCE;
+        return KotlinFileType.INSTANCE;
     }
 
     @Override
@@ -73,27 +73,27 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
 
     @NotNull
     @Override
-    public List<JetDeclaration> getDeclarations() {
+    public List<KtDeclaration> getDeclarations() {
         KotlinFileStub stub = getStub();
         if (stub != null) {
-            return Arrays.asList(stub.getChildrenByType(JetStubElementTypes.DECLARATION_TYPES, JetDeclaration.ARRAY_FACTORY));
+            return Arrays.asList(stub.getChildrenByType(KtStubElementTypes.DECLARATION_TYPES, KtDeclaration.ARRAY_FACTORY));
         }
-        return PsiTreeUtil.getChildrenOfTypeAsList(this, JetDeclaration.class);
+        return PsiTreeUtil.getChildrenOfTypeAsList(this, KtDeclaration.class);
     }
 
     @Nullable
-    public JetImportList getImportList() {
-        return findChildByTypeOrClass(JetStubElementTypes.IMPORT_LIST, JetImportList.class);
+    public KtImportList getImportList() {
+        return findChildByTypeOrClass(KtStubElementTypes.IMPORT_LIST, KtImportList.class);
     }
 
     @Nullable
-    public JetFileAnnotationList getFileAnnotationList() {
-        return findChildByTypeOrClass(JetStubElementTypes.FILE_ANNOTATION_LIST, JetFileAnnotationList.class);
+    public KtFileAnnotationList getFileAnnotationList() {
+        return findChildByTypeOrClass(KtStubElementTypes.FILE_ANNOTATION_LIST, KtFileAnnotationList.class);
     }
 
     @Nullable
-    public <T extends JetElementImplStub<? extends StubElement<?>>> T findChildByTypeOrClass(
-            @NotNull JetPlaceHolderStubElementType<T> elementType,
+    public <T extends KtElementImplStub<? extends StubElement<?>>> T findChildByTypeOrClass(
+            @NotNull KtPlaceHolderStubElementType<T> elementType,
             @NotNull Class<T> elementClass
     ) {
         KotlinFileStub stub = getStub();
@@ -105,14 +105,14 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
     }
 
     @NotNull
-    public List<JetImportDirective> getImportDirectives() {
-        JetImportList importList = getImportList();
-        return importList != null ? importList.getImports() : Collections.<JetImportDirective>emptyList();
+    public List<KtImportDirective> getImportDirectives() {
+        KtImportList importList = getImportList();
+        return importList != null ? importList.getImports() : Collections.<KtImportDirective>emptyList();
     }
 
     @Nullable
-    public JetImportDirective findImportByAlias(@NotNull String name) {
-        for (JetImportDirective directive : getImportDirectives()) {
+    public KtImportDirective findImportByAlias(@NotNull String name) {
+        for (KtImportDirective directive : getImportDirectives()) {
             if (name.equals(directive.getAliasName())) {
                 return directive;
             }
@@ -122,14 +122,14 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
 
     // scripts have no package directive, all other files must have package directives
     @Nullable
-    public JetPackageDirective getPackageDirective() {
+    public KtPackageDirective getPackageDirective() {
         KotlinFileStub stub = getStub();
         if (stub != null) {
-            StubElement<JetPackageDirective> packageDirectiveStub = stub.findChildStubByType(JetStubElementTypes.PACKAGE_DIRECTIVE);
+            StubElement<KtPackageDirective> packageDirectiveStub = stub.findChildStubByType(KtStubElementTypes.PACKAGE_DIRECTIVE);
             return packageDirectiveStub != null ? packageDirectiveStub.getPsi() : null;
         }
-        ASTNode ast = getNode().findChildByType(JetNodeTypes.PACKAGE_DIRECTIVE);
-        return ast != null ? (JetPackageDirective) ast.getPsi() : null;
+        ASTNode ast = getNode().findChildByType(KtNodeTypes.PACKAGE_DIRECTIVE);
+        return ast != null ? (KtPackageDirective) ast.getPsi() : null;
     }
 
     @Deprecated // getPackageFqName should be used instead
@@ -150,7 +150,7 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
 
     @NotNull
     public FqName getPackageFqNameByTree() {
-        JetPackageDirective packageDirective = getPackageDirective();
+        KtPackageDirective packageDirective = getPackageDirective();
         if (packageDirective == null) {
             return FqName.ROOT;
         }
@@ -174,8 +174,8 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
 
     // SCRIPT: find script in file
     @Nullable
-    public JetScript getScript() {
-        return PsiTreeUtil.getChildOfType(this, JetScript.class);
+    public KtScript getScript() {
+        return PsiTreeUtil.getChildOfType(this, KtScript.class);
     }
 
     public boolean isScript() {
@@ -198,8 +198,8 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
 
     @Override
     public void accept(@NotNull PsiElementVisitor visitor) {
-        if (visitor instanceof JetVisitor) {
-            accept((JetVisitor) visitor, null);
+        if (visitor instanceof KtVisitor) {
+            accept((KtVisitor) visitor, null);
         }
         else {
             visitor.visitFile(this);
@@ -208,24 +208,24 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
 
     @NotNull
     @Override
-    public JetFile getContainingJetFile() {
+    public KtFile getContainingJetFile() {
         return this;
     }
 
     @Override
-    public <D> void acceptChildren(@NotNull JetVisitor<Void, D> visitor, D data) {
-        JetPsiUtil.visitChildren(this, visitor, data);
+    public <D> void acceptChildren(@NotNull KtVisitor<Void, D> visitor, D data) {
+        KtPsiUtil.visitChildren(this, visitor, data);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitJetFile(this, data);
     }
 
     @NotNull
     @Override
-    public List<JetAnnotation> getAnnotations() {
-        JetFileAnnotationList fileAnnotationList = getFileAnnotationList();
+    public List<KtAnnotation> getAnnotations() {
+        KtFileAnnotationList fileAnnotationList = getFileAnnotationList();
         if (fileAnnotationList == null) return Collections.emptyList();
 
         return fileAnnotationList.getAnnotations();
@@ -233,8 +233,8 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
 
     @NotNull
     @Override
-    public List<JetAnnotationEntry> getAnnotationEntries() {
-        JetFileAnnotationList fileAnnotationList = getFileAnnotationList();
+    public List<KtAnnotationEntry> getAnnotationEntries() {
+        KtFileAnnotationList fileAnnotationList = getFileAnnotationList();
         if (fileAnnotationList == null) return Collections.emptyList();
 
         return fileAnnotationList.getAnnotationEntries();
@@ -244,19 +244,19 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
      * @return annotations that do not belong to any declaration due to incomplete code or syntax errors
      */
     @NotNull
-    public List<JetAnnotationEntry> getDanglingAnnotations() {
+    public List<KtAnnotationEntry> getDanglingAnnotations() {
         KotlinFileStub stub = getStub();
-        JetModifierList[] danglingModifierLists = stub == null
-                                                  ? findChildrenByClass(JetModifierList.class)
+        KtModifierList[] danglingModifierLists = stub == null
+                                                  ? findChildrenByClass(KtModifierList.class)
                                                   : stub.getChildrenByType(
-                                                          JetStubElementTypes.MODIFIER_LIST,
-                                                          JetStubElementTypes.MODIFIER_LIST.getArrayFactory()
+                                                          KtStubElementTypes.MODIFIER_LIST,
+                                                          KtStubElementTypes.MODIFIER_LIST.getArrayFactory()
                                                   );
         return ArraysKt.flatMap(
                 danglingModifierLists,
-                new Function1<JetModifierList, Iterable<JetAnnotationEntry>>() {
+                new Function1<KtModifierList, Iterable<KtAnnotationEntry>>() {
                     @Override
-                    public Iterable<JetAnnotationEntry> invoke(JetModifierList modifierList) {
+                    public Iterable<KtAnnotationEntry> invoke(KtModifierList modifierList) {
                         return modifierList.getAnnotationEntries();
                     }
                 });
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFileAnnotationList.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFileAnnotationList.java
similarity index 58%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetFileAnnotationList.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtFileAnnotationList.java
index ab67336a270..f962bcbfb95 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFileAnnotationList.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFileAnnotationList.java
@@ -20,32 +20,33 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.psiUtil.JetPsiUtilKt;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.List;
 
-public class JetFileAnnotationList extends JetElementImplStub<KotlinPlaceHolderStub<JetFileAnnotationList>> implements JetAnnotationsContainer {
+public class KtFileAnnotationList extends KtElementImplStub<KotlinPlaceHolderStub<KtFileAnnotationList>> implements
+                                                                                                            KtAnnotationsContainer {
 
-    public JetFileAnnotationList(@NotNull ASTNode node) {
+    public KtFileAnnotationList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetFileAnnotationList(@NotNull KotlinPlaceHolderStub<JetFileAnnotationList> stub) {
-        super(stub, JetStubElementTypes.FILE_ANNOTATION_LIST);
+    public KtFileAnnotationList(@NotNull KotlinPlaceHolderStub<KtFileAnnotationList> stub) {
+        super(stub, KtStubElementTypes.FILE_ANNOTATION_LIST);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitFileAnnotationList(this, data);
     }
 
     @NotNull
-    public List<JetAnnotation> getAnnotations() {
-        return getStubOrPsiChildrenAsList(JetStubElementTypes.ANNOTATION);
+    public List<KtAnnotation> getAnnotations() {
+        return getStubOrPsiChildrenAsList(KtStubElementTypes.ANNOTATION);
     }
 
     @NotNull
-    public List<JetAnnotationEntry> getAnnotationEntries() {
+    public List<KtAnnotationEntry> getAnnotationEntries() {
         return JetPsiUtilKt.collectAnnotationEntriesFromStubOrPsi(this);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFinallySection.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFinallySection.java
similarity index 68%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetFinallySection.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtFinallySection.java
index 5ff5c779229..ee801956b6d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFinallySection.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFinallySection.java
@@ -18,19 +18,19 @@ package org.jetbrains.kotlin.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
-public class JetFinallySection extends JetElementImpl implements JetStatementExpression {
-    public JetFinallySection(@NotNull ASTNode node) {
+public class KtFinallySection extends KtElementImpl implements KtStatementExpression {
+    public KtFinallySection(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitFinallySection(this, data);
     }
 
-    public JetBlockExpression getFinalExpression() {
-        return (JetBlockExpression) findChildByType(JetNodeTypes.BLOCK);
+    public KtBlockExpression getFinalExpression() {
+        return (KtBlockExpression) findChildByType(KtNodeTypes.BLOCK);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetForExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtForExpression.java
similarity index 58%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetForExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtForExpression.java
index a25e7e50e44..e49de373643 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetForExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtForExpression.java
@@ -19,36 +19,36 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-public class JetForExpression extends JetLoopExpression {
-    public JetForExpression(@NotNull ASTNode node) {
+public class KtForExpression extends KtLoopExpression {
+    public KtForExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitForExpression(this, data);
     }
 
     @Nullable
-    public JetParameter getLoopParameter() {
-        return (JetParameter) findChildByType(JetNodeTypes.VALUE_PARAMETER);
+    public KtParameter getLoopParameter() {
+        return (KtParameter) findChildByType(KtNodeTypes.VALUE_PARAMETER);
     }
 
     @Nullable
-    public JetMultiDeclaration getMultiParameter() {
-        return (JetMultiDeclaration) findChildByType(JetNodeTypes.MULTI_VARIABLE_DECLARATION);
+    public KtMultiDeclaration getMultiParameter() {
+        return (KtMultiDeclaration) findChildByType(KtNodeTypes.MULTI_VARIABLE_DECLARATION);
     }
 
     @Nullable @IfNotParsed
-    public JetExpression getLoopRange() {
-        return findExpressionUnder(JetNodeTypes.LOOP_RANGE);
+    public KtExpression getLoopRange() {
+        return findExpressionUnder(KtNodeTypes.LOOP_RANGE);
     }
 
     @Nullable @IfNotParsed
     public ASTNode getInKeywordNode() {
-        return getNode().findChildByType(JetTokens.IN_KEYWORD);
+        return getNode().findChildByType(KtTokens.IN_KEYWORD);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunction.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunction.java
similarity index 88%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunction.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunction.java
index c85de716ac5..2fdcbeac73a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunction.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunction.java
@@ -16,6 +16,6 @@
 
 package org.jetbrains.kotlin.psi;
 
-public interface JetFunction extends JetDeclarationWithBody, JetCallableDeclaration {
+public interface KtFunction extends KtDeclarationWithBody, KtCallableDeclaration {
     boolean isLocal();
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionLiteral.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionLiteral.java
similarity index 77%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionLiteral.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionLiteral.java
index 0bef29ddb52..a55cb719664 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionLiteral.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionLiteral.java
@@ -20,11 +20,11 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.lexer.JetTokens;
 
-public class JetFunctionLiteral extends JetFunctionNotStubbed {
-    public JetFunctionLiteral(@NotNull ASTNode node) {
+public class KtFunctionLiteral extends KtFunctionNotStubbed {
+    public KtFunctionLiteral(@NotNull ASTNode node) {
         super(node);
     }
 
@@ -44,12 +44,12 @@ public class JetFunctionLiteral extends JetFunctionNotStubbed {
     }
 
     public boolean hasParameterSpecification() {
-        return findChildByType(JetTokens.ARROW) != null;
+        return findChildByType(KtTokens.ARROW) != null;
     }
 
     @Override
-    public JetBlockExpression getBodyExpression() {
-        return (JetBlockExpression) super.getBodyExpression();
+    public KtBlockExpression getBodyExpression() {
+        return (KtBlockExpression) super.getBodyExpression();
     }
 
     @Nullable
@@ -60,18 +60,18 @@ public class JetFunctionLiteral extends JetFunctionNotStubbed {
 
     @NotNull
     public PsiElement getLBrace() {
-        return findChildByType(JetTokens.LBRACE);
+        return findChildByType(KtTokens.LBRACE);
     }
 
     @Nullable
     @IfNotParsed
     public PsiElement getRBrace() {
-        return findChildByType(JetTokens.RBRACE);
+        return findChildByType(KtTokens.RBRACE);
     }
 
     @Nullable
     public PsiElement getArrow() {
-        return findChildByType(JetTokens.ARROW);
+        return findChildByType(KtTokens.ARROW);
     }
 
     @Nullable
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionLiteralArgument.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionLiteralArgument.kt
similarity index 52%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionLiteralArgument.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionLiteralArgument.kt
index 7fbf4262953..8d64a3a0e6c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionLiteralArgument.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionLiteralArgument.kt
@@ -17,20 +17,19 @@
 package org.jetbrains.kotlin.psi
 
 import com.intellij.lang.ASTNode
-import com.intellij.psi.PsiWhiteSpace
 
-public class JetFunctionLiteralArgument(node: ASTNode) : JetValueArgument(node), FunctionLiteralArgument {
+public class KtFunctionLiteralArgument(node: ASTNode) : KtValueArgument(node), FunctionLiteralArgument {
 
-    override fun getArgumentExpression() = super<JetValueArgument>.getArgumentExpression()!!
+    override fun getArgumentExpression() = super<KtValueArgument>.getArgumentExpression()!!
 
-    override fun getFunctionLiteral(): JetFunctionLiteralExpression = getArgumentExpression().unpackFunctionLiteral()!!
+    override fun getFunctionLiteral(): KtFunctionLiteralExpression = getArgumentExpression().unpackFunctionLiteral()!!
 }
 
-public fun JetExpression.unpackFunctionLiteral(): JetFunctionLiteralExpression? {
+public fun KtExpression.unpackFunctionLiteral(): KtFunctionLiteralExpression? {
     return when (this) {
-        is JetFunctionLiteralExpression -> this
-        is JetLabeledExpression -> getBaseExpression()?.unpackFunctionLiteral()
-        is JetAnnotatedExpression -> getBaseExpression()?.unpackFunctionLiteral()
+        is KtFunctionLiteralExpression -> this
+        is KtLabeledExpression -> getBaseExpression()?.unpackFunctionLiteral()
+        is KtAnnotatedExpression -> getBaseExpression()?.unpackFunctionLiteral()
         else -> null
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionLiteralExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionLiteralExpression.java
similarity index 64%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionLiteralExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionLiteralExpression.java
index e3b5b5789a5..fb3411a8fc2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionLiteralExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionLiteralExpression.java
@@ -19,33 +19,33 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
 import java.util.List;
 
-public class JetFunctionLiteralExpression extends JetExpressionImpl {
-    public JetFunctionLiteralExpression(@NotNull ASTNode node) {
+public class KtFunctionLiteralExpression extends KtExpressionImpl {
+    public KtFunctionLiteralExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitFunctionLiteralExpression(this, data);
     }
 
     @NotNull
-    public JetFunctionLiteral getFunctionLiteral() {
-        return (JetFunctionLiteral) findChildByType(JetNodeTypes.FUNCTION_LITERAL);
+    public KtFunctionLiteral getFunctionLiteral() {
+        return (KtFunctionLiteral) findChildByType(KtNodeTypes.FUNCTION_LITERAL);
     }
 
     @NotNull
-    public List<JetParameter> getValueParameters() {
+    public List<KtParameter> getValueParameters() {
         return getFunctionLiteral().getValueParameters();
     }
 
     @Nullable
-    public JetBlockExpression getBodyExpression() {
+    public KtBlockExpression getBodyExpression() {
         return getFunctionLiteral().getBodyExpression();
     }
 
@@ -54,17 +54,17 @@ public class JetFunctionLiteralExpression extends JetExpressionImpl {
     }
 
     @NotNull
-    public JetElement asElement() {
+    public KtElement asElement() {
         return this;
     }
 
     @NotNull
     public ASTNode getLeftCurlyBrace() {
-        return getFunctionLiteral().getNode().findChildByType(JetTokens.LBRACE);
+        return getFunctionLiteral().getNode().findChildByType(KtTokens.LBRACE);
     }
 
     @Nullable
     public ASTNode getRightCurlyBrace() {
-        return getFunctionLiteral().getNode().findChildByType(JetTokens.RBRACE);
+        return getFunctionLiteral().getNode().findChildByType(KtTokens.RBRACE);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionNotStubbed.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionNotStubbed.java
similarity index 64%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionNotStubbed.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionNotStubbed.java
index 6ff8048b593..88f1654a683 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionNotStubbed.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionNotStubbed.java
@@ -20,34 +20,34 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-public abstract class JetFunctionNotStubbed extends JetTypeParameterListOwnerNotStubbed implements JetFunction {
+public abstract class KtFunctionNotStubbed extends KtTypeParameterListOwnerNotStubbed implements KtFunction {
 
-    public JetFunctionNotStubbed(@NotNull ASTNode node) {
+    public KtFunctionNotStubbed(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
     @Nullable
-    public JetParameterList getValueParameterList() {
-        return (JetParameterList) findChildByType(JetNodeTypes.VALUE_PARAMETER_LIST);
+    public KtParameterList getValueParameterList() {
+        return (KtParameterList) findChildByType(KtNodeTypes.VALUE_PARAMETER_LIST);
     }
 
     @Override
     @NotNull
-    public List<JetParameter> getValueParameters() {
-        JetParameterList list = getValueParameterList();
-        return list != null ? list.getParameters() : Collections.<JetParameter>emptyList();
+    public List<KtParameter> getValueParameters() {
+        KtParameterList list = getValueParameterList();
+        return list != null ? list.getParameters() : Collections.<KtParameter>emptyList();
     }
 
     @Override
     @Nullable
-    public JetExpression getBodyExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getBodyExpression() {
+        return findChildByClass(KtExpression.class);
     }
 
     @Override
@@ -57,19 +57,19 @@ public abstract class JetFunctionNotStubbed extends JetTypeParameterListOwnerNot
 
     @Override
     @Nullable
-    public JetTypeReference getReceiverTypeReference() {
+    public KtTypeReference getReceiverTypeReference() {
         return null;
     }
 
     @Override
     @Nullable
-    public JetTypeReference getTypeReference() {
+    public KtTypeReference getTypeReference() {
         return null;
     }
 
     @Nullable
     @Override
-    public JetTypeReference setTypeReference(@Nullable JetTypeReference typeRef) {
+    public KtTypeReference setTypeReference(@Nullable KtTypeReference typeRef) {
         if (typeRef == null) return null;
         throw new IllegalStateException("Function literals can't have type reference");
     }
@@ -83,6 +83,6 @@ public abstract class JetFunctionNotStubbed extends JetTypeParameterListOwnerNot
     @Override
     public boolean isLocal() {
         PsiElement parent = getParent();
-        return !(parent instanceof JetFile || parent instanceof JetClassBody);
+        return !(parent instanceof KtFile || parent instanceof KtClassBody);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionType.java
similarity index 52%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionType.java
index c30488a7f45..0a030091b56 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionType.java
@@ -20,39 +20,39 @@ import com.google.common.collect.Lists;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-public class JetFunctionType extends JetElementImplStub<KotlinPlaceHolderStub<JetFunctionType>> implements JetTypeElement {
+public class KtFunctionType extends KtElementImplStub<KotlinPlaceHolderStub<KtFunctionType>> implements KtTypeElement {
 
-    public static final JetToken RETURN_TYPE_SEPARATOR = JetTokens.ARROW;
+    public static final KtToken RETURN_TYPE_SEPARATOR = KtTokens.ARROW;
 
-    public JetFunctionType(@NotNull ASTNode node) {
+    public KtFunctionType(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetFunctionType(@NotNull KotlinPlaceHolderStub<JetFunctionType> stub) {
-        super(stub, JetStubElementTypes.FUNCTION_TYPE);
+    public KtFunctionType(@NotNull KotlinPlaceHolderStub<KtFunctionType> stub) {
+        super(stub, KtStubElementTypes.FUNCTION_TYPE);
     }
 
     @NotNull
     @Override
-    public List<JetTypeReference> getTypeArgumentsAsTypes() {
-        ArrayList<JetTypeReference> result = Lists.newArrayList();
-        JetTypeReference receiverTypeRef = getReceiverTypeReference();
+    public List<KtTypeReference> getTypeArgumentsAsTypes() {
+        ArrayList<KtTypeReference> result = Lists.newArrayList();
+        KtTypeReference receiverTypeRef = getReceiverTypeReference();
         if (receiverTypeRef != null) {
             result.add(receiverTypeRef);
         }
-        for (JetParameter jetParameter : getParameters()) {
+        for (KtParameter jetParameter : getParameters()) {
             result.add(jetParameter.getTypeReference());
         }
-        JetTypeReference returnTypeRef = getReturnTypeReference();
+        KtTypeReference returnTypeRef = getReturnTypeReference();
         if (returnTypeRef != null) {
             result.add(returnTypeRef);
         }
@@ -60,24 +60,24 @@ public class JetFunctionType extends JetElementImplStub<KotlinPlaceHolderStub<Je
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitFunctionType(this, data);
     }
 
     @Nullable
-    public JetParameterList getParameterList() {
-        return getStubOrPsiChild(JetStubElementTypes.VALUE_PARAMETER_LIST);
+    public KtParameterList getParameterList() {
+        return getStubOrPsiChild(KtStubElementTypes.VALUE_PARAMETER_LIST);
     }
 
     @NotNull
-    public List<JetParameter> getParameters() {
-        JetParameterList list = getParameterList();
-        return list != null ? list.getParameters() : Collections.<JetParameter>emptyList();
+    public List<KtParameter> getParameters() {
+        KtParameterList list = getParameterList();
+        return list != null ? list.getParameters() : Collections.<KtParameter>emptyList();
     }
 
     @Nullable
-    public JetTypeReference getReceiverTypeReference() {
-        JetFunctionTypeReceiver receiverDeclaration = getStubOrPsiChild(JetStubElementTypes.FUNCTION_TYPE_RECEIVER);
+    public KtTypeReference getReceiverTypeReference() {
+        KtFunctionTypeReceiver receiverDeclaration = getStubOrPsiChild(KtStubElementTypes.FUNCTION_TYPE_RECEIVER);
         if (receiverDeclaration == null) {
             return null;
         }
@@ -85,7 +85,7 @@ public class JetFunctionType extends JetElementImplStub<KotlinPlaceHolderStub<Je
     }
 
     @Nullable
-    public JetTypeReference getReturnTypeReference() {
-        return getStubOrPsiChild(JetStubElementTypes.TYPE_REFERENCE);
+    public KtTypeReference getReturnTypeReference() {
+        return getStubOrPsiChild(KtStubElementTypes.TYPE_REFERENCE);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionTypeReceiver.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionTypeReceiver.java
similarity index 60%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionTypeReceiver.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionTypeReceiver.java
index bf4a2ae20d4..c09cebc7766 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetFunctionTypeReceiver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtFunctionTypeReceiver.java
@@ -19,19 +19,19 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
-public class JetFunctionTypeReceiver extends JetElementImplStub<KotlinPlaceHolderStub<JetFunctionTypeReceiver>> {
-    public JetFunctionTypeReceiver(@NotNull ASTNode node) {
+public class KtFunctionTypeReceiver extends KtElementImplStub<KotlinPlaceHolderStub<KtFunctionTypeReceiver>> {
+    public KtFunctionTypeReceiver(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetFunctionTypeReceiver(@NotNull KotlinPlaceHolderStub<JetFunctionTypeReceiver> stub) {
-        super(stub, JetStubElementTypes.FUNCTION_TYPE_RECEIVER);
+    public KtFunctionTypeReceiver(@NotNull KotlinPlaceHolderStub<KtFunctionTypeReceiver> stub) {
+        super(stub, KtStubElementTypes.FUNCTION_TYPE_RECEIVER);
     }
 
     @NotNull
-    public JetTypeReference getTypeReference() {
-        return getRequiredStubOrPsiChild(JetStubElementTypes.TYPE_REFERENCE);
+    public KtTypeReference getTypeReference() {
+        return getRequiredStubOrPsiChild(KtStubElementTypes.TYPE_REFERENCE);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetIfExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtIfExpression.java
similarity index 62%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetIfExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtIfExpression.java
index c77b8b19e70..f848dd32732 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetIfExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtIfExpression.java
@@ -20,51 +20,51 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-public class JetIfExpression extends JetExpressionImpl {
-    public JetIfExpression(@NotNull ASTNode node) {
+public class KtIfExpression extends KtExpressionImpl {
+    public KtIfExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitIfExpression(this, data);
     }
 
     @Nullable @IfNotParsed
-    public JetExpression getCondition() {
-        return findExpressionUnder(JetNodeTypes.CONDITION);
+    public KtExpression getCondition() {
+        return findExpressionUnder(KtNodeTypes.CONDITION);
     }
 
     @Nullable @IfNotParsed
     public PsiElement getLeftParenthesis() {
-        return findChildByType(JetTokens.LPAR);
+        return findChildByType(KtTokens.LPAR);
     }
 
     @Nullable @IfNotParsed
     public PsiElement getRightParenthesis() {
-        return findChildByType(JetTokens.RPAR);
+        return findChildByType(KtTokens.RPAR);
     }
 
     @Nullable
-    public JetExpression getThen() {
-        return findExpressionUnder(JetNodeTypes.THEN);
+    public KtExpression getThen() {
+        return findExpressionUnder(KtNodeTypes.THEN);
     }
 
     @Nullable
-    public JetExpression getElse() {
-        return findExpressionUnder(JetNodeTypes.ELSE);
+    public KtExpression getElse() {
+        return findExpressionUnder(KtNodeTypes.ELSE);
     }
 
     @Nullable
     public PsiElement getElseKeyword() {
-        return findChildByType(JetTokens.ELSE_KEYWORD);
+        return findChildByType(KtTokens.ELSE_KEYWORD);
     }
 
     @NotNull
     public PsiElement getIfKeyword() {
-        return findChildByType(JetTokens.IF_KEYWORD);
+        return findChildByType(KtTokens.IF_KEYWORD);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportDirective.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtImportDirective.java
similarity index 73%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportDirective.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtImportDirective.java
index 7d102e9b6c8..0ecf7ab1bf9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportDirective.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtImportDirective.java
@@ -21,25 +21,25 @@ import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.stubs.KotlinImportDirectiveStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 import org.jetbrains.kotlin.resolve.ImportPath;
 
-public class JetImportDirective extends JetElementImplStub<KotlinImportDirectiveStub> {
+public class KtImportDirective extends KtElementImplStub<KotlinImportDirectiveStub> {
 
-    public JetImportDirective(@NotNull ASTNode node) {
+    public KtImportDirective(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetImportDirective(@NotNull KotlinImportDirectiveStub stub) {
-        super(stub, JetStubElementTypes.IMPORT_DIRECTIVE);
+    public KtImportDirective(@NotNull KotlinImportDirectiveStub stub) {
+        super(stub, KtStubElementTypes.IMPORT_DIRECTIVE);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitImportDirective(this, data);
     }
 
@@ -48,12 +48,12 @@ public class JetImportDirective extends JetElementImplStub<KotlinImportDirective
         if (stub != null) {
             return stub.isAbsoluteInRootPackage();
         }
-        return findChildByType(JetTokens.PACKAGE_KEYWORD) != null;
+        return findChildByType(KtTokens.PACKAGE_KEYWORD) != null;
     }
 
     @Nullable @IfNotParsed
-    public JetExpression getImportedReference() {
-        JetExpression[] references = getStubOrPsiChildren(JetStubElementTypes.INSIDE_DIRECTIVE_EXPRESSIONS, JetExpression.ARRAY_FACTORY);
+    public KtExpression getImportedReference() {
+        KtExpression[] references = getStubOrPsiChildren(KtStubElementTypes.INSIDE_DIRECTIVE_EXPRESSIONS, KtExpression.ARRAY_FACTORY);
         if (references.length > 0) {
             return references[0];
         }
@@ -66,8 +66,8 @@ public class JetImportDirective extends JetElementImplStub<KotlinImportDirective
         ASTNode childNode = getNode().getFirstChildNode();
         while (childNode != null) {
             IElementType tt = childNode.getElementType();
-            if (tt == JetTokens.AS_KEYWORD) asPassed = true;
-            if (asPassed && tt == JetTokens.IDENTIFIER) {
+            if (tt == KtTokens.AS_KEYWORD) asPassed = true;
+            if (asPassed && tt == KtTokens.IDENTIFIER) {
                 return childNode;
             }
 
@@ -94,7 +94,7 @@ public class JetImportDirective extends JetElementImplStub<KotlinImportDirective
         if (stub != null) {
             return stub.isAllUnder();
         }
-        return getNode().findChildByType(JetTokens.MUL) != null;
+        return getNode().findChildByType(KtTokens.MUL) != null;
     }
 
     @Nullable
@@ -133,13 +133,13 @@ public class JetImportDirective extends JetElementImplStub<KotlinImportDirective
     }
 
     @Nullable
-    private static FqName fqNameFromExpression(@Nullable JetExpression expression) {
+    private static FqName fqNameFromExpression(@Nullable KtExpression expression) {
         if (expression == null) {
             return null;
         }
 
-        if (expression instanceof JetDotQualifiedExpression) {
-            JetDotQualifiedExpression dotQualifiedExpression = (JetDotQualifiedExpression) expression;
+        if (expression instanceof KtDotQualifiedExpression) {
+            KtDotQualifiedExpression dotQualifiedExpression = (KtDotQualifiedExpression) expression;
             FqName parentFqn = fqNameFromExpression(dotQualifiedExpression.getReceiverExpression());
             Name child = nameFromExpression(dotQualifiedExpression.getSelectorExpression());
             if (child == null) {
@@ -150,8 +150,8 @@ public class JetImportDirective extends JetElementImplStub<KotlinImportDirective
             }
             return null;
         }
-        else if (expression instanceof JetSimpleNameExpression) {
-            JetSimpleNameExpression simpleNameExpression = (JetSimpleNameExpression) expression;
+        else if (expression instanceof KtSimpleNameExpression) {
+            KtSimpleNameExpression simpleNameExpression = (KtSimpleNameExpression) expression;
             return FqName.topLevel(simpleNameExpression.getReferencedNameAsName());
         }
         else {
@@ -160,13 +160,13 @@ public class JetImportDirective extends JetElementImplStub<KotlinImportDirective
     }
 
     @Nullable
-    private static Name nameFromExpression(@Nullable JetExpression expression) {
+    private static Name nameFromExpression(@Nullable KtExpression expression) {
         if (expression == null) {
             return null;
         }
 
-        if (expression instanceof JetSimpleNameExpression) {
-            return ((JetSimpleNameExpression) expression).getReferencedNameAsName();
+        if (expression instanceof KtSimpleNameExpression) {
+            return ((KtSimpleNameExpression) expression).getReferencedNameAsName();
         }
         else {
             throw new IllegalArgumentException("Can't construct name for: " + expression.getClass().toString());
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportList.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtImportList.java
similarity index 62%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportList.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtImportList.java
index 6645a58a297..5ce998f8ed4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportList.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtImportList.java
@@ -19,27 +19,27 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.List;
 
-public class JetImportList extends JetElementImplStub<KotlinPlaceHolderStub<JetImportList>> {
+public class KtImportList extends KtElementImplStub<KotlinPlaceHolderStub<KtImportList>> {
 
-    public JetImportList(@NotNull ASTNode node) {
+    public KtImportList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetImportList(@NotNull KotlinPlaceHolderStub<JetImportList> stub) {
-        super(stub, JetStubElementTypes.IMPORT_LIST);
+    public KtImportList(@NotNull KotlinPlaceHolderStub<KtImportList> stub) {
+        super(stub, KtStubElementTypes.IMPORT_LIST);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitImportList(this, data);
     }
 
     @NotNull
-    public List<JetImportDirective> getImports() {
-        return getStubOrPsiChildrenAsList(JetStubElementTypes.IMPORT_DIRECTIVE);
+    public List<KtImportDirective> getImports() {
+        return getStubOrPsiChildrenAsList(KtStubElementTypes.IMPORT_DIRECTIVE);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportsFactory.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtImportsFactory.java
similarity index 68%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportsFactory.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtImportsFactory.java
index 4e127025eb8..bc172b1763e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportsFactory.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtImportsFactory.java
@@ -27,34 +27,34 @@ import org.jetbrains.kotlin.resolve.ImportPath;
 import java.util.Collection;
 import java.util.Map;
 
-public class JetImportsFactory {
+public class KtImportsFactory {
     @NotNull private final Project project;
 
-    private final Map<ImportPath, JetImportDirective> importsCache = Maps.newHashMap();
+    private final Map<ImportPath, KtImportDirective> importsCache = Maps.newHashMap();
 
-    public JetImportsFactory(@NotNull Project project) {
+    public KtImportsFactory(@NotNull Project project) {
         this.project = project;
     }
 
     @NotNull
-    public JetImportDirective createImportDirective(@NotNull ImportPath importPath) {
-        JetImportDirective directive = importsCache.get(importPath);
+    public KtImportDirective createImportDirective(@NotNull ImportPath importPath) {
+        KtImportDirective directive = importsCache.get(importPath);
         if (directive != null) {
             return directive;
         }
 
-        JetImportDirective createdDirective = JetPsiFactoryKt.JetPsiFactory(project).createImportDirective(importPath);
+        KtImportDirective createdDirective = KtPsiFactoryKt.KtPsiFactory(project).createImportDirective(importPath);
         importsCache.put(importPath, createdDirective);
 
         return createdDirective;
     }
 
     @NotNull
-    public Collection<JetImportDirective> createImportDirectives(@NotNull Collection<ImportPath> importPaths) {
+    public Collection<KtImportDirective> createImportDirectives(@NotNull Collection<ImportPath> importPaths) {
         return Collections2.transform(importPaths,
-                                      new Function<ImportPath, JetImportDirective>() {
+                                      new Function<ImportPath, KtImportDirective>() {
                                           @Override
-                                          public JetImportDirective apply(@Nullable ImportPath path) {
+                                          public KtImportDirective apply(@Nullable ImportPath path) {
                                               assert path != null;
                                               return createImportDirective(path);
                                           }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetInitializerList.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtInitializerList.java
similarity index 59%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetInitializerList.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtInitializerList.java
index 04ade2dbeb6..4b1051693e1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetInitializerList.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtInitializerList.java
@@ -19,27 +19,27 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.Arrays;
 import java.util.List;
 
-public class JetInitializerList extends JetElementImplStub<KotlinPlaceHolderStub<JetInitializerList>> {
-    public JetInitializerList(@NotNull ASTNode node) {
+public class KtInitializerList extends KtElementImplStub<KotlinPlaceHolderStub<KtInitializerList>> {
+    public KtInitializerList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetInitializerList(@NotNull KotlinPlaceHolderStub<JetInitializerList> stub) {
-        super(stub, JetStubElementTypes.INITIALIZER_LIST);
+    public KtInitializerList(@NotNull KotlinPlaceHolderStub<KtInitializerList> stub) {
+        super(stub, KtStubElementTypes.INITIALIZER_LIST);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitInitializerList(this, data);
     }
 
     @NotNull
-    public List<JetDelegationSpecifier> getInitializers() {
-        return Arrays.asList(getStubOrPsiChildren(JetStubElementTypes.DELEGATION_SPECIFIER_TYPES, JetDelegationSpecifier.ARRAY_FACTORY));
+    public List<KtDelegationSpecifier> getInitializers() {
+        return Arrays.asList(getStubOrPsiChildren(KtStubElementTypes.DELEGATION_SPECIFIER_TYPES, KtDelegationSpecifier.ARRAY_FACTORY));
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetInstanceExpressionWithLabel.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtInstanceExpressionWithLabel.java
similarity index 68%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetInstanceExpressionWithLabel.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtInstanceExpressionWithLabel.java
index 920d43ca2ec..bbe81025a26 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetInstanceExpressionWithLabel.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtInstanceExpressionWithLabel.java
@@ -18,16 +18,16 @@ package org.jetbrains.kotlin.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
-public abstract class JetInstanceExpressionWithLabel extends JetExpressionWithLabel {
+public abstract class KtInstanceExpressionWithLabel extends KtExpressionWithLabel {
 
-    public JetInstanceExpressionWithLabel(@NotNull ASTNode node) {
+    public KtInstanceExpressionWithLabel(@NotNull ASTNode node) {
         super(node);
     }
 
     @NotNull
-    public JetReferenceExpression getInstanceReference() {
-        return (JetReferenceExpression) findChildByType(JetNodeTypes.REFERENCE_EXPRESSION);
+    public KtReferenceExpression getInstanceReference() {
+        return (KtReferenceExpression) findChildByType(KtNodeTypes.REFERENCE_EXPRESSION);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetIsExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtIsExpression.java
similarity index 59%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetIsExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtIsExpression.java
index 08d2027c88c..56b5a50b718 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetIsExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtIsExpression.java
@@ -19,37 +19,37 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-public class JetIsExpression extends JetExpressionImpl implements JetOperationExpression {
-    public JetIsExpression(@NotNull ASTNode node) {
+public class KtIsExpression extends KtExpressionImpl implements KtOperationExpression {
+    public KtIsExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitIsExpression(this, data);
     }
 
     @NotNull
-    public JetExpression getLeftHandSide() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getLeftHandSide() {
+        return findChildByClass(KtExpression.class);
     }
 
     @Nullable @IfNotParsed
-    public JetTypeReference getTypeReference() {
-        return (JetTypeReference) findChildByType(JetNodeTypes.TYPE_REFERENCE);
+    public KtTypeReference getTypeReference() {
+        return (KtTypeReference) findChildByType(KtNodeTypes.TYPE_REFERENCE);
     }
 
     @Override
     @NotNull
-    public JetSimpleNameExpression getOperationReference() {
-        return (JetSimpleNameExpression) findChildByType(JetNodeTypes.OPERATION_REFERENCE);
+    public KtSimpleNameExpression getOperationReference() {
+        return (KtSimpleNameExpression) findChildByType(KtNodeTypes.OPERATION_REFERENCE);
     }
 
     public boolean isNegated() {
-        return getOperationReference().getReferencedNameElementType() == JetTokens.NOT_IS;
+        return getOperationReference().getReferencedNameElementType() == KtTokens.NOT_IS;
     }
 
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetLabelReferenceExpression.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtLabelReferenceExpression.kt
similarity index 85%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetLabelReferenceExpression.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtLabelReferenceExpression.kt
index ccf4e8bbb61..919b03370e3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetLabelReferenceExpression.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtLabelReferenceExpression.kt
@@ -17,9 +17,9 @@
 package org.jetbrains.kotlin.psi
 
 import com.intellij.lang.ASTNode
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import com.intellij.psi.PsiElement
 
-public class JetLabelReferenceExpression(node: ASTNode) : JetSimpleNameExpressionImpl(node) {
+public class KtLabelReferenceExpression(node: ASTNode) : KtSimpleNameExpressionImpl(node) {
      public override fun getReferencedNameElement() = getIdentifier() ?: this
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetLabeledExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtLabeledExpression.java
similarity index 75%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetLabeledExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtLabeledExpression.java
index 455776305c4..f7e95987c34 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetLabeledExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtLabeledExpression.java
@@ -20,19 +20,19 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public class JetLabeledExpression extends JetExpressionWithLabel {
+public class KtLabeledExpression extends KtExpressionWithLabel {
 
-    public JetLabeledExpression(@NotNull ASTNode node) {
+    public KtLabeledExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Nullable @IfNotParsed
-    public JetExpression getBaseExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getBaseExpression() {
+        return findChildByClass(KtExpression.class);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitLabeledExpression(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetLiteralStringTemplateEntry.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtLiteralStringTemplateEntry.java
similarity index 79%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetLiteralStringTemplateEntry.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtLiteralStringTemplateEntry.java
index 7066588c00d..7d25eeaccca 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetLiteralStringTemplateEntry.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtLiteralStringTemplateEntry.java
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 
-public class JetLiteralStringTemplateEntry extends JetStringTemplateEntry {
-    public JetLiteralStringTemplateEntry(@NotNull ASTNode node) {
+public class KtLiteralStringTemplateEntry extends KtStringTemplateEntry {
+    public KtLiteralStringTemplateEntry(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitLiteralStringTemplateEntry(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetLoopExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtLoopExpression.java
similarity index 70%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetLoopExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtLoopExpression.java
index 81329897850..84c6de94fb3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetLoopExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtLoopExpression.java
@@ -20,27 +20,27 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-public abstract class JetLoopExpression extends JetExpressionImpl implements JetStatementExpression {
-    public JetLoopExpression(@NotNull ASTNode node) {
+public abstract class KtLoopExpression extends KtExpressionImpl implements KtStatementExpression {
+    public KtLoopExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Nullable
-    public JetExpression getBody() {
-        return findExpressionUnder(JetNodeTypes.BODY);
+    public KtExpression getBody() {
+        return findExpressionUnder(KtNodeTypes.BODY);
     }
 
     @Nullable
     @IfNotParsed
     public PsiElement getLeftParenthesis() {
-        return findChildByType(JetTokens.LPAR);
+        return findChildByType(KtTokens.LPAR);
     }
 
     @Nullable @IfNotParsed
     public PsiElement getRightParenthesis() {
-        return findChildByType(JetTokens.RPAR);
+        return findChildByType(KtTokens.RPAR);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetModifierList.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtModifierList.java
similarity index 68%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetModifierList.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtModifierList.java
index 83d0699bbe3..5e4aa141482 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetModifierList.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtModifierList.java
@@ -21,39 +21,39 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.stubs.IStubElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken;
 import org.jetbrains.kotlin.psi.psiUtil.JetPsiUtilKt;
 import org.jetbrains.kotlin.psi.stubs.KotlinModifierListStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.List;
 
-public abstract class JetModifierList extends JetElementImplStub<KotlinModifierListStub> implements JetAnnotationsContainer {
+public abstract class KtModifierList extends KtElementImplStub<KotlinModifierListStub> implements KtAnnotationsContainer {
 
-    public JetModifierList(@NotNull KotlinModifierListStub stub, @NotNull IStubElementType nodeType) {
+    public KtModifierList(@NotNull KotlinModifierListStub stub, @NotNull IStubElementType nodeType) {
         super(stub, nodeType);
     }
 
-    public JetModifierList(@NotNull ASTNode node) {
+    public KtModifierList(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitModifierList(this, data);
     }
 
     @NotNull
-    public List<JetAnnotation> getAnnotations() {
-        return getStubOrPsiChildrenAsList(JetStubElementTypes.ANNOTATION);
+    public List<KtAnnotation> getAnnotations() {
+        return getStubOrPsiChildrenAsList(KtStubElementTypes.ANNOTATION);
     }
 
     @NotNull
-    public List<JetAnnotationEntry> getAnnotationEntries() {
+    public List<KtAnnotationEntry> getAnnotationEntries() {
         return JetPsiUtilKt.collectAnnotationEntriesFromStubOrPsi(this);
     }
 
-    public boolean hasModifier(@NotNull JetModifierKeywordToken tokenType) {
+    public boolean hasModifier(@NotNull KtModifierKeywordToken tokenType) {
         KotlinModifierListStub stub = getStub();
         if (stub != null) {
             return stub.hasModifier(tokenType);
@@ -62,7 +62,7 @@ public abstract class JetModifierList extends JetElementImplStub<KotlinModifierL
     }
 
     @Nullable
-    public PsiElement getModifier(@NotNull JetModifierKeywordToken tokenType) {
+    public PsiElement getModifier(@NotNull KtModifierKeywordToken tokenType) {
         return findChildByType(tokenType);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetModifierListOwner.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtModifierListOwner.java
similarity index 63%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetModifierListOwner.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtModifierListOwner.java
index 66b73f0df43..55a306c6bd6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetModifierListOwner.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtModifierListOwner.java
@@ -19,17 +19,17 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken;
 
-public interface JetModifierListOwner extends PsiElement, JetAnnotated {
+public interface KtModifierListOwner extends PsiElement, KtAnnotated {
     @Nullable
-    JetModifierList getModifierList();
+    KtModifierList getModifierList();
 
-    boolean hasModifier(@NotNull JetModifierKeywordToken modifier);
+    boolean hasModifier(@NotNull KtModifierKeywordToken modifier);
 
-    void addModifier(@NotNull JetModifierKeywordToken modifier);
-    void removeModifier(@NotNull JetModifierKeywordToken modifier);
+    void addModifier(@NotNull KtModifierKeywordToken modifier);
+    void removeModifier(@NotNull KtModifierKeywordToken modifier);
 
     @NotNull
-    JetAnnotationEntry addAnnotationEntry(@NotNull JetAnnotationEntry annotationEntry);
+    KtAnnotationEntry addAnnotationEntry(@NotNull KtAnnotationEntry annotationEntry);
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetModifierListOwnerStub.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtModifierListOwnerStub.java
similarity index 61%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetModifierListOwnerStub.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtModifierListOwnerStub.java
index 39d714fe5d1..5d7e52f53d2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetModifierListOwnerStub.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtModifierListOwnerStub.java
@@ -21,62 +21,62 @@ import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken;
 import org.jetbrains.kotlin.psi.addRemoveModifier.AddRemoveModifierKt;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetModifierListOwnerStub<T extends StubElement<?>> extends JetElementImplStub<T> implements JetModifierListOwner {
-    public JetModifierListOwnerStub(ASTNode node) {
+public class KtModifierListOwnerStub<T extends StubElement<?>> extends KtElementImplStub<T> implements KtModifierListOwner {
+    public KtModifierListOwnerStub(ASTNode node) {
         super(node);
     }
 
-    public JetModifierListOwnerStub(T stub, IStubElementType nodeType) {
+    public KtModifierListOwnerStub(T stub, IStubElementType nodeType) {
         super(stub, nodeType);
     }
 
     @Override
     @Nullable
-    public JetModifierList getModifierList() {
-        return getStubOrPsiChild(JetStubElementTypes.MODIFIER_LIST);
+    public KtModifierList getModifierList() {
+        return getStubOrPsiChild(KtStubElementTypes.MODIFIER_LIST);
     }
 
     @Override
-    public boolean hasModifier(@NotNull JetModifierKeywordToken modifier) {
-        JetModifierList modifierList = getModifierList();
+    public boolean hasModifier(@NotNull KtModifierKeywordToken modifier) {
+        KtModifierList modifierList = getModifierList();
         return modifierList != null && modifierList.hasModifier(modifier);
     }
 
     @Override
-    public void addModifier(@NotNull JetModifierKeywordToken modifier) {
+    public void addModifier(@NotNull KtModifierKeywordToken modifier) {
         AddRemoveModifierKt.addModifier(this, modifier);
     }
 
     @Override
-    public void removeModifier(@NotNull JetModifierKeywordToken modifier) {
+    public void removeModifier(@NotNull KtModifierKeywordToken modifier) {
         AddRemoveModifierKt.removeModifier(this, modifier);
     }
 
     @NotNull
     @Override
-    public JetAnnotationEntry addAnnotationEntry(@NotNull JetAnnotationEntry annotationEntry) {
+    public KtAnnotationEntry addAnnotationEntry(@NotNull KtAnnotationEntry annotationEntry) {
         return AddRemoveModifierKt.addAnnotationEntry(this, annotationEntry);
     }
 
     @Override
     @NotNull
-    public List<JetAnnotationEntry> getAnnotationEntries() {
-        JetModifierList modifierList = getModifierList();
+    public List<KtAnnotationEntry> getAnnotationEntries() {
+        KtModifierList modifierList = getModifierList();
         if (modifierList == null) return Collections.emptyList();
         return modifierList.getAnnotationEntries();
     }
 
     @Override
     @NotNull
-    public List<JetAnnotation> getAnnotations() {
-        JetModifierList modifierList = getModifierList();
+    public List<KtAnnotation> getAnnotations() {
+        KtModifierList modifierList = getModifierList();
         if (modifierList == null) return Collections.emptyList();
         return modifierList.getAnnotations();
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetMultiDeclaration.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtMultiDeclaration.java
similarity index 70%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetMultiDeclaration.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtMultiDeclaration.java
index 1fa8d49a870..d36705b2cb8 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetMultiDeclaration.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtMultiDeclaration.java
@@ -22,35 +22,35 @@ import com.intellij.psi.tree.TokenSet;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
 import java.util.List;
 
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
+import static org.jetbrains.kotlin.lexer.KtTokens.*;
 
-public class JetMultiDeclaration extends JetDeclarationImpl {
-    public JetMultiDeclaration(@NotNull ASTNode node) {
+public class KtMultiDeclaration extends KtDeclarationImpl {
+    public KtMultiDeclaration(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitMultiDeclaration(this, data);
     }
 
     @NotNull
-    public List<JetMultiDeclarationEntry> getEntries() {
-        return findChildrenByType(JetNodeTypes.MULTI_VARIABLE_DECLARATION_ENTRY);
+    public List<KtMultiDeclarationEntry> getEntries() {
+        return findChildrenByType(KtNodeTypes.MULTI_VARIABLE_DECLARATION_ENTRY);
     }
 
     @Nullable
-    public JetExpression getInitializer() {
+    public KtExpression getInitializer() {
         ASTNode eqNode = getNode().findChildByType(EQ);
         if (eqNode == null) {
             return null;
         }
-        return PsiTreeUtil.getNextSiblingOfType(eqNode.getPsi(), JetExpression.class);
+        return PsiTreeUtil.getNextSiblingOfType(eqNode.getPsi(), KtExpression.class);
     }
 
     @Nullable
@@ -60,11 +60,11 @@ public class JetMultiDeclaration extends JetDeclarationImpl {
 
     @Nullable
     public PsiElement getRPar() {
-        return findChildByType(JetTokens.RPAR);
+        return findChildByType(KtTokens.RPAR);
     }
 
     @Nullable
     public PsiElement getLPar() {
-        return findChildByType(JetTokens.LPAR);
+        return findChildByType(KtTokens.LPAR);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetMultiDeclarationEntry.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtMultiDeclarationEntry.java
similarity index 67%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetMultiDeclarationEntry.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtMultiDeclarationEntry.java
index 2243659ba21..e184ab3dbf5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetMultiDeclarationEntry.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtMultiDeclarationEntry.java
@@ -23,94 +23,94 @@ import com.intellij.psi.search.SearchScope;
 import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.typeRefHelpers.TypeRefHelpersKt;
 
 import java.util.Collections;
 import java.util.List;
 
-import static org.jetbrains.kotlin.lexer.JetTokens.VAL_KEYWORD;
-import static org.jetbrains.kotlin.lexer.JetTokens.VAR_KEYWORD;
+import static org.jetbrains.kotlin.lexer.KtTokens.VAL_KEYWORD;
+import static org.jetbrains.kotlin.lexer.KtTokens.VAR_KEYWORD;
 
-public class JetMultiDeclarationEntry extends JetNamedDeclarationNotStubbed implements JetVariableDeclaration {
-    public JetMultiDeclarationEntry(@NotNull ASTNode node) {
+public class KtMultiDeclarationEntry extends KtNamedDeclarationNotStubbed implements KtVariableDeclaration {
+    public KtMultiDeclarationEntry(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public JetTypeReference getTypeReference() {
+    public KtTypeReference getTypeReference() {
         return TypeRefHelpersKt.getTypeReference(this);
     }
 
     @Override
     @Nullable
-    public JetTypeReference setTypeReference(@Nullable JetTypeReference typeRef) {
+    public KtTypeReference setTypeReference(@Nullable KtTypeReference typeRef) {
         return TypeRefHelpersKt.setTypeReference(this, getNameIdentifier(), typeRef);
     }
 
     @Nullable
     @Override
     public PsiElement getColon() {
-        return findChildByType(JetTokens.COLON);
+        return findChildByType(KtTokens.COLON);
     }
 
     @Nullable
     @Override
-    public JetParameterList getValueParameterList() {
+    public KtParameterList getValueParameterList() {
         return null;
     }
 
     @NotNull
     @Override
-    public List<JetParameter> getValueParameters() {
+    public List<KtParameter> getValueParameters() {
         return Collections.emptyList();
     }
 
     @Nullable
     @Override
-    public JetTypeReference getReceiverTypeReference() {
+    public KtTypeReference getReceiverTypeReference() {
         return null;
     }
 
     @Nullable
     @Override
-    public JetTypeParameterList getTypeParameterList() {
+    public KtTypeParameterList getTypeParameterList() {
         return null;
     }
 
     @Nullable
     @Override
-    public JetTypeConstraintList getTypeConstraintList() {
+    public KtTypeConstraintList getTypeConstraintList() {
         return null;
     }
 
     @NotNull
     @Override
-    public List<JetTypeConstraint> getTypeConstraints() {
+    public List<KtTypeConstraint> getTypeConstraints() {
         return Collections.emptyList();
     }
 
     @NotNull
     @Override
-    public List<JetTypeParameter> getTypeParameters() {
+    public List<KtTypeParameter> getTypeParameters() {
         return Collections.emptyList();
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitMultiDeclarationEntry(this, data);
     }
 
     @Override
     public boolean isVar() {
-        return getParentNode().findChildByType(JetTokens.VAR_KEYWORD) != null;
+        return getParentNode().findChildByType(KtTokens.VAR_KEYWORD) != null;
     }
 
     @Nullable
     @Override
-    public JetExpression getInitializer() {
+    public KtExpression getInitializer() {
         return null;
     }
 
@@ -122,7 +122,7 @@ public class JetMultiDeclarationEntry extends JetNamedDeclarationNotStubbed impl
     @NotNull
     private ASTNode getParentNode() {
         ASTNode parent = getNode().getTreeParent();
-        assert parent.getElementType() == JetNodeTypes.MULTI_VARIABLE_DECLARATION;
+        assert parent.getElementType() == KtNodeTypes.MULTI_VARIABLE_DECLARATION;
         return parent;
     }
 
@@ -142,7 +142,7 @@ public class JetMultiDeclarationEntry extends JetNamedDeclarationNotStubbed impl
     @NotNull
     @Override
     public SearchScope getUseScope() {
-        JetElement enclosingBlock = JetPsiUtil.getEnclosingElementForLocalDeclaration(this, false);
+        KtElement enclosingBlock = KtPsiUtil.getEnclosingElementForLocalDeclaration(this, false);
         if (enclosingBlock != null) return new LocalSearchScope(enclosingBlock);
 
         return super.getUseScope();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNameReferenceExpression.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNameReferenceExpression.kt
similarity index 71%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetNameReferenceExpression.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtNameReferenceExpression.kt
index e2132dc5732..2ea47273b90 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNameReferenceExpression.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNameReferenceExpression.kt
@@ -21,17 +21,17 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.tree.IElementType
 import com.intellij.psi.tree.TokenSet
 import org.jetbrains.kotlin.psi.stubs.KotlinNameReferenceExpressionStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 
-import org.jetbrains.kotlin.lexer.JetTokens.*
+import org.jetbrains.kotlin.lexer.KtTokens.*
 
-public class JetNameReferenceExpression : JetExpressionImplStub<KotlinNameReferenceExpressionStub>, JetSimpleNameExpression {
+public class KtNameReferenceExpression : KtExpressionImplStub<KotlinNameReferenceExpressionStub>, KtSimpleNameExpression {
     public constructor(node: ASTNode) : super(node) {
     }
 
-    public constructor(stub: KotlinNameReferenceExpressionStub) : super(stub, JetStubElementTypes.REFERENCE_EXPRESSION) {
+    public constructor(stub: KotlinNameReferenceExpressionStub) : super(stub, KtStubElementTypes.REFERENCE_EXPRESSION) {
     }
 
     override fun getReferencedName(): String {
@@ -39,11 +39,11 @@ public class JetNameReferenceExpression : JetExpressionImplStub<KotlinNameRefere
         if (stub != null) {
             return stub.getReferencedName()
         }
-        return JetSimpleNameExpressionImpl.getReferencedNameImpl(this)
+        return KtSimpleNameExpressionImpl.getReferencedNameImpl(this)
     }
 
     override fun getReferencedNameAsName(): Name {
-        return JetSimpleNameExpressionImpl.getReferencedNameAsNameImpl(this)
+        return KtSimpleNameExpressionImpl.getReferencedNameAsNameImpl(this)
     }
 
     override fun getReferencedNameElement(): PsiElement {
@@ -52,14 +52,14 @@ public class JetNameReferenceExpression : JetExpressionImplStub<KotlinNameRefere
     }
 
     override fun getIdentifier(): PsiElement? {
-        return findChildByType(JetTokens.IDENTIFIER)
+        return findChildByType(KtTokens.IDENTIFIER)
     }
 
     override fun getReferencedNameElementType(): IElementType {
-        return JetSimpleNameExpressionImpl.getReferencedNameElementTypeImpl(this)
+        return KtSimpleNameExpressionImpl.getReferencedNameElementTypeImpl(this)
     }
 
-    override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D): R {
+    override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D): R {
         return visitor.visitSimpleNameExpression(this, data)
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamed.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamed.java
similarity index 96%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamed.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamed.java
index 2cbac402ccb..ea63ff8c31a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamed.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamed.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.psi;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.name.Name;
 
-public interface JetNamed {
+public interface KtNamed {
     @Nullable
     Name getNameAsName();
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclaration.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedDeclaration.java
similarity index 88%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclaration.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedDeclaration.java
index 0d4194e4d9d..3a2992f9390 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclaration.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedDeclaration.java
@@ -22,7 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 
-public interface JetNamedDeclaration extends JetDeclaration, PsiNameIdentifierOwner, JetStatementExpression, JetNamed {
+public interface KtNamedDeclaration extends KtDeclaration, PsiNameIdentifierOwner, KtStatementExpression, KtNamed {
     @NotNull
     Name getNameAsSafeName();
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclarationNotStubbed.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedDeclarationNotStubbed.java
similarity index 76%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclarationNotStubbed.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedDeclarationNotStubbed.java
index a1f801b941d..9bc17a7d667 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclarationNotStubbed.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedDeclarationNotStubbed.java
@@ -22,14 +22,14 @@ import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-import static org.jetbrains.kotlin.psi.JetPsiFactoryKt.JetPsiFactory;
+import static org.jetbrains.kotlin.psi.KtPsiFactoryKt.KtPsiFactory;
 
 // TODO: Remove when all named declarations get stubs
 @Deprecated
-abstract class JetNamedDeclarationNotStubbed extends JetDeclarationImpl implements JetNamedDeclaration {
-    public JetNamedDeclarationNotStubbed(@NotNull ASTNode node) {
+abstract class KtNamedDeclarationNotStubbed extends KtDeclarationImpl implements KtNamedDeclaration {
+    public KtNamedDeclarationNotStubbed(@NotNull ASTNode node) {
         super(node);
     }
 
@@ -38,7 +38,7 @@ abstract class JetNamedDeclarationNotStubbed extends JetDeclarationImpl implemen
         PsiElement identifier = getNameIdentifier();
         if (identifier != null) {
             String text = identifier.getText();
-            return text != null ? JetPsiUtil.unquoteIdentifier(text) : null;
+            return text != null ? KtPsiUtil.unquoteIdentifier(text) : null;
         }
         else {
             return null;
@@ -54,17 +54,17 @@ abstract class JetNamedDeclarationNotStubbed extends JetDeclarationImpl implemen
     @Override
     @NotNull
     public Name getNameAsSafeName() {
-        return JetPsiUtil.safeName(getName());
+        return KtPsiUtil.safeName(getName());
     }
 
     @Override
     public PsiElement getNameIdentifier() {
-        return findChildByType(JetTokens.IDENTIFIER);
+        return findChildByType(KtTokens.IDENTIFIER);
     }
 
     @Override
     public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
-        return getNameIdentifier().replace(JetPsiFactory(this).createNameIdentifier(name));
+        return getNameIdentifier().replace(KtPsiFactory(this).createNameIdentifier(name));
     }
 
     @Override
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclarationStub.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedDeclarationStub.java
similarity index 70%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclarationStub.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedDeclarationStub.java
index dedc8188887..0cb3f4be6d5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclarationStub.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedDeclarationStub.java
@@ -26,20 +26,20 @@ import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.stubs.KotlinStubWithFqName;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
 
-import static org.jetbrains.kotlin.psi.JetPsiFactoryKt.JetPsiFactory;
+import static org.jetbrains.kotlin.psi.KtPsiFactoryKt.KtPsiFactory;
 
-abstract class JetNamedDeclarationStub<T extends KotlinStubWithFqName<?>> extends JetDeclarationStub<T> implements JetNamedDeclaration {
-    public JetNamedDeclarationStub(@NotNull T stub, @NotNull IStubElementType nodeType) {
+abstract class KtNamedDeclarationStub<T extends KotlinStubWithFqName<?>> extends KtDeclarationStub<T> implements KtNamedDeclaration {
+    public KtNamedDeclarationStub(@NotNull T stub, @NotNull IStubElementType nodeType) {
         super(stub, nodeType);
     }
 
-    public JetNamedDeclarationStub(@NotNull ASTNode node) {
+    public KtNamedDeclarationStub(@NotNull ASTNode node) {
         super(node);
     }
 
@@ -53,7 +53,7 @@ abstract class JetNamedDeclarationStub<T extends KotlinStubWithFqName<?>> extend
         PsiElement identifier = getNameIdentifier();
         if (identifier != null) {
             String text = identifier.getText();
-            return text != null ? JetPsiUtil.unquoteIdentifier(text) : null;
+            return text != null ? KtPsiUtil.unquoteIdentifier(text) : null;
         }
         else {
             return null;
@@ -69,12 +69,12 @@ abstract class JetNamedDeclarationStub<T extends KotlinStubWithFqName<?>> extend
     @Override
     @NotNull
     public Name getNameAsSafeName() {
-        return JetPsiUtil.safeName(getName());
+        return KtPsiUtil.safeName(getName());
     }
 
     @Override
     public PsiElement getNameIdentifier() {
-        return findChildByType(JetTokens.IDENTIFIER);
+        return findChildByType(KtTokens.IDENTIFIER);
     }
 
     @Override
@@ -82,14 +82,14 @@ abstract class JetNamedDeclarationStub<T extends KotlinStubWithFqName<?>> extend
         PsiElement identifier = getNameIdentifier();
         if (identifier == null) return null;
 
-        JetModifierList modifierList = getModifierList();
+        KtModifierList modifierList = getModifierList();
         if (modifierList != null &&
-            modifierList.hasModifier(JetTokens.OPERATOR_KEYWORD) &&
+            modifierList.hasModifier(KtTokens.OPERATOR_KEYWORD) &&
             !OperatorConventions.isConventionName(Name.identifier(name))) {
-            removeModifier(JetTokens.OPERATOR_KEYWORD);
+            removeModifier(KtTokens.OPERATOR_KEYWORD);
         }
 
-        return identifier.replace(JetPsiFactory(this).createNameIdentifier(name));
+        return identifier.replace(KtPsiFactory(this).createNameIdentifier(name));
     }
 
     @Override
@@ -101,13 +101,13 @@ abstract class JetNamedDeclarationStub<T extends KotlinStubWithFqName<?>> extend
     @NotNull
     @Override
     public SearchScope getUseScope() {
-        JetElement enclosingBlock = JetPsiUtil.getEnclosingElementForLocalDeclaration(this, false);
+        KtElement enclosingBlock = KtPsiUtil.getEnclosingElementForLocalDeclaration(this, false);
         if (enclosingBlock != null) return new LocalSearchScope(enclosingBlock);
 
-        if (hasModifier(JetTokens.PRIVATE_KEYWORD)) {
-            JetElement containingClass = PsiTreeUtil.getParentOfType(this, JetClassOrObject.class);
-            if (containingClass instanceof JetObjectDeclaration && ((JetObjectDeclaration) containingClass).isCompanion()) {
-                JetElement companionObjectClass = PsiTreeUtil.getParentOfType(containingClass, JetClassOrObject.class);
+        if (hasModifier(KtTokens.PRIVATE_KEYWORD)) {
+            KtElement containingClass = PsiTreeUtil.getParentOfType(this, KtClassOrObject.class);
+            if (containingClass instanceof KtObjectDeclaration && ((KtObjectDeclaration) containingClass).isCompanion()) {
+                KtElement companionObjectClass = PsiTreeUtil.getParentOfType(containingClass, KtClassOrObject.class);
                 if (companionObjectClass != null) {
                     containingClass = companionObjectClass;
                 }
@@ -129,6 +129,6 @@ abstract class JetNamedDeclarationStub<T extends KotlinStubWithFqName<?>> extend
         if (stub != null) {
             return stub.getFqName();
         }
-        return JetNamedDeclarationUtil.getFQName(this);
+        return KtNamedDeclarationUtil.getFQName(this);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclarationUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedDeclarationUtil.java
similarity index 65%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclarationUtil.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedDeclarationUtil.java
index afbc0541b03..cad036d1e79 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclarationUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedDeclarationUtil.java
@@ -17,23 +17,22 @@
 package org.jetbrains.kotlin.psi;
 
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.FqNameUnsafe;
 import org.jetbrains.kotlin.name.Name;
 
-public final class JetNamedDeclarationUtil {
+public final class KtNamedDeclarationUtil {
     @Nullable
-    public static FqNameUnsafe getUnsafeFQName(@NotNull JetNamedDeclaration namedDeclaration) {
+    public static FqNameUnsafe getUnsafeFQName(@NotNull KtNamedDeclaration namedDeclaration) {
         FqName fqName = namedDeclaration.getFqName();
         return fqName != null ? fqName.toUnsafe() : null;
     }
 
     @Nullable
     //NOTE: use JetNamedDeclaration#getFqName instead
-    /*package private*/ static FqName getFQName(@NotNull JetNamedDeclaration namedDeclaration) {
+    /*package private*/ static FqName getFQName(@NotNull KtNamedDeclaration namedDeclaration) {
         Name name = namedDeclaration.getNameAsName();
         if (name == null) {
             return null;
@@ -49,31 +48,31 @@ public final class JetNamedDeclarationUtil {
     }
 
     @Nullable
-    public static FqName getParentFqName(@NotNull JetNamedDeclaration namedDeclaration) {
+    public static FqName getParentFqName(@NotNull KtNamedDeclaration namedDeclaration) {
         PsiElement parent = namedDeclaration.getParent();
-        if (parent instanceof JetClassBody) {
+        if (parent instanceof KtClassBody) {
             // One nesting to JetClassBody doesn't affect to qualified name
             parent = parent.getParent();
         }
 
-        if (parent instanceof JetFile) {
-            return ((JetFile) parent).getPackageFqName();
+        if (parent instanceof KtFile) {
+            return ((KtFile) parent).getPackageFqName();
         }
-        else if (parent instanceof JetNamedFunction || parent instanceof JetClass) {
-            return getFQName((JetNamedDeclaration) parent);
+        else if (parent instanceof KtNamedFunction || parent instanceof KtClass) {
+            return getFQName((KtNamedDeclaration) parent);
         }
-        else if (namedDeclaration instanceof JetParameter) {
-            JetClassOrObject constructorClass = JetPsiUtil.getClassIfParameterIsProperty((JetParameter) namedDeclaration);
+        else if (namedDeclaration instanceof KtParameter) {
+            KtClassOrObject constructorClass = KtPsiUtil.getClassIfParameterIsProperty((KtParameter) namedDeclaration);
             if (constructorClass != null) {
                 return getFQName(constructorClass);
             }
         }
-        else if (parent instanceof JetObjectDeclaration) {
-             return getFQName((JetNamedDeclaration) parent);
+        else if (parent instanceof KtObjectDeclaration) {
+             return getFQName((KtNamedDeclaration) parent);
         }
         return null;
     }
 
-    private JetNamedDeclarationUtil() {
+    private KtNamedDeclarationUtil() {
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedFunction.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedFunction.java
similarity index 71%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedFunction.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedFunction.java
index d38593a7dac..385f30bb88c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedFunction.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNamedFunction.java
@@ -25,26 +25,26 @@ import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.stubs.KotlinFunctionStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 import org.jetbrains.kotlin.psi.typeRefHelpers.TypeRefHelpersKt;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetNamedFunction extends JetTypeParameterListOwnerStub<KotlinFunctionStub>
-        implements JetFunction, JetWithExpressionInitializer, PsiModifiableCodeBlock {
-    public JetNamedFunction(@NotNull ASTNode node) {
+public class KtNamedFunction extends KtTypeParameterListOwnerStub<KotlinFunctionStub>
+        implements KtFunction, KtWithExpressionInitializer, PsiModifiableCodeBlock {
+    public KtNamedFunction(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetNamedFunction(@NotNull KotlinFunctionStub stub) {
-        super(stub, JetStubElementTypes.FUNCTION);
+    public KtNamedFunction(@NotNull KotlinFunctionStub stub) {
+        super(stub, KtStubElementTypes.FUNCTION);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitNamedFunction(this, data);
     }
 
@@ -57,7 +57,7 @@ public class JetNamedFunction extends JetTypeParameterListOwnerStub<KotlinFuncti
     }
 
     private boolean hasTypeParameterListBeforeFunctionNameByTree() {
-        JetTypeParameterList typeParameterList = getTypeParameterList();
+        KtTypeParameterList typeParameterList = getTypeParameterList();
         if (typeParameterList == null) {
             return false;
         }
@@ -80,19 +80,19 @@ public class JetNamedFunction extends JetTypeParameterListOwnerStub<KotlinFuncti
     @Nullable
     @IfNotParsed // "function" with no "fun" keyword is created by parser for "{...}" on top-level or in class body
     public PsiElement getFunKeyword() {
-        return findChildByType(JetTokens.FUN_KEYWORD);
+        return findChildByType(KtTokens.FUN_KEYWORD);
     }
 
     @Override
     @Nullable
     public PsiElement getEqualsToken() {
-        return findChildByType(JetTokens.EQ);
+        return findChildByType(KtTokens.EQ);
     }
 
     @Override
     @Nullable
-    public JetExpression getInitializer() {
-        return PsiTreeUtil.getNextSiblingOfType(getEqualsToken(), JetExpression.class);
+    public KtExpression getInitializer() {
+        return PsiTreeUtil.getNextSiblingOfType(getEqualsToken(), KtExpression.class);
     }
 
     @Override
@@ -107,21 +107,21 @@ public class JetNamedFunction extends JetTypeParameterListOwnerStub<KotlinFuncti
 
     @Override
     @Nullable
-    public JetParameterList getValueParameterList() {
-        return getStubOrPsiChild(JetStubElementTypes.VALUE_PARAMETER_LIST);
+    public KtParameterList getValueParameterList() {
+        return getStubOrPsiChild(KtStubElementTypes.VALUE_PARAMETER_LIST);
     }
 
     @Override
     @NotNull
-    public List<JetParameter> getValueParameters() {
-        JetParameterList list = getValueParameterList();
-        return list != null ? list.getParameters() : Collections.<JetParameter>emptyList();
+    public List<KtParameter> getValueParameters() {
+        KtParameterList list = getValueParameterList();
+        return list != null ? list.getParameters() : Collections.<KtParameter>emptyList();
     }
 
     @Override
     @Nullable
-    public JetExpression getBodyExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getBodyExpression() {
+        return findChildByClass(KtExpression.class);
     }
 
     @Override
@@ -140,13 +140,13 @@ public class JetNamedFunction extends JetTypeParameterListOwnerStub<KotlinFuncti
 
     @Override
     @Nullable
-    public JetTypeReference getReceiverTypeReference() {
+    public KtTypeReference getReceiverTypeReference() {
         KotlinFunctionStub stub = getStub();
         if (stub != null) {
             if (!stub.isExtension()) {
                 return null;
             }
-            List<JetTypeReference> childTypeReferences = getStubOrPsiChildrenAsList(JetStubElementTypes.TYPE_REFERENCE);
+            List<KtTypeReference> childTypeReferences = getStubOrPsiChildrenAsList(KtStubElementTypes.TYPE_REFERENCE);
             if (!childTypeReferences.isEmpty()) {
                 return childTypeReferences.get(0);
             }
@@ -158,13 +158,13 @@ public class JetNamedFunction extends JetTypeParameterListOwnerStub<KotlinFuncti
     }
 
     @Nullable
-    private JetTypeReference getReceiverTypeRefByTree() {
+    private KtTypeReference getReceiverTypeRefByTree() {
         PsiElement child = getFirstChild();
         while (child != null) {
             IElementType tt = child.getNode().getElementType();
-            if (tt == JetTokens.LPAR || tt == JetTokens.COLON) break;
-            if (child instanceof JetTypeReference) {
-                return (JetTypeReference) child;
+            if (tt == KtTokens.LPAR || tt == KtTokens.COLON) break;
+            if (child instanceof KtTypeReference) {
+                return (KtTypeReference) child;
             }
             child = child.getNextSibling();
         }
@@ -174,10 +174,10 @@ public class JetNamedFunction extends JetTypeParameterListOwnerStub<KotlinFuncti
 
     @Override
     @Nullable
-    public JetTypeReference getTypeReference() {
+    public KtTypeReference getTypeReference() {
         KotlinFunctionStub stub = getStub();
         if (stub != null) {
-            List<JetTypeReference> typeReferences = getStubOrPsiChildrenAsList(JetStubElementTypes.TYPE_REFERENCE);
+            List<KtTypeReference> typeReferences = getStubOrPsiChildrenAsList(KtStubElementTypes.TYPE_REFERENCE);
             int returnTypeIndex = stub.isExtension() ? 1 : 0;
             if (returnTypeIndex >= typeReferences.size()) {
                 return null;
@@ -189,20 +189,20 @@ public class JetNamedFunction extends JetTypeParameterListOwnerStub<KotlinFuncti
 
     @Override
     @Nullable
-    public JetTypeReference setTypeReference(@Nullable JetTypeReference typeRef) {
+    public KtTypeReference setTypeReference(@Nullable KtTypeReference typeRef) {
         return TypeRefHelpersKt.setTypeReference(this, getValueParameterList(), typeRef);
     }
 
     @Nullable
     @Override
     public PsiElement getColon() {
-        return findChildByType(JetTokens.COLON);
+        return findChildByType(KtTokens.COLON);
     }
 
     @Override
     public boolean isLocal() {
         PsiElement parent = getParent();
-        return !(parent instanceof JetFile || parent instanceof JetClassBody);
+        return !(parent instanceof KtFile || parent instanceof KtClassBody);
     }
 
     public boolean isTopLevel() {
@@ -211,7 +211,7 @@ public class JetNamedFunction extends JetTypeParameterListOwnerStub<KotlinFuncti
             return stub.isTopLevel();
         }
 
-        return getParent() instanceof JetFile;
+        return getParent() instanceof KtFile;
     }
 
     @Override
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNullableType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNullableType.java
similarity index 53%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetNullableType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtNullableType.java
index e05ae4fdd00..6f8e2f8ab7f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNullableType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtNullableType.java
@@ -19,42 +19,42 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetNullableType extends JetElementImplStub<KotlinPlaceHolderStub<JetNullableType>> implements JetTypeElement {
-    public JetNullableType(@NotNull ASTNode node) {
+public class KtNullableType extends KtElementImplStub<KotlinPlaceHolderStub<KtNullableType>> implements KtTypeElement {
+    public KtNullableType(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetNullableType(@NotNull KotlinPlaceHolderStub<JetNullableType> stub) {
-        super(stub, JetStubElementTypes.NULLABLE_TYPE);
+    public KtNullableType(@NotNull KotlinPlaceHolderStub<KtNullableType> stub) {
+        super(stub, KtStubElementTypes.NULLABLE_TYPE);
     }
 
     @NotNull
     public ASTNode getQuestionMarkNode() {
-        return getNode().findChildByType(JetTokens.QUEST);
+        return getNode().findChildByType(KtTokens.QUEST);
     }
 
     @NotNull
     @Override
-    public List<JetTypeReference> getTypeArgumentsAsTypes() {
-        JetTypeElement innerType = getInnerType();
-        return innerType == null ? Collections.<JetTypeReference>emptyList() : innerType.getTypeArgumentsAsTypes();
+    public List<KtTypeReference> getTypeArgumentsAsTypes() {
+        KtTypeElement innerType = getInnerType();
+        return innerType == null ? Collections.<KtTypeReference>emptyList() : innerType.getTypeArgumentsAsTypes();
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitNullableType(this, data);
     }
 
     @Nullable
     @IfNotParsed
-    public JetTypeElement getInnerType() {
-        return JetStubbedPsiUtil.getStubOrPsiChild(this, JetStubElementTypes.TYPE_ELEMENT_TYPES, JetTypeElement.ARRAY_FACTORY);
+    public KtTypeElement getInnerType() {
+        return KtStubbedPsiUtil.getStubOrPsiChild(this, KtStubElementTypes.TYPE_ELEMENT_TYPES, KtTypeElement.ARRAY_FACTORY);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclaration.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtObjectDeclaration.kt
similarity index 82%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclaration.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtObjectDeclaration.kt
index c503ace1933..83f683bed81 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclaration.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtObjectDeclaration.kt
@@ -19,14 +19,14 @@ package org.jetbrains.kotlin.psi
 import com.intellij.lang.ASTNode
 import com.intellij.psi.PsiElement
 import org.jetbrains.annotations.NonNls
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.SpecialNames
 import org.jetbrains.kotlin.psi.stubs.KotlinObjectStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 
-public class JetObjectDeclaration : JetClassOrObject {
+public class KtObjectDeclaration : KtClassOrObject {
     public constructor(node: ASTNode) : super(node)
-    public constructor(stub: KotlinObjectStub) : super(stub, JetStubElementTypes.OBJECT_DECLARATION)
+    public constructor(stub: KotlinObjectStub) : super(stub, KtStubElementTypes.OBJECT_DECLARATION)
 
     private val _stub: KotlinObjectStub?
         get() = stub as? KotlinObjectStub
@@ -47,7 +47,7 @@ public class JetObjectDeclaration : JetClassOrObject {
     override fun setName(@NonNls name: String): PsiElement {
         val declarationName = getNameAsDeclaration()
         if (declarationName == null) {
-            val psiFactory = JetPsiFactory(project)
+            val psiFactory = KtPsiFactory(project)
             val result = addAfter(psiFactory.createObjectDeclarationName(name), getObjectKeyword())
             addAfter(psiFactory.createWhiteSpace(), getObjectKeyword())
 
@@ -58,16 +58,16 @@ public class JetObjectDeclaration : JetClassOrObject {
         }
     }
 
-    public fun isCompanion(): Boolean = _stub?.isCompanion() ?: hasModifier(JetTokens.COMPANION_KEYWORD)
+    public fun isCompanion(): Boolean = _stub?.isCompanion() ?: hasModifier(KtTokens.COMPANION_KEYWORD)
 
     override fun getTextOffset(): Int = nameIdentifier?.textRange?.startOffset
                                         ?: getObjectKeyword().textRange.startOffset
 
-    override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D): R {
+    override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D): R {
         return visitor.visitObjectDeclaration(this, data)
     }
 
-    public fun isObjectLiteral(): Boolean = _stub?.isObjectLiteral() ?: (parent is JetObjectLiteralExpression)
+    public fun isObjectLiteral(): Boolean = _stub?.isObjectLiteral() ?: (parent is KtObjectLiteralExpression)
 
-    public fun getObjectKeyword(): PsiElement = findChildByType(JetTokens.OBJECT_KEYWORD)!!
+    public fun getObjectKeyword(): PsiElement = findChildByType(KtTokens.OBJECT_KEYWORD)!!
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclarationName.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtObjectDeclarationName.java
similarity index 74%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclarationName.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtObjectDeclarationName.java
index 2bc1dfda39e..57317f7e932 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclarationName.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtObjectDeclarationName.java
@@ -24,12 +24,12 @@ import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-import static org.jetbrains.kotlin.psi.JetPsiFactoryKt.JetPsiFactory;
+import static org.jetbrains.kotlin.psi.KtPsiFactoryKt.KtPsiFactory;
 
-public class JetObjectDeclarationName extends JetExpressionImpl {
-    public JetObjectDeclarationName(@NotNull ASTNode node) {
+public class KtObjectDeclarationName extends KtExpressionImpl {
+    public KtObjectDeclarationName(@NotNull ASTNode node) {
         super(node);
     }
 
@@ -39,7 +39,7 @@ public class JetObjectDeclarationName extends JetExpressionImpl {
         PsiElement identifier = getNameIdentifier();
         if (identifier != null) {
             String text = identifier.getText();
-            return text != null ? JetPsiUtil.unquoteIdentifier(text) : null;
+            return text != null ? KtPsiUtil.unquoteIdentifier(text) : null;
         }
         else {
             return null;
@@ -47,11 +47,11 @@ public class JetObjectDeclarationName extends JetExpressionImpl {
     }
 
     public PsiElement getNameIdentifier() {
-        return findChildByType(JetTokens.IDENTIFIER);
+        return findChildByType(KtTokens.IDENTIFIER);
     }
 
     public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
-        return getNameIdentifier().replace(JetPsiFactory(this).createNameIdentifier(name));
+        return getNameIdentifier().replace(KtPsiFactory(this).createNameIdentifier(name));
     }
 
     @Override
@@ -61,14 +61,14 @@ public class JetObjectDeclarationName extends JetExpressionImpl {
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitObjectDeclarationName(this, data);
     }
 
     @NotNull
     @Override
     public SearchScope getUseScope() {
-        JetObjectDeclaration objectDeclaration = PsiTreeUtil.getParentOfType(this, JetObjectDeclaration.class);
+        KtObjectDeclaration objectDeclaration = PsiTreeUtil.getParentOfType(this, KtObjectDeclaration.class);
         return objectDeclaration != null ? objectDeclaration.getUseScope() : super.getUseScope();
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectLiteralExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtObjectLiteralExpression.java
similarity index 68%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectLiteralExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtObjectLiteralExpression.java
index 9aa8948fb06..e40fa8a7c39 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectLiteralExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtObjectLiteralExpression.java
@@ -18,20 +18,20 @@ package org.jetbrains.kotlin.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
-public class JetObjectLiteralExpression extends JetExpressionImpl {
-    public JetObjectLiteralExpression(@NotNull ASTNode node) {
+public class KtObjectLiteralExpression extends KtExpressionImpl {
+    public KtObjectLiteralExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitObjectLiteralExpression(this, data);
     }
 
     @NotNull
-    public JetObjectDeclaration getObjectDeclaration() {
-        return (JetObjectDeclaration) findChildByType(JetNodeTypes.OBJECT_DECLARATION);
+    public KtObjectDeclaration getObjectDeclaration() {
+        return (KtObjectDeclaration) findChildByType(KtNodeTypes.OBJECT_DECLARATION);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetOperationExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtOperationExpression.java
similarity index 85%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetOperationExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtOperationExpression.java
index 4739d894681..e921f4b0f24 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetOperationExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtOperationExpression.java
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.psi;
 
 import org.jetbrains.annotations.NotNull;
 
-public interface JetOperationExpression extends JetExpression {
+public interface KtOperationExpression extends KtExpression {
     @NotNull
-    JetSimpleNameExpression getOperationReference();
+    KtSimpleNameExpression getOperationReference();
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetOperationReferenceExpression.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtOperationReferenceExpression.kt
similarity index 84%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetOperationReferenceExpression.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtOperationReferenceExpression.kt
index edcdbad4988..8777e88fa7c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetOperationReferenceExpression.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtOperationReferenceExpression.kt
@@ -19,20 +19,20 @@ package org.jetbrains.kotlin.psi
 import com.intellij.lang.ASTNode
 import com.intellij.psi.PsiElement
 import com.intellij.psi.impl.source.tree.TreeElement
-import org.jetbrains.kotlin.lexer.JetSingleValueToken
-import org.jetbrains.kotlin.lexer.JetToken
+import org.jetbrains.kotlin.lexer.KtSingleValueToken
+import org.jetbrains.kotlin.lexer.KtToken
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.parsing.JetExpressionParsing
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 
-public class JetOperationReferenceExpression(node: ASTNode) : JetSimpleNameExpressionImpl(node) {
+public class KtOperationReferenceExpression(node: ASTNode) : KtSimpleNameExpressionImpl(node) {
     override fun getReferencedNameElement() = findChildByType<PsiElement?>(JetExpressionParsing.ALL_OPERATIONS) ?: this
 
     fun getNameForConventionalOperation(unaryOperations: Boolean = true, binaryOperations: Boolean = true): Name? {
-        val operator = (firstChild as? TreeElement)?.elementType as? JetToken ?: return null
+        val operator = (firstChild as? TreeElement)?.elementType as? KtToken ?: return null
         return OperatorConventions.getNameForOperationSymbol(operator, unaryOperations, binaryOperations)
     }
 
-    fun isPredefinedOperator() = (firstChild as? TreeElement)?.elementType is JetSingleValueToken
+    fun isPredefinedOperator() = (firstChild as? TreeElement)?.elementType is KtSingleValueToken
 
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPackageDirective.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPackageDirective.java
similarity index 64%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetPackageDirective.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtPackageDirective.java
index fc13fad7184..3e1337815b9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPackageDirective.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPackageDirective.java
@@ -21,53 +21,53 @@ import com.intellij.psi.PsiElement;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.name.SpecialNames;
 import org.jetbrains.kotlin.psi.psiUtil.JetPsiUtilKt;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetPackageDirective extends JetModifierListOwnerStub<KotlinPlaceHolderStub<JetPackageDirective>> {
+public class KtPackageDirective extends KtModifierListOwnerStub<KotlinPlaceHolderStub<KtPackageDirective>> {
     private String qualifiedNameCache = null;
 
-    public JetPackageDirective(@NotNull ASTNode node) {
+    public KtPackageDirective(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetPackageDirective(@NotNull KotlinPlaceHolderStub<JetPackageDirective> stub) {
-        super(stub, JetStubElementTypes.PACKAGE_DIRECTIVE);
+    public KtPackageDirective(@NotNull KotlinPlaceHolderStub<KtPackageDirective> stub) {
+        super(stub, KtStubElementTypes.PACKAGE_DIRECTIVE);
     }
 
     // This should be either JetSimpleNameExpression, or JetDotQualifiedExpression
     @Nullable
-    public JetExpression getPackageNameExpression() {
-        return JetStubbedPsiUtil.getStubOrPsiChild(this, JetStubElementTypes.INSIDE_DIRECTIVE_EXPRESSIONS, JetExpression.ARRAY_FACTORY);
+    public KtExpression getPackageNameExpression() {
+        return KtStubbedPsiUtil.getStubOrPsiChild(this, KtStubElementTypes.INSIDE_DIRECTIVE_EXPRESSIONS, KtExpression.ARRAY_FACTORY);
     }
 
     @NotNull
-    public List<JetSimpleNameExpression> getPackageNames() {
-        JetExpression nameExpression = getPackageNameExpression();
+    public List<KtSimpleNameExpression> getPackageNames() {
+        KtExpression nameExpression = getPackageNameExpression();
         if (nameExpression == null) return Collections.emptyList();
 
-        List<JetSimpleNameExpression> packageNames = ContainerUtil.newArrayList();
-        while (nameExpression instanceof JetQualifiedExpression) {
-            JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) nameExpression;
+        List<KtSimpleNameExpression> packageNames = ContainerUtil.newArrayList();
+        while (nameExpression instanceof KtQualifiedExpression) {
+            KtQualifiedExpression qualifiedExpression = (KtQualifiedExpression) nameExpression;
 
-            JetExpression selector = qualifiedExpression.getSelectorExpression();
-            if (selector instanceof JetSimpleNameExpression) {
-                packageNames.add((JetSimpleNameExpression) selector);
+            KtExpression selector = qualifiedExpression.getSelectorExpression();
+            if (selector instanceof KtSimpleNameExpression) {
+                packageNames.add((KtSimpleNameExpression) selector);
             }
 
             nameExpression = qualifiedExpression.getReceiverExpression();
         }
 
-        if (nameExpression instanceof JetSimpleNameExpression) {
-            packageNames.add((JetSimpleNameExpression) nameExpression);
+        if (nameExpression instanceof KtSimpleNameExpression) {
+            packageNames.add((KtSimpleNameExpression) nameExpression);
         }
 
         Collections.reverse(packageNames);
@@ -76,16 +76,16 @@ public class JetPackageDirective extends JetModifierListOwnerStub<KotlinPlaceHol
     }
 
     @Nullable
-    public JetSimpleNameExpression getLastReferenceExpression() {
-        JetExpression nameExpression = getPackageNameExpression();
+    public KtSimpleNameExpression getLastReferenceExpression() {
+        KtExpression nameExpression = getPackageNameExpression();
         if (nameExpression == null) return null;
 
-        return (JetSimpleNameExpression) JetPsiUtilKt.getQualifiedElementSelector(nameExpression);
+        return (KtSimpleNameExpression) JetPsiUtilKt.getQualifiedElementSelector(nameExpression);
     }
 
     @Nullable
     public PsiElement getNameIdentifier() {
-        JetSimpleNameExpression lastPart = getLastReferenceExpression();
+        KtSimpleNameExpression lastPart = getLastReferenceExpression();
         return lastPart != null ? lastPart.getIdentifier() : null;
     }
 
@@ -113,7 +113,7 @@ public class JetPackageDirective extends JetModifierListOwnerStub<KotlinPlaceHol
     }
 
     @NotNull
-    public FqName getFqName(JetSimpleNameExpression nameExpression) {
+    public FqName getFqName(KtSimpleNameExpression nameExpression) {
         return new FqName(getQualifiedNameOf(nameExpression));
     }
 
@@ -123,9 +123,9 @@ public class JetPackageDirective extends JetModifierListOwnerStub<KotlinPlaceHol
             return;
         }
 
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         PsiElement newExpression = psiFactory.createExpression(fqName.asString());
-        JetExpression currentExpression = getPackageNameExpression();
+        KtExpression currentExpression = getPackageNameExpression();
         if (currentExpression != null) {
             currentExpression.replace(newExpression);
             return;
@@ -150,9 +150,9 @@ public class JetPackageDirective extends JetModifierListOwnerStub<KotlinPlaceHol
     }
 
     @NotNull
-    private String getQualifiedNameOf(@Nullable JetSimpleNameExpression nameExpression) {
+    private String getQualifiedNameOf(@Nullable KtSimpleNameExpression nameExpression) {
         StringBuilder builder = new StringBuilder();
-        for (JetSimpleNameExpression e : getPackageNames()) {
+        for (KtSimpleNameExpression e : getPackageNames()) {
             if (builder.length() > 0) {
                 builder.append(".");
             }
@@ -165,7 +165,7 @@ public class JetPackageDirective extends JetModifierListOwnerStub<KotlinPlaceHol
 
     @Nullable
     public PsiElement getPackageKeyword() {
-        return findChildByType(JetTokens.PACKAGE_KEYWORD);
+        return findChildByType(KtTokens.PACKAGE_KEYWORD);
     }
 
     @Override
@@ -174,7 +174,7 @@ public class JetPackageDirective extends JetModifierListOwnerStub<KotlinPlaceHol
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitPackageDirective(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetParameter.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtParameter.java
similarity index 67%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetParameter.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtParameter.java
index ed9242b8ce5..33ced1cf3cd 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetParameter.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtParameter.java
@@ -23,45 +23,45 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.stubs.KotlinParameterStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 import org.jetbrains.kotlin.psi.typeRefHelpers.TypeRefHelpersKt;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetParameter extends JetNamedDeclarationStub<KotlinParameterStub> implements JetCallableDeclaration {
+public class KtParameter extends KtNamedDeclarationStub<KotlinParameterStub> implements KtCallableDeclaration {
 
-    public JetParameter(@NotNull ASTNode node) {
+    public KtParameter(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetParameter(@NotNull KotlinParameterStub stub) {
-        super(stub, JetStubElementTypes.VALUE_PARAMETER);
+    public KtParameter(@NotNull KotlinParameterStub stub) {
+        super(stub, KtStubElementTypes.VALUE_PARAMETER);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitParameter(this, data);
     }
 
     @Override
     @Nullable
-    public JetTypeReference getTypeReference() {
-        return getStubOrPsiChild(JetStubElementTypes.TYPE_REFERENCE);
+    public KtTypeReference getTypeReference() {
+        return getStubOrPsiChild(KtStubElementTypes.TYPE_REFERENCE);
     }
 
     @Override
     @Nullable
-    public JetTypeReference setTypeReference(@Nullable JetTypeReference typeRef) {
+    public KtTypeReference setTypeReference(@Nullable KtTypeReference typeRef) {
         return TypeRefHelpersKt.setTypeReference(this, getNameIdentifier(), typeRef);
     }
 
     @Nullable
     @Override
     public PsiElement getColon() {
-        return findChildByType(JetTokens.COLON);
+        return findChildByType(KtTokens.COLON);
     }
 
     public boolean hasDefaultValue() {
@@ -73,7 +73,7 @@ public class JetParameter extends JetNamedDeclarationStub<KotlinParameterStub> i
     }
 
     @Nullable
-    public JetExpression getDefaultValue() {
+    public KtExpression getDefaultValue() {
         KotlinParameterStub stub = getStub();
         if (stub != null && !stub.hasDefaultValue()) {
             return null;
@@ -81,9 +81,9 @@ public class JetParameter extends JetNamedDeclarationStub<KotlinParameterStub> i
         boolean passedEQ = false;
         ASTNode child = getNode().getFirstChildNode();
         while (child != null) {
-            if (child.getElementType() == JetTokens.EQ) passedEQ = true;
-            if (passedEQ && child.getPsi() instanceof JetExpression) {
-                return (JetExpression) child.getPsi();
+            if (child.getElementType() == KtTokens.EQ) passedEQ = true;
+            if (passedEQ && child.getPsi() instanceof KtExpression) {
+                return (KtExpression) child.getPsi();
             }
             child = child.getTreeNext();
         }
@@ -97,12 +97,12 @@ public class JetParameter extends JetNamedDeclarationStub<KotlinParameterStub> i
             return stub.isMutable();
         }
 
-        return findChildByType(JetTokens.VAR_KEYWORD) != null;
+        return findChildByType(KtTokens.VAR_KEYWORD) != null;
     }
 
     public boolean isVarArg() {
-        JetModifierList modifierList = getModifierList();
-        return modifierList != null && modifierList.hasModifier(JetTokens.VARARG_KEYWORD);
+        KtModifierList modifierList = getModifierList();
+        return modifierList != null && modifierList.hasModifier(KtTokens.VARARG_KEYWORD);
     }
 
     public boolean hasValOrVar() {
@@ -122,7 +122,7 @@ public class JetParameter extends JetNamedDeclarationStub<KotlinParameterStub> i
         return findChildByType(VAL_VAR_TOKEN_SET);
     }
 
-    private static final TokenSet VAL_VAR_TOKEN_SET = TokenSet.create(JetTokens.VAL_KEYWORD, JetTokens.VAR_KEYWORD);
+    private static final TokenSet VAL_VAR_TOKEN_SET = TokenSet.create(KtTokens.VAL_KEYWORD, KtTokens.VAR_KEYWORD);
 
     @Override
     public ItemPresentation getPresentation() {
@@ -130,57 +130,57 @@ public class JetParameter extends JetNamedDeclarationStub<KotlinParameterStub> i
     }
 
     public boolean isLoopParameter() {
-        return getParent() instanceof JetForExpression;
+        return getParent() instanceof KtForExpression;
     }
 
     @Nullable
     @Override
-    public JetParameterList getValueParameterList() {
+    public KtParameterList getValueParameterList() {
         return null;
     }
 
     @NotNull
     @Override
-    public List<JetParameter> getValueParameters() {
+    public List<KtParameter> getValueParameters() {
         return Collections.emptyList();
     }
 
     @Nullable
     @Override
-    public JetTypeReference getReceiverTypeReference() {
+    public KtTypeReference getReceiverTypeReference() {
         return null;
     }
 
     @Nullable
     @Override
-    public JetTypeParameterList getTypeParameterList() {
+    public KtTypeParameterList getTypeParameterList() {
         return null;
     }
 
     @Nullable
     @Override
-    public JetTypeConstraintList getTypeConstraintList() {
+    public KtTypeConstraintList getTypeConstraintList() {
         return null;
     }
 
     @NotNull
     @Override
-    public List<JetTypeConstraint> getTypeConstraints() {
+    public List<KtTypeConstraint> getTypeConstraints() {
         return Collections.emptyList();
     }
 
     @NotNull
     @Override
-    public List<JetTypeParameter> getTypeParameters() {
+    public List<KtTypeParameter> getTypeParameters() {
         return Collections.emptyList();
     }
 
     @Nullable
-    public JetFunction getOwnerFunction() {
+    public KtFunction getOwnerFunction() {
         PsiElement parent = getParent();
         if (parent == null) return null;
         PsiElement grandparent = parent.getParent();
-        if (!(grandparent instanceof JetFunction)) return null;
-        return (JetFunction) grandparent;
+        if (!(grandparent instanceof KtFunction)) return null;
+        return (KtFunction) grandparent;
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetParameterList.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtParameterList.java
similarity index 58%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetParameterList.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtParameterList.java
index b0383f08244..6d04fa0596e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetParameterList.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtParameterList.java
@@ -17,50 +17,48 @@
 package org.jetbrains.kotlin.psi;
 
 import com.intellij.lang.ASTNode;
-import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.List;
 
-public class JetParameterList extends JetElementImplStub<KotlinPlaceHolderStub<JetParameterList>> {
-    public JetParameterList(@NotNull ASTNode node) {
+public class KtParameterList extends KtElementImplStub<KotlinPlaceHolderStub<KtParameterList>> {
+    public KtParameterList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetParameterList(@NotNull KotlinPlaceHolderStub<JetParameterList> stub) {
-        super(stub, JetStubElementTypes.VALUE_PARAMETER_LIST);
+    public KtParameterList(@NotNull KotlinPlaceHolderStub<KtParameterList> stub) {
+        super(stub, KtStubElementTypes.VALUE_PARAMETER_LIST);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitParameterList(this, data);
     }
 
     @NotNull
-    public List<JetParameter> getParameters() {
-        return getStubOrPsiChildrenAsList(JetStubElementTypes.VALUE_PARAMETER);
+    public List<KtParameter> getParameters() {
+        return getStubOrPsiChildrenAsList(KtStubElementTypes.VALUE_PARAMETER);
     }
 
     @NotNull
-    public JetParameter addParameter(@NotNull JetParameter parameter) {
+    public KtParameter addParameter(@NotNull KtParameter parameter) {
         return EditCommaSeparatedListHelper.INSTANCE$.addItem(this, getParameters(), parameter);
     }
 
     @NotNull
-    public JetParameter addParameterAfter(@NotNull JetParameter parameter, @Nullable JetParameter anchor) {
+    public KtParameter addParameterAfter(@NotNull KtParameter parameter, @Nullable KtParameter anchor) {
         return EditCommaSeparatedListHelper.INSTANCE$.addItemAfter(this, getParameters(), parameter, anchor);
     }
 
     @NotNull
-    public JetParameter addParameterBefore(@NotNull JetParameter parameter, @Nullable JetParameter anchor) {
+    public KtParameter addParameterBefore(@NotNull KtParameter parameter, @Nullable KtParameter anchor) {
         return EditCommaSeparatedListHelper.INSTANCE$.addItemBefore(this, getParameters(), parameter, anchor);
     }
 
-    public void removeParameter(@NotNull JetParameter parameter) {
+    public void removeParameter(@NotNull KtParameter parameter) {
         EditCommaSeparatedListHelper.INSTANCE$.removeItem(parameter);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetParenthesizedExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtParenthesizedExpression.java
similarity index 75%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetParenthesizedExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtParenthesizedExpression.java
index bb221dbe0f8..fdac299623f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetParenthesizedExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtParenthesizedExpression.java
@@ -20,18 +20,18 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public class JetParenthesizedExpression extends JetExpressionImpl {
-    public JetParenthesizedExpression(@NotNull ASTNode node) {
+public class KtParenthesizedExpression extends KtExpressionImpl {
+    public KtParenthesizedExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitParenthesizedExpression(this, data);
     }
 
     @Nullable @IfNotParsed
-    public JetExpression getExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getExpression() {
+        return findChildByClass(KtExpression.class);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPostfixExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPostfixExpression.java
similarity index 79%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetPostfixExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtPostfixExpression.java
index dca600ad638..f306d3c12b6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPostfixExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPostfixExpression.java
@@ -21,19 +21,19 @@ import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public class JetPostfixExpression extends JetUnaryExpression {
-    public JetPostfixExpression(@NotNull ASTNode node) {
+public class KtPostfixExpression extends KtUnaryExpression {
+    public KtPostfixExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
     @Nullable @IfNotParsed
-    public JetExpression getBaseExpression() {
-        return PsiTreeUtil.getPrevSiblingOfType(getOperationReference(), JetExpression.class);
+    public KtExpression getBaseExpression() {
+        return PsiTreeUtil.getPrevSiblingOfType(getOperationReference(), KtExpression.class);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitPostfixExpression(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPrefixExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPrefixExpression.java
similarity index 79%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetPrefixExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtPrefixExpression.java
index 014f566fede..3a4ce689393 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPrefixExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPrefixExpression.java
@@ -21,19 +21,19 @@ import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public class JetPrefixExpression extends JetUnaryExpression {
-    public JetPrefixExpression(@NotNull ASTNode node) {
+public class KtPrefixExpression extends KtUnaryExpression {
+    public KtPrefixExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitPrefixExpression(this, data);
     }
 
     @Override
     @Nullable @IfNotParsed
-    public JetExpression getBaseExpression() {
-        return PsiTreeUtil.getNextSiblingOfType(getOperationReference(), JetExpression.class);
+    public KtExpression getBaseExpression() {
+        return PsiTreeUtil.getNextSiblingOfType(getOperationReference(), KtExpression.class);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPrimaryConstructor.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPrimaryConstructor.kt
similarity index 56%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetPrimaryConstructor.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtPrimaryConstructor.kt
index f661e938692..a951c79f1bf 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPrimaryConstructor.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPrimaryConstructor.kt
@@ -18,25 +18,25 @@ package org.jetbrains.kotlin.psi
 
 import com.intellij.lang.ASTNode
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.addRemoveModifier.addModifier
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 
-public class JetPrimaryConstructor : JetConstructor<JetPrimaryConstructor> {
+public class KtPrimaryConstructor : KtConstructor<KtPrimaryConstructor> {
     public constructor(node: ASTNode) : super(node)
-    public constructor(stub: KotlinPlaceHolderStub<JetPrimaryConstructor>) : super(stub, JetStubElementTypes.PRIMARY_CONSTRUCTOR)
+    public constructor(stub: KotlinPlaceHolderStub<KtPrimaryConstructor>) : super(stub, KtStubElementTypes.PRIMARY_CONSTRUCTOR)
 
-    override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D) = visitor.visitPrimaryConstructor(this, data)
+    override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D) = visitor.visitPrimaryConstructor(this, data)
 
-    override fun getContainingClassOrObject() = getParent() as JetClassOrObject
+    override fun getContainingClassOrObject() = getParent() as KtClassOrObject
 
     private fun getOrCreateConstructorKeyword(): PsiElement {
-        return getConstructorKeyword() ?: addBefore(JetPsiFactory(this).createConstructorKeyword(), valueParameterList!!)
+        return getConstructorKeyword() ?: addBefore(KtPsiFactory(this).createConstructorKeyword(), valueParameterList!!)
     }
 
-    override fun addModifier(modifier: JetModifierKeywordToken) {
+    override fun addModifier(modifier: KtModifierKeywordToken) {
         val modifierList = modifierList
         if (modifierList != null) {
             addModifier(modifierList, modifier)
@@ -45,28 +45,28 @@ public class JetPrimaryConstructor : JetConstructor<JetPrimaryConstructor> {
             }
         }
         else {
-            if (modifier == JetTokens.PUBLIC_KEYWORD) return
-            val newModifierList = JetPsiFactory(this).createModifierList(modifier)
+            if (modifier == KtTokens.PUBLIC_KEYWORD) return
+            val newModifierList = KtPsiFactory(this).createModifierList(modifier)
             addBefore(newModifierList, getOrCreateConstructorKeyword())
         }
     }
 
-    override fun removeModifier(modifier: JetModifierKeywordToken) {
+    override fun removeModifier(modifier: KtModifierKeywordToken) {
         super.removeModifier(modifier)
         if (modifierList == null) {
             getConstructorKeyword()?.delete()
         }
     }
 
-    override fun addAnnotationEntry(annotationEntry: JetAnnotationEntry): JetAnnotationEntry {
+    override fun addAnnotationEntry(annotationEntry: KtAnnotationEntry): KtAnnotationEntry {
         val modifierList = getModifierList()
         return if (modifierList != null) {
-            modifierList.addBefore(annotationEntry, modifierList.firstChild) as JetAnnotationEntry
+            modifierList.addBefore(annotationEntry, modifierList.firstChild) as KtAnnotationEntry
         }
         else {
             val parameterList = getValueParameterList()!!
-            val newModifierList = JetPsiFactory(getProject()).createModifierList(annotationEntry.text)
-            (addBefore(newModifierList, parameterList) as JetModifierList).annotationEntries.first()
+            val newModifierList = KtPsiFactory(getProject()).createModifierList(annotationEntry.text)
+            (addBefore(newModifierList, parameterList) as KtModifierList).annotationEntries.first()
         }
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetProjectionKind.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtProjectionKind.java
similarity index 67%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetProjectionKind.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtProjectionKind.java
index 5e6e9980bd1..8f1de186a77 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetProjectionKind.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtProjectionKind.java
@@ -17,20 +17,20 @@
 package org.jetbrains.kotlin.psi;
 
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetSingleValueToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtSingleValueToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-public enum JetProjectionKind {
-    IN(JetTokens.IN_KEYWORD), OUT(JetTokens.OUT_KEYWORD), STAR(JetTokens.MUL), NONE(null);
+public enum KtProjectionKind {
+    IN(KtTokens.IN_KEYWORD), OUT(KtTokens.OUT_KEYWORD), STAR(KtTokens.MUL), NONE(null);
 
-    private final JetSingleValueToken token;
+    private final KtSingleValueToken token;
 
-    JetProjectionKind(@Nullable JetSingleValueToken token) {
+    KtProjectionKind(@Nullable KtSingleValueToken token) {
         this.token = token;
     }
 
     @Nullable
-    public JetSingleValueToken getToken() {
+    public KtSingleValueToken getToken() {
         return token;
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetProperty.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtProperty.java
similarity index 67%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetProperty.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtProperty.java
index c786bb0be57..246d602d2b3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetProperty.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtProperty.java
@@ -27,33 +27,33 @@ import com.intellij.psi.tree.TokenSet;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.stubs.KotlinPropertyStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 import org.jetbrains.kotlin.psi.typeRefHelpers.TypeRefHelpersKt;
 
 import java.util.Collections;
 import java.util.List;
 
-import static org.jetbrains.kotlin.JetNodeTypes.PROPERTY_DELEGATE;
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
+import static org.jetbrains.kotlin.KtNodeTypes.PROPERTY_DELEGATE;
+import static org.jetbrains.kotlin.lexer.KtTokens.*;
 
-public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStub>
-        implements JetVariableDeclaration, PsiModifiableCodeBlock {
+public class KtProperty extends KtTypeParameterListOwnerStub<KotlinPropertyStub>
+        implements KtVariableDeclaration, PsiModifiableCodeBlock {
 
-    private static final Logger LOG = Logger.getInstance(JetProperty.class);
+    private static final Logger LOG = Logger.getInstance(KtProperty.class);
 
-    public JetProperty(@NotNull ASTNode node) {
+    public KtProperty(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetProperty(@NotNull KotlinPropertyStub stub) {
-        super(stub, JetStubElementTypes.PROPERTY);
+    public KtProperty(@NotNull KotlinPropertyStub stub) {
+        super(stub, KtStubElementTypes.PROPERTY);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitProperty(this, data);
     }
 
@@ -64,12 +64,12 @@ public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStu
             return stub.isVar();
         }
 
-        return getNode().findChildByType(JetTokens.VAR_KEYWORD) != null;
+        return getNode().findChildByType(KtTokens.VAR_KEYWORD) != null;
     }
 
     public boolean isLocal() {
         PsiElement parent = getParent();
-        return !(parent instanceof JetFile || parent instanceof JetClassBody);
+        return !(parent instanceof KtFile || parent instanceof KtClassBody);
     }
 
     public boolean isTopLevel() {
@@ -78,45 +78,45 @@ public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStu
             return stub.isTopLevel();
         }
 
-        return getParent() instanceof JetFile;
+        return getParent() instanceof KtFile;
     }
 
     @Nullable
     @Override
-    public JetParameterList getValueParameterList() {
+    public KtParameterList getValueParameterList() {
         return null;
     }
 
     @NotNull
     @Override
-    public List<JetParameter> getValueParameters() {
+    public List<KtParameter> getValueParameters() {
         return Collections.emptyList();
     }
 
     @Override
     @Nullable
-    public JetTypeReference getReceiverTypeReference() {
+    public KtTypeReference getReceiverTypeReference() {
         KotlinPropertyStub stub = getStub();
         if (stub != null) {
             if (!stub.isExtension()) {
                 return null;
             }
             else {
-                return getStubOrPsiChild(JetStubElementTypes.TYPE_REFERENCE);
+                return getStubOrPsiChild(KtStubElementTypes.TYPE_REFERENCE);
             }
         }
         return getReceiverTypeRefByTree();
     }
 
     @Nullable
-    private JetTypeReference getReceiverTypeRefByTree() {
+    private KtTypeReference getReceiverTypeRefByTree() {
         ASTNode node = getNode().getFirstChildNode();
         while (node != null) {
             IElementType tt = node.getElementType();
-            if (tt == JetTokens.COLON) break;
+            if (tt == KtTokens.COLON) break;
 
-            if (tt == JetNodeTypes.TYPE_REFERENCE) {
-                return (JetTypeReference) node.getPsi();
+            if (tt == KtNodeTypes.TYPE_REFERENCE) {
+                return (KtTypeReference) node.getPsi();
             }
             node = node.getTreeNext();
         }
@@ -126,14 +126,14 @@ public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStu
 
     @Override
     @Nullable
-    public JetTypeReference getTypeReference() {
+    public KtTypeReference getTypeReference() {
         KotlinPropertyStub stub = getStub();
         if (stub != null) {
             if (!stub.hasReturnTypeRef()) {
                 return null;
             }
             else {
-                List<JetTypeReference> typeReferences = getStubOrPsiChildrenAsList(JetStubElementTypes.TYPE_REFERENCE);
+                List<KtTypeReference> typeReferences = getStubOrPsiChildrenAsList(KtStubElementTypes.TYPE_REFERENCE);
                 int returnTypeRefPositionInPsi = stub.isExtension() ? 1 : 0;
                 if (typeReferences.size() <= returnTypeRefPositionInPsi) {
                     LOG.error("Invalid stub structure built for property:\n" + getText());
@@ -147,29 +147,29 @@ public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStu
 
     @Override
     @Nullable
-    public JetTypeReference setTypeReference(@Nullable JetTypeReference typeRef) {
+    public KtTypeReference setTypeReference(@Nullable KtTypeReference typeRef) {
         return TypeRefHelpersKt.setTypeReference(this, getNameIdentifier(), typeRef);
     }
 
     @Nullable
     @Override
     public PsiElement getColon() {
-        return findChildByType(JetTokens.COLON);
+        return findChildByType(KtTokens.COLON);
     }
 
     @Nullable
     public PsiElement getEqualsToken() {
-        return findChildByType(JetTokens.EQ);
+        return findChildByType(KtTokens.EQ);
     }
 
     @NotNull
-    public List<JetPropertyAccessor> getAccessors() {
-        return getStubOrPsiChildrenAsList(JetStubElementTypes.PROPERTY_ACCESSOR);
+    public List<KtPropertyAccessor> getAccessors() {
+        return getStubOrPsiChildrenAsList(KtStubElementTypes.PROPERTY_ACCESSOR);
     }
 
     @Nullable
-    public JetPropertyAccessor getGetter() {
-        for (JetPropertyAccessor accessor : getAccessors()) {
+    public KtPropertyAccessor getGetter() {
+        for (KtPropertyAccessor accessor : getAccessors()) {
             if (accessor.isGetter()) return accessor;
         }
 
@@ -177,8 +177,8 @@ public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStu
     }
 
     @Nullable
-    public JetPropertyAccessor getSetter() {
-        for (JetPropertyAccessor accessor : getAccessors()) {
+    public KtPropertyAccessor getSetter() {
+        for (KtPropertyAccessor accessor : getAccessors()) {
             if (accessor.isSetter()) return accessor;
         }
 
@@ -194,8 +194,8 @@ public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStu
     }
 
     @Nullable
-    public JetPropertyDelegate getDelegate() {
-        return (JetPropertyDelegate) findChildByType(PROPERTY_DELEGATE);
+    public KtPropertyDelegate getDelegate() {
+        return (KtPropertyDelegate) findChildByType(PROPERTY_DELEGATE);
     }
 
     public boolean hasDelegateExpression() {
@@ -207,8 +207,8 @@ public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStu
     }
 
     @Nullable
-    public JetExpression getDelegateExpression() {
-        JetPropertyDelegate delegate = getDelegate();
+    public KtExpression getDelegateExpression() {
+        KtPropertyDelegate delegate = getDelegate();
         if (delegate != null) {
             return delegate.getExpression();
         }
@@ -226,8 +226,8 @@ public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStu
 
     @Override
     @Nullable
-    public JetExpression getInitializer() {
-        return PsiTreeUtil.getNextSiblingOfType(findChildByType(EQ), JetExpression.class);
+    public KtExpression getInitializer() {
+        return PsiTreeUtil.getNextSiblingOfType(findChildByType(EQ), KtExpression.class);
     }
 
     public boolean hasDelegateExpressionOrInitializer() {
@@ -235,12 +235,12 @@ public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStu
     }
 
     @Nullable
-    public JetExpression setInitializer(@Nullable JetExpression initializer) {
-        JetExpression oldInitializer = getInitializer();
+    public KtExpression setInitializer(@Nullable KtExpression initializer) {
+        KtExpression oldInitializer = getInitializer();
 
         if (oldInitializer != null) {
             if (initializer != null) {
-                return (JetExpression) oldInitializer.replace(initializer);
+                return (KtExpression) oldInitializer.replace(initializer);
             }
             else {
                 deleteChildRange(findChildByType(EQ), oldInitializer);
@@ -253,8 +253,8 @@ public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStu
                 if (addAfter == null) {
                     addAfter = getNameIdentifier();
                 }
-                PsiElement eq = addAfter(new JetPsiFactory(getProject()).createEQ(), addAfter);
-                return (JetExpression) addAfter(initializer, eq);
+                PsiElement eq = addAfter(new KtPsiFactory(getProject()).createEQ(), addAfter);
+                return (KtExpression) addAfter(initializer, eq);
             }
             else {
                 return null;
@@ -263,8 +263,8 @@ public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStu
     }
 
     @Nullable
-    public JetExpression getDelegateExpressionOrInitializer() {
-        JetExpression expression = getDelegateExpression();
+    public KtExpression getDelegateExpressionOrInitializer() {
+        KtExpression expression = getDelegateExpression();
         if (expression == null) {
             return getInitializer();
         }
@@ -279,7 +279,7 @@ public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStu
         return element;
     }
 
-    private static final TokenSet VAL_VAR_TOKEN_SET = TokenSet.create(JetTokens.VAL_KEYWORD, JetTokens.VAR_KEYWORD);
+    private static final TokenSet VAL_VAR_TOKEN_SET = TokenSet.create(KtTokens.VAL_KEYWORD, KtTokens.VAR_KEYWORD);
 
     @Override
     public ItemPresentation getPresentation() {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPropertyAccessor.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPropertyAccessor.java
similarity index 62%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetPropertyAccessor.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtPropertyAccessor.java
index b62b93dcd56..79cd547202f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPropertyAccessor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPropertyAccessor.java
@@ -21,25 +21,25 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.stubs.KotlinPropertyAccessorStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetPropertyAccessor extends JetDeclarationStub<KotlinPropertyAccessorStub>
-        implements JetDeclarationWithBody, JetModifierListOwner, JetWithExpressionInitializer {
-    public JetPropertyAccessor(@NotNull ASTNode node) {
+public class KtPropertyAccessor extends KtDeclarationStub<KotlinPropertyAccessorStub>
+        implements KtDeclarationWithBody, KtModifierListOwner, KtWithExpressionInitializer {
+    public KtPropertyAccessor(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetPropertyAccessor(@NotNull KotlinPropertyAccessorStub stub) {
-        super(stub, JetStubElementTypes.PROPERTY_ACCESSOR);
+    public KtPropertyAccessor(@NotNull KotlinPropertyAccessorStub stub) {
+        super(stub, KtStubElementTypes.PROPERTY_ACCESSOR);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitPropertyAccessor(this, data);
     }
 
@@ -48,7 +48,7 @@ public class JetPropertyAccessor extends JetDeclarationStub<KotlinPropertyAccess
         if (stub != null) {
             return !stub.isGetter();
         }
-        return findChildByType(JetTokens.SET_KEYWORD) != null;
+        return findChildByType(KtTokens.SET_KEYWORD) != null;
     }
 
     public boolean isGetter() {
@@ -56,27 +56,27 @@ public class JetPropertyAccessor extends JetDeclarationStub<KotlinPropertyAccess
         if (stub != null) {
             return stub.isGetter();
         }
-        return findChildByType(JetTokens.GET_KEYWORD) != null;
+        return findChildByType(KtTokens.GET_KEYWORD) != null;
     }
 
     @Nullable
-    public JetParameterList getParameterList() {
-        return getStubOrPsiChild(JetStubElementTypes.VALUE_PARAMETER_LIST);
+    public KtParameterList getParameterList() {
+        return getStubOrPsiChild(KtStubElementTypes.VALUE_PARAMETER_LIST);
     }
 
     @Nullable
-    public JetParameter getParameter() {
-        JetParameterList parameterList = getParameterList();
+    public KtParameter getParameter() {
+        KtParameterList parameterList = getParameterList();
         if (parameterList == null) return null;
-        List<JetParameter> parameters = parameterList.getParameters();
+        List<KtParameter> parameters = parameterList.getParameters();
         if (parameters.isEmpty()) return null;
         return parameters.get(0);
     }
 
     @NotNull
     @Override
-    public List<JetParameter> getValueParameters() {
-        JetParameter parameter = getParameter();
+    public List<KtParameter> getValueParameters() {
+        KtParameter parameter = getParameter();
         if (parameter == null) {
             return Collections.emptyList();
         }
@@ -85,8 +85,8 @@ public class JetPropertyAccessor extends JetDeclarationStub<KotlinPropertyAccess
 
     @Nullable
     @Override
-    public JetExpression getBodyExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getBodyExpression() {
+        return findChildByClass(KtExpression.class);
     }
 
     @Override
@@ -106,7 +106,7 @@ public class JetPropertyAccessor extends JetDeclarationStub<KotlinPropertyAccess
     @Override
     @Nullable
     public PsiElement getEqualsToken() {
-        return findChildByType(JetTokens.EQ);
+        return findChildByType(KtTokens.EQ);
     }
 
     @Override
@@ -115,28 +115,28 @@ public class JetPropertyAccessor extends JetDeclarationStub<KotlinPropertyAccess
     }
 
     @Nullable
-    public JetTypeReference getReturnTypeReference() {
-        return getStubOrPsiChild(JetStubElementTypes.TYPE_REFERENCE);
+    public KtTypeReference getReturnTypeReference() {
+        return getStubOrPsiChild(KtStubElementTypes.TYPE_REFERENCE);
     }
 
     @NotNull
     public PsiElement getNamePlaceholder() {
-        PsiElement get = findChildByType(JetTokens.GET_KEYWORD);
+        PsiElement get = findChildByType(KtTokens.GET_KEYWORD);
         if (get != null) {
             return get;
         }
-        return findChildByType(JetTokens.SET_KEYWORD);
+        return findChildByType(KtTokens.SET_KEYWORD);
     }
 
     @Nullable
     public ASTNode getRightParenthesis() {
-        return getNode().findChildByType(JetTokens.RPAR);
+        return getNode().findChildByType(KtTokens.RPAR);
     }
 
     @Nullable
     @Override
-    public JetExpression getInitializer() {
-        return PsiTreeUtil.getNextSiblingOfType(getEqualsToken(), JetExpression.class);
+    public KtExpression getInitializer() {
+        return PsiTreeUtil.getNextSiblingOfType(getEqualsToken(), KtExpression.class);
     }
 
     @Override
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPropertyDelegate.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPropertyDelegate.java
similarity index 71%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetPropertyDelegate.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtPropertyDelegate.java
index aea44a52658..d25bdb1291b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPropertyDelegate.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPropertyDelegate.java
@@ -19,26 +19,26 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-public class JetPropertyDelegate extends JetElementImpl {
-    public JetPropertyDelegate(@NotNull ASTNode node) {
+public class KtPropertyDelegate extends KtElementImpl {
+    public KtPropertyDelegate(@NotNull ASTNode node) {
         super(node);
     }
 
     @Nullable
-    public JetExpression getExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getExpression() {
+        return findChildByClass(KtExpression.class);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitPropertyDelegate(this, data);
     }
 
     @NotNull
     public ASTNode getByKeywordNode() {
         //noinspection ConstantConditions
-        return getNode().findChildByType(JetTokens.BY_KEYWORD);
+        return getNode().findChildByType(KtTokens.BY_KEYWORD);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiFactory.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPsiFactory.kt
similarity index 68%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiFactory.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtPsiFactory.kt
index 33fb5f98f21..55b5df4fa3d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiFactory.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPsiFactory.kt
@@ -25,21 +25,21 @@ import com.intellij.psi.PsiFileFactory
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.util.LocalTimeCounter
 import org.jetbrains.kotlin.analyzer.ModuleInfo
-import org.jetbrains.kotlin.idea.JetFileType
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
+import org.jetbrains.kotlin.idea.KotlinFileType
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetPsiFactory.CallableBuilder.Target
+import org.jetbrains.kotlin.psi.KtPsiFactory.CallableBuilder.Target
 import org.jetbrains.kotlin.resolve.ImportPath
 
-public fun JetPsiFactory(project: Project?): JetPsiFactory = JetPsiFactory(project!!)
-public fun JetPsiFactory(elementForProject: PsiElement): JetPsiFactory = JetPsiFactory(elementForProject.getProject())
+public fun KtPsiFactory(project: Project?): KtPsiFactory = KtPsiFactory(project!!)
+public fun KtPsiFactory(elementForProject: PsiElement): KtPsiFactory = KtPsiFactory(elementForProject.getProject())
 
-public var JetFile.doNotAnalyze: String? by UserDataProperty(Key.create("DO_NOT_ANALYZE"))
-public var JetFile.analysisContext: PsiElement? by UserDataProperty(Key.create("ANALYSIS_CONTEXT"))
-public var JetFile.moduleInfo: ModuleInfo? by UserDataProperty(Key.create("MODULE_INFO"))
+public var KtFile.doNotAnalyze: String? by UserDataProperty(Key.create("DO_NOT_ANALYZE"))
+public var KtFile.analysisContext: PsiElement? by UserDataProperty(Key.create("ANALYSIS_CONTEXT"))
+public var KtFile.moduleInfo: ModuleInfo? by UserDataProperty(Key.create("MODULE_INFO"))
 
-public class JetPsiFactory(private val project: Project) {
+public class KtPsiFactory(private val project: Project) {
 
     public fun createValKeyword(): PsiElement {
         val property = createProperty("val x = 1")
@@ -52,10 +52,10 @@ public class JetPsiFactory(private val project: Project) {
     }
 
     public fun createSafeCallNode(): ASTNode {
-        return (createExpression("a?.b") as JetSafeQualifiedExpression).getOperationTokenNode()
+        return (createExpression("a?.b") as KtSafeQualifiedExpression).getOperationTokenNode()
     }
 
-    public fun createExpression(text: String): JetExpression {
+    public fun createExpression(text: String): KtExpression {
         //TODO: '\n' below if important - some strange code indenting problems appear without it
         val expression = createProperty("val x =\n$text").getInitializer() ?: error("Failed to create expression from text: '$text'")
         assert(expression.getText() == text) {
@@ -64,20 +64,20 @@ public class JetPsiFactory(private val project: Project) {
         return expression
     }
 
-    public fun createClassLiteral(className: String): JetClassLiteralExpression =
-            createExpression("$className::class") as JetClassLiteralExpression
+    public fun createClassLiteral(className: String): KtClassLiteralExpression =
+            createExpression("$className::class") as KtClassLiteralExpression
 
-    public fun createCallArguments(text: String): JetValueArgumentList {
+    public fun createCallArguments(text: String): KtValueArgumentList {
         val property = createProperty("val x = foo $text")
-        return (property.getInitializer() as JetCallExpression).getValueArgumentList()!!
+        return (property.getInitializer() as KtCallExpression).getValueArgumentList()!!
     }
 
-    public fun createTypeArguments(text: String): JetTypeArgumentList {
+    public fun createTypeArguments(text: String): KtTypeArgumentList {
         val property = createProperty("val x = foo$text()")
-        return (property.getInitializer() as JetCallExpression).getTypeArgumentList()!!
+        return (property.getInitializer() as KtCallExpression).getTypeArgumentList()!!
     }
 
-    public fun createType(type: String): JetTypeReference {
+    public fun createType(type: String): KtTypeReference {
         val typeReference = createProperty("val x : $type").typeReference
         if (typeReference == null || typeReference.text != type) {
             throw IllegalArgumentException("Incorrect type: $type")
@@ -111,7 +111,7 @@ public class JetPsiFactory(private val project: Project) {
 
     //the pair contains the first and the last elements of a range
     public fun createWhitespaceAndArrow(): Pair<PsiElement, PsiElement> {
-        val functionType = createType("() -> Int").typeElement as JetFunctionType
+        val functionType = createType("() -> Int").typeElement as KtFunctionType
         return Pair(functionType.findElementAt(2)!!, functionType.findElementAt(3)!!)
     }
 
@@ -132,55 +132,55 @@ public class JetPsiFactory(private val project: Project) {
         return createWhiteSpace("\n".repeat(lineBreaks))
     }
 
-    public fun createClass(text: String): JetClass {
+    public fun createClass(text: String): KtClass {
         return createDeclaration(text)
     }
 
-    public fun createCompanionObject(): JetObjectDeclaration {
+    public fun createCompanionObject(): KtObjectDeclaration {
         return createClass("class A {\n companion object{\n}\n}").getCompanionObjects().first()
     }
 
-    public fun createFile(text: String): JetFile {
+    public fun createFile(text: String): KtFile {
         return createFile("dummy.kt", text)
     }
 
-    private fun doCreateFile(fileName: String, text: String): JetFile {
-        return PsiFileFactory.getInstance(project).createFileFromText(fileName, JetFileType.INSTANCE, text, LocalTimeCounter.currentTime(), false) as JetFile
+    private fun doCreateFile(fileName: String, text: String): KtFile {
+        return PsiFileFactory.getInstance(project).createFileFromText(fileName, KotlinFileType.INSTANCE, text, LocalTimeCounter.currentTime(), false) as KtFile
     }
 
-    public fun createFile(fileName: String, text: String): JetFile {
+    public fun createFile(fileName: String, text: String): KtFile {
         val file = doCreateFile(fileName, text)
 
-        file.doNotAnalyze = "This file was created by JetPsiFactory and should not be analyzed\n" +
+        file.doNotAnalyze = "This file was created by KtPsiFactory and should not be analyzed\n" +
                             "Use createAnalyzableFile to create file that can be analyzed\n"
 
         return file
     }
 
-    public fun createAnalyzableFile(fileName: String, text: String, contextToAnalyzeIn: PsiElement): JetFile {
+    public fun createAnalyzableFile(fileName: String, text: String, contextToAnalyzeIn: PsiElement): KtFile {
         val file = doCreateFile(fileName, text)
         file.analysisContext = contextToAnalyzeIn
         return file
     }
 
-    public fun createPhysicalFile(fileName: String, text: String): JetFile {
-        return PsiFileFactory.getInstance(project).createFileFromText(fileName, JetFileType.INSTANCE, text, LocalTimeCounter.currentTime(), true) as JetFile
+    public fun createPhysicalFile(fileName: String, text: String): KtFile {
+        return PsiFileFactory.getInstance(project).createFileFromText(fileName, KotlinFileType.INSTANCE, text, LocalTimeCounter.currentTime(), true) as KtFile
     }
 
-    public fun createProperty(name: String, type: String?, isVar: Boolean, initializer: String?): JetProperty {
+    public fun createProperty(name: String, type: String?, isVar: Boolean, initializer: String?): KtProperty {
         val text = (if (isVar) "var " else "val ") + name + (if (type != null) ":" + type else "") + (if (initializer == null) "" else " = " + initializer)
         return createProperty(text)
     }
 
-    public fun createProperty(name: String, type: String?, isVar: Boolean): JetProperty {
+    public fun createProperty(name: String, type: String?, isVar: Boolean): KtProperty {
         return createProperty(name, type, isVar, null)
     }
 
-    public fun createProperty(text: String): JetProperty {
+    public fun createProperty(text: String): KtProperty {
         return createDeclaration(text)
     }
 
-    public fun <TDeclaration : JetDeclaration> createDeclaration(text: String): TDeclaration {
+    public fun <TDeclaration : KtDeclaration> createDeclaration(text: String): TDeclaration {
         val file = createFile(text)
         val declarations = file.getDeclarations()
         assert(declarations.size() == 1) { "${declarations.size()} declarations in $text" }
@@ -193,82 +193,82 @@ public class JetPsiFactory(private val project: Project) {
         return createProperty(name, null, false).getNameIdentifier()!!
     }
 
-    public fun createSimpleName(name: String): JetSimpleNameExpression {
-        return createProperty(name, null, false, name).getInitializer() as JetSimpleNameExpression
+    public fun createSimpleName(name: String): KtSimpleNameExpression {
+        return createProperty(name, null, false, name).getInitializer() as KtSimpleNameExpression
     }
 
-    public fun createOperationName(name: String): JetSimpleNameExpression {
-        return (createExpression("0 $name 0") as JetBinaryExpression).getOperationReference()
+    public fun createOperationName(name: String): KtSimpleNameExpression {
+        return (createExpression("0 $name 0") as KtBinaryExpression).getOperationReference()
     }
 
-    public fun createObjectDeclarationName(name: String): JetObjectDeclarationName {
-        return createDeclaration<JetObjectDeclaration>("object $name").getNameAsDeclaration()!!
+    public fun createObjectDeclarationName(name: String): KtObjectDeclarationName {
+        return createDeclaration<KtObjectDeclaration>("object $name").getNameAsDeclaration()!!
     }
 
     public fun createIdentifier(name: String): PsiElement {
         return createSimpleName(name).getIdentifier()!!
     }
 
-    public fun createFunction(funDecl: String): JetNamedFunction {
+    public fun createFunction(funDecl: String): KtNamedFunction {
         return createDeclaration(funDecl)
     }
 
-    public fun createSecondaryConstructor(decl: String): JetSecondaryConstructor {
+    public fun createSecondaryConstructor(decl: String): KtSecondaryConstructor {
         return createClass("class Foo {\n $decl \n}").getSecondaryConstructors().first()
     }
 
-    public fun createModifierList(modifier: JetModifierKeywordToken): JetModifierList {
+    public fun createModifierList(modifier: KtModifierKeywordToken): KtModifierList {
         return createModifierList(modifier.getValue())
     }
 
-    public fun createModifierList(text: String): JetModifierList {
+    public fun createModifierList(text: String): KtModifierList {
         return createProperty(text + " val x").getModifierList()!!
     }
 
-    public fun createModifier(modifier: JetModifierKeywordToken): PsiElement {
+    public fun createModifier(modifier: KtModifierKeywordToken): PsiElement {
         return createModifierList(modifier.getValue()).getModifier(modifier)!!
     }
 
-    public fun createAnnotationEntry(text: String): JetAnnotationEntry {
+    public fun createAnnotationEntry(text: String): KtAnnotationEntry {
         val modifierList = createProperty(text + " val x").getModifierList()
         return modifierList!!.getAnnotationEntries().first()
     }
 
-    public fun createEmptyBody(): JetBlockExpression {
-        return createFunction("fun foo() {}").getBodyExpression() as JetBlockExpression
+    public fun createEmptyBody(): KtBlockExpression {
+        return createFunction("fun foo() {}").getBodyExpression() as KtBlockExpression
     }
 
-    public fun createAnonymousInitializer(): JetClassInitializer {
+    public fun createAnonymousInitializer(): KtClassInitializer {
         return createClass("class A { init {} }").getAnonymousInitializers().first()
     }
 
-    public fun createEmptyClassBody(): JetClassBody {
+    public fun createEmptyClassBody(): KtClassBody {
         return createClass("class A(){}").getBody()!!
     }
 
-    public fun createParameter(text : String): JetParameter {
+    public fun createParameter(text : String): KtParameter {
         return createClass("class A($text)").getPrimaryConstructorParameters().first()
     }
 
-    public fun createParameterList(text: String): JetParameterList {
+    public fun createParameterList(text: String): KtParameterList {
         return createFunction("fun foo$text{}").getValueParameterList()!!
     }
 
-    public fun createFunctionLiteralParameterList(text: String): JetParameterList {
-        return (createExpression("{ $text -> 0}") as JetFunctionLiteralExpression).getFunctionLiteral().getValueParameterList()!!
+    public fun createFunctionLiteralParameterList(text: String): KtParameterList {
+        return (createExpression("{ $text -> 0}") as KtFunctionLiteralExpression).getFunctionLiteral().getValueParameterList()!!
     }
 
-    public fun createEnumEntry(text: String): JetEnumEntry {
-        return createDeclaration<JetClass>("enum class E {$text}").getDeclarations()[0] as JetEnumEntry
+    public fun createEnumEntry(text: String): KtEnumEntry {
+        return createDeclaration<KtClass>("enum class E {$text}").getDeclarations()[0] as KtEnumEntry
     }
 
-    public fun createEnumEntryInitializerList(): JetInitializerList {
+    public fun createEnumEntryInitializerList(): KtInitializerList {
         return createEnumEntry("Entry()").initializerList!!
     }
 
-    public fun createWhenEntry(entryText: String): JetWhenEntry {
+    public fun createWhenEntry(entryText: String): KtWhenEntry {
         val function = createFunction("fun foo() { when(12) { " + entryText + " } }")
-        val whenEntry = PsiTreeUtil.findChildOfType(function, javaClass<JetWhenEntry>())
+        val whenEntry = PsiTreeUtil.findChildOfType(function, javaClass<KtWhenEntry>())
 
         assert(whenEntry != null) { "Couldn't generate when entry" }
         assert(entryText == whenEntry!!.text) { "Generate when entry text differs from the given text" }
@@ -276,25 +276,25 @@ public class JetPsiFactory(private val project: Project) {
         return whenEntry
     }
 
-    public fun createBlockStringTemplateEntry(expression: JetExpression): JetStringTemplateEntryWithExpression {
-        val stringTemplateExpression = createExpression("\"\${" + expression.getText() + "}\"") as JetStringTemplateExpression
-        return stringTemplateExpression.getEntries()[0] as JetStringTemplateEntryWithExpression
+    public fun createBlockStringTemplateEntry(expression: KtExpression): KtStringTemplateEntryWithExpression {
+        val stringTemplateExpression = createExpression("\"\${" + expression.getText() + "}\"") as KtStringTemplateExpression
+        return stringTemplateExpression.getEntries()[0] as KtStringTemplateEntryWithExpression
     }
 
-    public fun createSimpleNameStringTemplateEntry(name: String): JetStringTemplateEntryWithExpression {
-        val stringTemplateExpression = createExpression("\"\$$name\"") as JetStringTemplateExpression
-        return stringTemplateExpression.getEntries()[0] as JetStringTemplateEntryWithExpression
+    public fun createSimpleNameStringTemplateEntry(name: String): KtStringTemplateEntryWithExpression {
+        val stringTemplateExpression = createExpression("\"\$$name\"") as KtStringTemplateExpression
+        return stringTemplateExpression.getEntries()[0] as KtStringTemplateEntryWithExpression
     }
 
-    public fun createPackageDirective(fqName: FqName): JetPackageDirective {
+    public fun createPackageDirective(fqName: FqName): KtPackageDirective {
         return createFile("package ${fqName.asString()}").getPackageDirective()!!
     }
 
-    public fun createPackageDirectiveIfNeeded(fqName: FqName): JetPackageDirective? {
+    public fun createPackageDirectiveIfNeeded(fqName: FqName): KtPackageDirective? {
         return if (fqName.isRoot()) null else createPackageDirective(fqName)
     }
 
-    public fun createImportDirective(importPath: ImportPath): JetImportDirective {
+    public fun createImportDirective(importPath: ImportPath): KtImportDirective {
         if (importPath.fqnPart().isRoot()) {
             throw IllegalArgumentException("import path must not be empty")
         }
@@ -311,45 +311,45 @@ public class JetPsiFactory(private val project: Project) {
         return file.getImportDirectives().first()
     }
 
-    public fun createImportDirectiveWithImportList(importPath: ImportPath): JetImportList {
+    public fun createImportDirectiveWithImportList(importPath: ImportPath): KtImportList {
         val importDirective = createImportDirective(importPath)
-        return importDirective.getParent() as JetImportList
+        return importDirective.getParent() as KtImportList
     }
 
-    public fun createPrimaryConstructor(): JetPrimaryConstructor {
+    public fun createPrimaryConstructor(): KtPrimaryConstructor {
         return createClass("class A()").getPrimaryConstructor()!!
     }
 
     public fun createConstructorKeyword(): PsiElement =
             createClass("class A constructor()").getPrimaryConstructor()!!.getConstructorKeyword()!!
 
-    public fun createLabeledExpression(labelName: String): JetLabeledExpression
-        = createExpression("$labelName@ 1") as JetLabeledExpression
+    public fun createLabeledExpression(labelName: String): KtLabeledExpression
+        = createExpression("$labelName@ 1") as KtLabeledExpression
 
     public fun createFieldIdentifier(fieldName: String): PsiElement {
-        return (createExpression("$" + fieldName) as JetNameReferenceExpression).getReferencedNameElement()
+        return (createExpression("$" + fieldName) as KtNameReferenceExpression).getReferencedNameElement()
     }
 
-    public fun createTypeCodeFragment(text: String, context: PsiElement?): JetTypeCodeFragment {
-        return JetTypeCodeFragment(project, "fragment.kt", text, context)
+    public fun createTypeCodeFragment(text: String, context: PsiElement?): KtTypeCodeFragment {
+        return KtTypeCodeFragment(project, "fragment.kt", text, context)
     }
 
-    public fun createExpressionCodeFragment(text: String, context: PsiElement?): JetExpressionCodeFragment {
-        return JetExpressionCodeFragment(project, "fragment.kt", text, null, context)
+    public fun createExpressionCodeFragment(text: String, context: PsiElement?): KtExpressionCodeFragment {
+        return KtExpressionCodeFragment(project, "fragment.kt", text, null, context)
     }
 
-    public fun createBlockCodeFragment(text: String, context: PsiElement?): JetBlockCodeFragment {
-        return JetBlockCodeFragment(project, "fragment.kt", text, null, context)
+    public fun createBlockCodeFragment(text: String, context: PsiElement?): KtBlockCodeFragment {
+        return KtBlockCodeFragment(project, "fragment.kt", text, null, context)
     }
 
-    public fun createIf(condition: JetExpression, thenExpr: JetExpression, elseExpr: JetExpression? = null): JetIfExpression {
+    public fun createIf(condition: KtExpression, thenExpr: KtExpression, elseExpr: KtExpression? = null): KtIfExpression {
         return (if (elseExpr != null)
-            createExpressionByPattern("if ($0) $1 else $2", condition, thenExpr, elseExpr) as JetIfExpression
+            createExpressionByPattern("if ($0) $1 else $2", condition, thenExpr, elseExpr) as KtIfExpression
         else
-            createExpressionByPattern("if ($0) $1", condition, thenExpr)) as JetIfExpression
+            createExpressionByPattern("if ($0) $1", condition, thenExpr)) as KtIfExpression
     }
 
-    public fun createArgument(expression: JetExpression, name: Name? = null, isSpread: Boolean = false): JetValueArgument {
+    public fun createArgument(expression: KtExpression, name: Name? = null, isSpread: Boolean = false): KtValueArgument {
         val argumentList = buildByPattern({ pattern, args -> createByPattern(pattern, *args) { createCallArguments(it) } }) {
             appendFixedText("(")
 
@@ -369,15 +369,15 @@ public class JetPsiFactory(private val project: Project) {
         return argumentList.getArguments().single()
     }
 
-    public fun createDelegatorToSuperCall(text: String): JetDelegatorToSuperCall {
-        return createClass("class A: $text").getDelegationSpecifiers().first() as JetDelegatorToSuperCall
+    public fun createDelegatorToSuperCall(text: String): KtDelegatorToSuperCall {
+        return createClass("class A: $text").getDelegationSpecifiers().first() as KtDelegatorToSuperCall
     }
 
-    public fun createDelegatorToSuperClass(text: String): JetDelegatorToSuperClass {
-        return createClass("class A: $text").getDelegationSpecifiers().first() as JetDelegatorToSuperClass
+    public fun createDelegatorToSuperClass(text: String): KtDelegatorToSuperClass {
+        return createClass("class A: $text").getDelegationSpecifiers().first() as KtDelegatorToSuperClass
     }
 
-    public fun createConstructorDelegationCall(text: String): JetConstructorDelegationCall {
+    public fun createConstructorDelegationCall(text: String): KtConstructorDelegationCall {
         val colonOrEmpty = if (text.isEmpty()) "" else ": "
         return createClass("class A { constructor()$colonOrEmpty$text {}").getSecondaryConstructors().first().getDelegationCall()
     }
@@ -548,12 +548,12 @@ public class JetPsiFactory(private val project: Project) {
         }
     }
 
-    public fun createBlock(bodyText: String): JetBlockExpression {
-        return createFunction("fun foo() {\n" + bodyText + "\n}").getBodyExpression() as JetBlockExpression
+    public fun createBlock(bodyText: String): KtBlockExpression {
+        return createFunction("fun foo() {\n" + bodyText + "\n}").getBodyExpression() as KtBlockExpression
     }
 
-    public fun createSingleStatementBlock(statement: JetExpression): JetBlockExpression {
-        return createDeclarationByPattern<JetNamedFunction>("fun foo() {\n$0\n}", statement).getBodyExpression() as JetBlockExpression
+    public fun createSingleStatementBlock(statement: KtExpression): KtBlockExpression {
+        return createDeclarationByPattern<KtNamedFunction>("fun foo() {\n$0\n}", statement).getBodyExpression() as KtBlockExpression
     }
 
     public fun createComment(text: String): PsiComment {
@@ -566,21 +566,21 @@ public class JetPsiFactory(private val project: Project) {
 
     // special hack used in ControlStructureTypingVisitor
     // TODO: get rid of it
-    public fun wrapInABlockWrapper(expression: JetExpression): JetBlockExpression {
-        if (expression is JetBlockExpression) {
+    public fun wrapInABlockWrapper(expression: KtExpression): KtBlockExpression {
+        if (expression is KtBlockExpression) {
             return expression
         }
         val function = createFunction("fun f() { ${expression.getText()} }")
-        val block = function.getBodyExpression() as JetBlockExpression
+        val block = function.getBodyExpression() as KtBlockExpression
         return BlockWrapper(block, expression)
     }
 
-    private class BlockWrapper(fakeBlockExpression: JetBlockExpression, private val expression: JetExpression) : JetBlockExpression(fakeBlockExpression.getNode()), JetPsiUtil.JetExpressionWrapper {
-        override fun getStatements(): List<JetExpression> {
+    private class BlockWrapper(fakeBlockExpression: KtBlockExpression, private val expression: KtExpression) : KtBlockExpression(fakeBlockExpression.getNode()), KtPsiUtil.KtExpressionWrapper {
+        override fun getStatements(): List<KtExpression> {
             return listOf(expression)
         }
 
-        override fun getBaseExpression(): JetExpression {
+        override fun getBaseExpression(): KtExpression {
             return expression
         }
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPsiUtil.java
similarity index 53%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiUtil.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtPsiUtil.java
index defbbbb7c05..66361e949ea 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtPsiUtil.java
@@ -30,13 +30,13 @@ import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor;
 import org.jetbrains.kotlin.kdoc.psi.api.KDocElement;
-import org.jetbrains.kotlin.lexer.JetToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.name.SpecialNames;
@@ -51,34 +51,34 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-public class JetPsiUtil {
-    private JetPsiUtil() {
+public class KtPsiUtil {
+    private KtPsiUtil() {
     }
 
-    public interface JetExpressionWrapper {
-        JetExpression getBaseExpression();
+    public interface KtExpressionWrapper {
+        KtExpression getBaseExpression();
     }
 
-    public static <D> void visitChildren(@NotNull JetElement element, @NotNull JetVisitor<Void, D> visitor, D data) {
+    public static <D> void visitChildren(@NotNull KtElement element, @NotNull KtVisitor<Void, D> visitor, D data) {
         PsiElement child = element.getFirstChild();
         while (child != null) {
-            if (child instanceof JetElement) {
-                ((JetElement) child).accept(visitor, data);
+            if (child instanceof KtElement) {
+                ((KtElement) child).accept(visitor, data);
             }
             child = child.getNextSibling();
         }
     }
 
     @NotNull
-    public static JetExpression safeDeparenthesize(@NotNull JetExpression expression) {
-        JetExpression deparenthesized = deparenthesize(expression);
+    public static KtExpression safeDeparenthesize(@NotNull KtExpression expression) {
+        KtExpression deparenthesized = deparenthesize(expression);
         return deparenthesized != null ? deparenthesized : expression;
     }
 
     @Nullable
-    public static JetExpression deparenthesize(@Nullable JetExpression expression ) {
+    public static KtExpression deparenthesize(@Nullable KtExpression expression ) {
         while (true) {
-            JetExpression baseExpression = deparenthesizeOnce(expression);
+            KtExpression baseExpression = deparenthesizeOnce(expression);
 
             if (baseExpression == expression) return baseExpression;
             expression = baseExpression;
@@ -86,20 +86,20 @@ public class JetPsiUtil {
     }
 
     @Nullable
-    public static JetExpression deparenthesizeOnce(
-            @Nullable JetExpression expression
+    public static KtExpression deparenthesizeOnce(
+            @Nullable KtExpression expression
     ) {
-        if (expression instanceof JetAnnotatedExpression) {
-            return ((JetAnnotatedExpression) expression).getBaseExpression();
+        if (expression instanceof KtAnnotatedExpression) {
+            return ((KtAnnotatedExpression) expression).getBaseExpression();
         }
-        else if (expression instanceof JetLabeledExpression) {
-            return ((JetLabeledExpression) expression).getBaseExpression();
+        else if (expression instanceof KtLabeledExpression) {
+            return ((KtLabeledExpression) expression).getBaseExpression();
         }
-        else if (expression instanceof JetExpressionWrapper) {
-            return ((JetExpressionWrapper) expression).getBaseExpression();
+        else if (expression instanceof KtExpressionWrapper) {
+            return ((KtExpressionWrapper) expression).getBaseExpression();
         }
-        else if (expression instanceof JetParenthesizedExpression) {
-            return ((JetParenthesizedExpression) expression).getExpression();
+        else if (expression instanceof KtParenthesizedExpression) {
+            return ((KtParenthesizedExpression) expression).getExpression();
         }
         return expression;
     }
@@ -110,19 +110,19 @@ public class JetPsiUtil {
     }
 
     @NotNull
-    public static Set<JetElement> findRootExpressions(@NotNull Collection<JetElement> unreachableElements) {
-        Set<JetElement> rootElements = new HashSet<JetElement>();
-        final Set<JetElement> shadowedElements = new HashSet<JetElement>();
-        JetVisitorVoid shadowAllChildren = new JetVisitorVoid() {
+    public static Set<KtElement> findRootExpressions(@NotNull Collection<KtElement> unreachableElements) {
+        Set<KtElement> rootElements = new HashSet<KtElement>();
+        final Set<KtElement> shadowedElements = new HashSet<KtElement>();
+        KtVisitorVoid shadowAllChildren = new KtVisitorVoid() {
             @Override
-            public void visitJetElement(@NotNull JetElement element) {
+            public void visitJetElement(@NotNull KtElement element) {
                 if (shadowedElements.add(element)) {
                     element.acceptChildren(this);
                 }
             }
         };
 
-        for (JetElement element : unreachableElements) {
+        for (KtElement element : unreachableElements) {
             if (shadowedElements.contains(element)) continue;
             element.acceptChildren(shadowAllChildren);
 
@@ -162,10 +162,10 @@ public class JetPsiUtil {
 
     /** @return <code>null</code> iff the tye has syntactic errors */
     @Nullable
-    public static FqName toQualifiedName(@NotNull JetUserType userType) {
+    public static FqName toQualifiedName(@NotNull KtUserType userType) {
         List<String> reversedNames = Lists.newArrayList();
 
-        JetUserType current = userType;
+        KtUserType current = userType;
         while (current != null) {
             String name = current.getReferencedName();
             if (name == null) return null;
@@ -178,12 +178,12 @@ public class JetPsiUtil {
     }
 
     @Nullable
-    public static Name getShortName(@NotNull JetAnnotationEntry annotation) {
-        JetTypeReference typeReference = annotation.getTypeReference();
+    public static Name getShortName(@NotNull KtAnnotationEntry annotation) {
+        KtTypeReference typeReference = annotation.getTypeReference();
         assert typeReference != null : "Annotation entry hasn't typeReference " + annotation.getText();
-        JetTypeElement typeElement = typeReference.getTypeElement();
-        if (typeElement instanceof JetUserType) {
-            JetUserType userType = (JetUserType) typeElement;
+        KtTypeElement typeElement = typeReference.getTypeElement();
+        if (typeElement instanceof KtUserType) {
+            KtUserType userType = (KtUserType) typeElement;
             String shortName = userType.getReferencedName();
             if (shortName != null) {
                 return Name.identifier(shortName);
@@ -192,11 +192,11 @@ public class JetPsiUtil {
         return null;
     }
 
-    public static boolean isDeprecated(@NotNull JetModifierListOwner owner) {
-        JetModifierList modifierList = owner.getModifierList();
+    public static boolean isDeprecated(@NotNull KtModifierListOwner owner) {
+        KtModifierList modifierList = owner.getModifierList();
         if (modifierList != null) {
-            List<JetAnnotationEntry> annotationEntries = modifierList.getAnnotationEntries();
-            for (JetAnnotationEntry annotation : annotationEntries) {
+            List<KtAnnotationEntry> annotationEntries = modifierList.getAnnotationEntries();
+            for (KtAnnotationEntry annotation : annotationEntries) {
                 Name shortName = getShortName(annotation);
                 if (KotlinBuiltIns.FQ_NAMES.deprecated.shortName().equals(shortName)) {
                     return true;
@@ -207,34 +207,34 @@ public class JetPsiUtil {
     }
 
     @Nullable
-    public static <T extends PsiElement> T getDirectParentOfTypeForBlock(@NotNull JetBlockExpression block, @NotNull Class<T> aClass) {
+    public static <T extends PsiElement> T getDirectParentOfTypeForBlock(@NotNull KtBlockExpression block, @NotNull Class<T> aClass) {
         T parent = PsiTreeUtil.getParentOfType(block, aClass);
-        if (parent instanceof JetIfExpression) {
-            JetIfExpression ifExpression = (JetIfExpression) parent;
+        if (parent instanceof KtIfExpression) {
+            KtIfExpression ifExpression = (KtIfExpression) parent;
             if (ifExpression.getElse() == block || ifExpression.getThen() == block) {
                 return parent;
             }
         }
-        if (parent instanceof JetWhenExpression) {
-            JetWhenExpression whenExpression = (JetWhenExpression) parent;
-            for (JetWhenEntry whenEntry : whenExpression.getEntries()) {
+        if (parent instanceof KtWhenExpression) {
+            KtWhenExpression whenExpression = (KtWhenExpression) parent;
+            for (KtWhenEntry whenEntry : whenExpression.getEntries()) {
                 if (whenEntry.getExpression() == block) {
                     return parent;
                 }
             }
         }
-        if (parent instanceof JetFunctionLiteral) {
-            JetFunctionLiteral functionLiteral = (JetFunctionLiteral) parent;
+        if (parent instanceof KtFunctionLiteral) {
+            KtFunctionLiteral functionLiteral = (KtFunctionLiteral) parent;
             if (functionLiteral.getBodyExpression() == block) {
                 return parent;
             }
         }
-        if (parent instanceof JetTryExpression) {
-            JetTryExpression tryExpression = (JetTryExpression) parent;
+        if (parent instanceof KtTryExpression) {
+            KtTryExpression tryExpression = (KtTryExpression) parent;
             if (tryExpression.getTryBlock() == block) {
                 return parent;
             }
-            for (JetCatchClause clause : tryExpression.getCatchClauses()) {
+            for (KtCatchClause clause : tryExpression.getCatchClauses()) {
                 if (clause.getCatchBody() == block) {
                     return parent;
                 }
@@ -244,16 +244,16 @@ public class JetPsiUtil {
     }
 
     @Nullable
-    public static Name getAliasName(@NotNull JetImportDirective importDirective) {
+    public static Name getAliasName(@NotNull KtImportDirective importDirective) {
         if (importDirective.isAllUnder()) {
             return null;
         }
         String aliasName = importDirective.getAliasName();
-        JetExpression importedReference = importDirective.getImportedReference();
+        KtExpression importedReference = importDirective.getImportedReference();
         if (importedReference == null) {
             return null;
         }
-        JetSimpleNameExpression referenceExpression = getLastReference(importedReference);
+        KtSimpleNameExpression referenceExpression = getLastReference(importedReference);
         if (aliasName == null) {
             aliasName = referenceExpression != null ? referenceExpression.getReferencedName() : null;
         }
@@ -262,51 +262,51 @@ public class JetPsiUtil {
     }
 
     @Nullable
-    public static JetSimpleNameExpression getLastReference(@NotNull JetExpression importedReference) {
-        JetElement selector = JetPsiUtilKt.getQualifiedElementSelector(importedReference);
-        return selector instanceof JetSimpleNameExpression ? (JetSimpleNameExpression) selector : null;
+    public static KtSimpleNameExpression getLastReference(@NotNull KtExpression importedReference) {
+        KtElement selector = JetPsiUtilKt.getQualifiedElementSelector(importedReference);
+        return selector instanceof KtSimpleNameExpression ? (KtSimpleNameExpression) selector : null;
     }
 
-    public static boolean isSelectorInQualified(@NotNull JetSimpleNameExpression nameExpression) {
-        JetElement qualifiedElement = JetPsiUtilKt.getQualifiedElement(nameExpression);
-        return qualifiedElement instanceof JetQualifiedExpression
-               || ((qualifiedElement instanceof JetUserType) && ((JetUserType) qualifiedElement).getQualifier() != null);
+    public static boolean isSelectorInQualified(@NotNull KtSimpleNameExpression nameExpression) {
+        KtElement qualifiedElement = JetPsiUtilKt.getQualifiedElement(nameExpression);
+        return qualifiedElement instanceof KtQualifiedExpression
+               || ((qualifiedElement instanceof KtUserType) && ((KtUserType) qualifiedElement).getQualifier() != null);
     }
 
-    public static boolean isLHSOfDot(@NotNull JetExpression expression) {
+    public static boolean isLHSOfDot(@NotNull KtExpression expression) {
         PsiElement parent = expression.getParent();
-        if (!(parent instanceof JetQualifiedExpression)) return false;
-        JetQualifiedExpression qualifiedParent = (JetQualifiedExpression) parent;
+        if (!(parent instanceof KtQualifiedExpression)) return false;
+        KtQualifiedExpression qualifiedParent = (KtQualifiedExpression) parent;
         return qualifiedParent.getReceiverExpression() == expression || isLHSOfDot(qualifiedParent);
     }
 
     // SCRIPT: is declaration in script?
-    public static boolean isScriptDeclaration(@NotNull JetDeclaration namedDeclaration) {
+    public static boolean isScriptDeclaration(@NotNull KtDeclaration namedDeclaration) {
         return getScript(namedDeclaration) != null;
     }
 
     // SCRIPT: get script from top-level declaration
     @Nullable
-    public static JetScript getScript(@NotNull JetDeclaration namedDeclaration) {
+    public static KtScript getScript(@NotNull KtDeclaration namedDeclaration) {
         PsiElement parent = namedDeclaration.getParent();
-        if (parent != null && parent.getParent() instanceof JetScript) {
-            return (JetScript) parent.getParent();
+        if (parent != null && parent.getParent() instanceof KtScript) {
+            return (KtScript) parent.getParent();
         }
         else {
             return null;
         }
     }
 
-    public static boolean isVariableNotParameterDeclaration(@NotNull JetDeclaration declaration) {
-        if (!(declaration instanceof JetVariableDeclaration)) return false;
-        if (declaration instanceof JetProperty) return true;
-        assert declaration instanceof JetMultiDeclarationEntry;
-        JetMultiDeclarationEntry multiDeclarationEntry = (JetMultiDeclarationEntry) declaration;
-        return !(multiDeclarationEntry.getParent().getParent() instanceof JetForExpression);
+    public static boolean isVariableNotParameterDeclaration(@NotNull KtDeclaration declaration) {
+        if (!(declaration instanceof KtVariableDeclaration)) return false;
+        if (declaration instanceof KtProperty) return true;
+        assert declaration instanceof KtMultiDeclarationEntry;
+        KtMultiDeclarationEntry multiDeclarationEntry = (KtMultiDeclarationEntry) declaration;
+        return !(multiDeclarationEntry.getParent().getParent() instanceof KtForExpression);
     }
 
     @Nullable
-    public static Name getConventionName(@NotNull JetSimpleNameExpression simpleNameExpression) {
+    public static Name getConventionName(@NotNull KtSimpleNameExpression simpleNameExpression) {
         if (simpleNameExpression.getIdentifier() != null) {
             return simpleNameExpression.getReferencedNameAsName();
         }
@@ -314,9 +314,9 @@ public class JetPsiUtil {
         PsiElement firstChild = simpleNameExpression.getFirstChild();
         if (firstChild != null) {
             IElementType elementType = firstChild.getNode().getElementType();
-            if (elementType instanceof JetToken) {
-                JetToken jetToken = (JetToken) elementType;
-                boolean isPrefixExpression = simpleNameExpression.getParent() instanceof JetPrefixExpression;
+            if (elementType instanceof KtToken) {
+                KtToken jetToken = (KtToken) elementType;
+                boolean isPrefixExpression = simpleNameExpression.getParent() instanceof KtPrefixExpression;
                 if (isPrefixExpression) {
                     return OperatorConventions.getNameForOperationSymbol(jetToken, true, false);
                 }
@@ -347,50 +347,50 @@ public class JetPsiUtil {
         return answer;
     }
 
-    public static boolean isNullConstant(@NotNull JetExpression expression) {
-        JetExpression deparenthesized = deparenthesize(expression);
-        return deparenthesized instanceof JetConstantExpression && deparenthesized.getNode().getElementType() == JetNodeTypes.NULL;
+    public static boolean isNullConstant(@NotNull KtExpression expression) {
+        KtExpression deparenthesized = deparenthesize(expression);
+        return deparenthesized instanceof KtConstantExpression && deparenthesized.getNode().getElementType() == KtNodeTypes.NULL;
     }
 
-    public static boolean isTrueConstant(@Nullable JetExpression condition) {
-        return (condition != null && condition.getNode().getElementType() == JetNodeTypes.BOOLEAN_CONSTANT &&
-                condition.getNode().findChildByType(JetTokens.TRUE_KEYWORD) != null);
+    public static boolean isTrueConstant(@Nullable KtExpression condition) {
+        return (condition != null && condition.getNode().getElementType() == KtNodeTypes.BOOLEAN_CONSTANT &&
+                condition.getNode().findChildByType(KtTokens.TRUE_KEYWORD) != null);
     }
 
-    public static boolean isAbstract(@NotNull JetDeclarationWithBody declaration) {
+    public static boolean isAbstract(@NotNull KtDeclarationWithBody declaration) {
         return declaration.getBodyExpression() == null;
     }
 
-    public static boolean isBackingFieldReference(@NotNull JetSimpleNameExpression expression, @Nullable DeclarationDescriptor descriptor) {
-        return descriptor instanceof SyntheticFieldDescriptor || expression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER;
+    public static boolean isBackingFieldReference(@NotNull KtSimpleNameExpression expression, @Nullable DeclarationDescriptor descriptor) {
+        return descriptor instanceof SyntheticFieldDescriptor || expression.getReferencedNameElementType() == KtTokens.FIELD_IDENTIFIER;
     }
 
-    public static boolean isBackingFieldReference(@Nullable JetElement element, @Nullable DeclarationDescriptor descriptor) {
-        return element instanceof JetSimpleNameExpression && isBackingFieldReference((JetSimpleNameExpression) element, descriptor);
+    public static boolean isBackingFieldReference(@Nullable KtElement element, @Nullable DeclarationDescriptor descriptor) {
+        return element instanceof KtSimpleNameExpression && isBackingFieldReference((KtSimpleNameExpression) element, descriptor);
     }
 
     @Nullable
-    public static JetExpression getExpressionOrLastStatementInBlock(@Nullable JetExpression expression) {
-        if (expression instanceof JetBlockExpression) {
-            return getLastStatementInABlock((JetBlockExpression) expression);
+    public static KtExpression getExpressionOrLastStatementInBlock(@Nullable KtExpression expression) {
+        if (expression instanceof KtBlockExpression) {
+            return getLastStatementInABlock((KtBlockExpression) expression);
         }
         return expression;
     }
 
     @Nullable
-    public static JetExpression getLastStatementInABlock(@Nullable JetBlockExpression blockExpression) {
+    public static KtExpression getLastStatementInABlock(@Nullable KtBlockExpression blockExpression) {
         if (blockExpression == null) return null;
-        List<JetExpression> statements = blockExpression.getStatements();
+        List<KtExpression> statements = blockExpression.getStatements();
         return statements.isEmpty() ? null : statements.get(statements.size() - 1);
     }
 
-    public static boolean isTrait(@NotNull JetClassOrObject classOrObject) {
-        return classOrObject instanceof JetClass && ((JetClass) classOrObject).isInterface();
+    public static boolean isTrait(@NotNull KtClassOrObject classOrObject) {
+        return classOrObject instanceof KtClass && ((KtClass) classOrObject).isInterface();
     }
 
     @Nullable
-    public static JetClassOrObject getOutermostClassOrObject(@NotNull JetClassOrObject classOrObject) {
-        JetClassOrObject current = classOrObject;
+    public static KtClassOrObject getOutermostClassOrObject(@NotNull KtClassOrObject classOrObject) {
+        KtClassOrObject current = classOrObject;
         while (true) {
             PsiElement parent = current.getParent();
             assert classOrObject.getParent() != null : "Class with no parent: " + classOrObject.getText();
@@ -398,21 +398,21 @@ public class JetPsiUtil {
             if (parent instanceof PsiFile) {
                 return current;
             }
-            if (!(parent instanceof JetClassBody)) {
+            if (!(parent instanceof KtClassBody)) {
                 // It is a local class, no legitimate outer
                 return current;
             }
 
-            current = (JetClassOrObject) parent.getParent();
+            current = (KtClassOrObject) parent.getParent();
         }
     }
 
     @Nullable
-    public static JetClassOrObject getClassIfParameterIsProperty(@NotNull JetParameter jetParameter) {
+    public static KtClassOrObject getClassIfParameterIsProperty(@NotNull KtParameter jetParameter) {
         if (jetParameter.hasValOrVar()) {
             PsiElement grandParent = jetParameter.getParent().getParent();
-            if (grandParent instanceof JetPrimaryConstructor) {
-                return ((JetPrimaryConstructor) grandParent).getContainingClassOrObject();
+            if (grandParent instanceof KtPrimaryConstructor) {
+                return ((KtPrimaryConstructor) grandParent).getContainingClassOrObject();
             }
         }
 
@@ -420,39 +420,39 @@ public class JetPsiUtil {
     }
 
     @Nullable
-    private static IElementType getOperation(@NotNull JetExpression expression) {
-        if (expression instanceof JetQualifiedExpression) {
-            return ((JetQualifiedExpression) expression).getOperationSign();
+    private static IElementType getOperation(@NotNull KtExpression expression) {
+        if (expression instanceof KtQualifiedExpression) {
+            return ((KtQualifiedExpression) expression).getOperationSign();
         }
-        else if (expression instanceof JetOperationExpression) {
-            return ((JetOperationExpression) expression).getOperationReference().getReferencedNameElementType();
+        else if (expression instanceof KtOperationExpression) {
+            return ((KtOperationExpression) expression).getOperationReference().getReferencedNameElementType();
         }
         return null;
     }
 
 
-    private static int getPriority(@NotNull JetExpression expression) {
+    private static int getPriority(@NotNull KtExpression expression) {
         int maxPriority = JetExpressionParsing.Precedence.values().length + 1;
 
         // same as postfix operations
-        if (expression instanceof JetPostfixExpression ||
-            expression instanceof JetQualifiedExpression ||
-            expression instanceof JetCallExpression ||
-            expression instanceof JetArrayAccessExpression) {
+        if (expression instanceof KtPostfixExpression ||
+            expression instanceof KtQualifiedExpression ||
+            expression instanceof KtCallExpression ||
+            expression instanceof KtArrayAccessExpression) {
             return maxPriority - 1;
         }
 
-        if (expression instanceof JetPrefixExpression || expression instanceof JetLabeledExpression) return maxPriority - 2;
+        if (expression instanceof KtPrefixExpression || expression instanceof KtLabeledExpression) return maxPriority - 2;
 
-        if (expression instanceof JetIfExpression) {
+        if (expression instanceof KtIfExpression) {
             return JetExpressionParsing.Precedence.ASSIGNMENT.ordinal();
         }
 
-        if (expression instanceof JetSuperExpression) {
+        if (expression instanceof KtSuperExpression) {
             return maxPriority;
         }
 
-        if (expression instanceof JetDeclaration || expression instanceof JetStatementExpression) {
+        if (expression instanceof KtDeclaration || expression instanceof KtStatementExpression) {
             return 0;
         }
 
@@ -467,31 +467,31 @@ public class JetPsiUtil {
         return maxPriority;
     }
 
-    public static boolean areParenthesesUseless(@NotNull JetParenthesizedExpression expression) {
-        JetExpression innerExpression = expression.getExpression();
+    public static boolean areParenthesesUseless(@NotNull KtParenthesizedExpression expression) {
+        KtExpression innerExpression = expression.getExpression();
         if (innerExpression == null) return true;
 
         PsiElement parent = expression.getParent();
-        if (!(parent instanceof JetExpression)) return true;
+        if (!(parent instanceof KtExpression)) return true;
 
-        return !areParenthesesNecessary(innerExpression, expression, (JetExpression) parent);
+        return !areParenthesesNecessary(innerExpression, expression, (KtExpression) parent);
     }
 
-    public static boolean areParenthesesNecessary(@NotNull JetExpression innerExpression, @NotNull JetExpression currentInner, @NotNull JetExpression parentExpression) {
-        if (parentExpression instanceof JetParenthesizedExpression || innerExpression instanceof JetParenthesizedExpression) {
+    public static boolean areParenthesesNecessary(@NotNull KtExpression innerExpression, @NotNull KtExpression currentInner, @NotNull KtExpression parentExpression) {
+        if (parentExpression instanceof KtParenthesizedExpression || innerExpression instanceof KtParenthesizedExpression) {
             return false;
         }
 
-        if (parentExpression instanceof JetPackageDirective) return false;
+        if (parentExpression instanceof KtPackageDirective) return false;
 
-        if (parentExpression instanceof JetWhenExpression || innerExpression instanceof JetWhenExpression) {
+        if (parentExpression instanceof KtWhenExpression || innerExpression instanceof KtWhenExpression) {
             return false;
         }
 
-        if (innerExpression instanceof JetIfExpression) {
+        if (innerExpression instanceof KtIfExpression) {
             PsiElement current = parentExpression;
 
-            while (!(current instanceof JetBlockExpression || current instanceof JetDeclaration || current instanceof JetStatementExpression)) {
+            while (!(current instanceof KtBlockExpression || current instanceof KtDeclaration || current instanceof KtStatementExpression)) {
                 if (current.getTextRange().getEndOffset() != currentInner.getTextRange().getEndOffset()) {
                     return current.getText().charAt(current.getTextLength() - 1) != ')'; // if current expression is "guarded" by parenthesis, no extra parenthesis is necessary
                 }
@@ -500,32 +500,32 @@ public class JetPsiUtil {
             }
         }
 
-        if (parentExpression instanceof JetCallExpression && currentInner == ((JetCallExpression) parentExpression).getCalleeExpression()) {
-            if (innerExpression instanceof JetSimpleNameExpression) return false;
+        if (parentExpression instanceof KtCallExpression && currentInner == ((KtCallExpression) parentExpression).getCalleeExpression()) {
+            if (innerExpression instanceof KtSimpleNameExpression) return false;
             if (JetPsiUtilKt.getQualifiedExpressionForSelector(parentExpression) != null) return true;
-            return !(innerExpression instanceof JetThisExpression
-                     || innerExpression instanceof JetArrayAccessExpression
-                     || innerExpression instanceof JetConstantExpression
-                     || innerExpression instanceof JetStringTemplateExpression
-                     || innerExpression instanceof JetCallExpression);
+            return !(innerExpression instanceof KtThisExpression
+                     || innerExpression instanceof KtArrayAccessExpression
+                     || innerExpression instanceof KtConstantExpression
+                     || innerExpression instanceof KtStringTemplateExpression
+                     || innerExpression instanceof KtCallExpression);
         }
 
         IElementType innerOperation = getOperation(innerExpression);
         IElementType parentOperation = getOperation(parentExpression);
 
         // 'return (@label{...})' case
-        if (parentExpression instanceof JetReturnExpression
-            && (innerExpression instanceof JetLabeledExpression || innerExpression instanceof JetAnnotatedExpression)) return true;
+        if (parentExpression instanceof KtReturnExpression
+            && (innerExpression instanceof KtLabeledExpression || innerExpression instanceof KtAnnotatedExpression)) return true;
 
         // '(x: Int) < y' case
-        if (innerExpression instanceof JetBinaryExpressionWithTypeRHS && parentOperation == JetTokens.LT) {
+        if (innerExpression instanceof KtBinaryExpressionWithTypeRHS && parentOperation == KtTokens.LT) {
             return true;
         }
 
-        if (parentExpression instanceof JetLabeledExpression) return false;
+        if (parentExpression instanceof KtLabeledExpression) return false;
 
         // 'x ?: ...' case
-        if (parentExpression instanceof JetBinaryExpression && parentOperation == JetTokens.ELVIS && currentInner == ((JetBinaryExpression) parentExpression).getRight()) {
+        if (parentExpression instanceof KtBinaryExpression && parentOperation == KtTokens.ELVIS && currentInner == ((KtBinaryExpression) parentExpression).getRight()) {
             return false;
         }
 
@@ -533,16 +533,16 @@ public class JetPsiUtil {
         int parentPriority = getPriority(parentExpression);
 
         if (innerPriority == parentPriority) {
-            if (parentExpression instanceof JetBinaryExpression) {
-                if (innerOperation == JetTokens.ANDAND || innerOperation == JetTokens.OROR) {
+            if (parentExpression instanceof KtBinaryExpression) {
+                if (innerOperation == KtTokens.ANDAND || innerOperation == KtTokens.OROR) {
                     return false;
                 }
-                return ((JetBinaryExpression) parentExpression).getRight() == currentInner;
+                return ((KtBinaryExpression) parentExpression).getRight() == currentInner;
             }
 
             //'-(-x)' case
-            if (parentExpression instanceof JetPrefixExpression && innerExpression instanceof JetPrefixExpression) {
-                return innerOperation == parentOperation && (innerOperation == JetTokens.PLUS || innerOperation == JetTokens.MINUS);
+            if (parentExpression instanceof KtPrefixExpression && innerExpression instanceof KtPrefixExpression) {
+                return innerOperation == parentOperation && (innerOperation == KtTokens.PLUS || innerOperation == KtTokens.MINUS);
             }
             return false;
         }
@@ -551,19 +551,19 @@ public class JetPsiUtil {
     }
 
     public static boolean isAssignment(@NotNull PsiElement element) {
-        return element instanceof JetBinaryExpression &&
-               JetTokens.ALL_ASSIGNMENTS.contains(((JetBinaryExpression) element).getOperationToken());
+        return element instanceof KtBinaryExpression &&
+               KtTokens.ALL_ASSIGNMENTS.contains(((KtBinaryExpression) element).getOperationToken());
     }
 
     public static boolean isOrdinaryAssignment(@NotNull PsiElement element) {
-        return element instanceof JetBinaryExpression &&
-               ((JetBinaryExpression) element).getOperationToken().equals(JetTokens.EQ);
+        return element instanceof KtBinaryExpression &&
+               ((KtBinaryExpression) element).getOperationToken().equals(KtTokens.EQ);
     }
 
-    public static boolean checkVariableDeclarationInBlock(@NotNull JetBlockExpression block, @NotNull String varName) {
-        for (JetExpression element : block.getStatements()) {
-            if (element instanceof JetVariableDeclaration) {
-                if (((JetVariableDeclaration) element).getNameAsSafeName().asString().equals(varName)) {
+    public static boolean checkVariableDeclarationInBlock(@NotNull KtBlockExpression block, @NotNull String varName) {
+        for (KtExpression element : block.getStatements()) {
+            if (element instanceof KtVariableDeclaration) {
+                if (((KtVariableDeclaration) element).getNameAsSafeName().asString().equals(varName)) {
                     return true;
                 }
             }
@@ -572,9 +572,9 @@ public class JetPsiUtil {
         return false;
     }
 
-    public static boolean checkWhenExpressionHasSingleElse(@NotNull JetWhenExpression whenExpression) {
+    public static boolean checkWhenExpressionHasSingleElse(@NotNull KtWhenExpression whenExpression) {
         int elseCount = 0;
-        for (JetWhenEntry entry : whenExpression.getEntries()) {
+        for (KtWhenEntry entry : whenExpression.getEntries()) {
             if (entry.isElse()) {
                 elseCount++;
             }
@@ -587,9 +587,9 @@ public class JetPsiUtil {
         return PsiTreeUtil.skipSiblingsForward(element, PsiWhiteSpace.class, PsiComment.class);
     }
 
-    public static final Predicate<JetElement> ANY_JET_ELEMENT = new Predicate<JetElement>() {
+    public static final Predicate<KtElement> ANY_JET_ELEMENT = new Predicate<KtElement>() {
         @Override
-        public boolean apply(@Nullable JetElement input) {
+        public boolean apply(@Nullable KtElement input) {
             return true;
         }
     };
@@ -641,19 +641,19 @@ public class JetPsiUtil {
     }
 
     @Nullable
-    public static JetElement getOutermostDescendantElement(
+    public static KtElement getOutermostDescendantElement(
             @Nullable PsiElement root,
             boolean first,
-            final @NotNull Predicate<JetElement> predicate
+            final @NotNull Predicate<KtElement> predicate
     ) {
-        if (!(root instanceof JetElement)) return null;
+        if (!(root instanceof KtElement)) return null;
 
-        final List<JetElement> results = Lists.newArrayList();
+        final List<KtElement> results = Lists.newArrayList();
 
         root.accept(
-                new JetVisitorVoid() {
+                new KtVisitorVoid() {
                     @Override
-                    public void visitJetElement(@NotNull JetElement element) {
+                    public void visitJetElement(@NotNull KtElement element) {
                         if (predicate.apply(element)) {
                             //noinspection unchecked
                             results.add(element);
@@ -687,15 +687,15 @@ public class JetPsiUtil {
     }
 
     public static PsiElement ascendIfPropertyAccessor(PsiElement element) {
-        if (element instanceof JetPropertyAccessor) {
+        if (element instanceof KtPropertyAccessor) {
             return element.getParent();
         }
         return element;
     }
 
     @Nullable
-    public static JetModifierList replaceModifierList(@NotNull JetModifierListOwner owner, @Nullable JetModifierList modifierList) {
-        JetModifierList oldModifierList = owner.getModifierList();
+    public static KtModifierList replaceModifierList(@NotNull KtModifierListOwner owner, @Nullable KtModifierList modifierList) {
+        KtModifierList oldModifierList = owner.getModifierList();
         if (modifierList == null) {
             if (oldModifierList != null) oldModifierList.delete();
             return null;
@@ -703,50 +703,50 @@ public class JetPsiUtil {
         else {
             if (oldModifierList == null) {
                 PsiElement firstChild = owner.getFirstChild();
-                return (JetModifierList) owner.addBefore(modifierList, firstChild);
+                return (KtModifierList) owner.addBefore(modifierList, firstChild);
             }
             else {
-                return (JetModifierList) oldModifierList.replace(modifierList);
+                return (KtModifierList) oldModifierList.replace(modifierList);
             }
         }
     }
 
     @Nullable
-    public static String getPackageName(@NotNull JetElement element) {
-        JetFile file = element.getContainingJetFile();
-        JetPackageDirective header = PsiTreeUtil.findChildOfType(file, JetPackageDirective.class);
+    public static String getPackageName(@NotNull KtElement element) {
+        KtFile file = element.getContainingJetFile();
+        KtPackageDirective header = PsiTreeUtil.findChildOfType(file, KtPackageDirective.class);
 
         return header != null ? header.getQualifiedName() : null;
     }
 
     @Nullable
-    public static JetElement getEnclosingElementForLocalDeclaration(@NotNull JetDeclaration declaration) {
+    public static KtElement getEnclosingElementForLocalDeclaration(@NotNull KtDeclaration declaration) {
         return getEnclosingElementForLocalDeclaration(declaration, true);
     }
 
-    private static boolean isMemberOfObjectExpression(@NotNull JetCallableDeclaration propertyOrFunction) {
+    private static boolean isMemberOfObjectExpression(@NotNull KtCallableDeclaration propertyOrFunction) {
         PsiElement parent = PsiTreeUtil.getStubOrPsiParent(propertyOrFunction);
-        if (!(parent instanceof JetClassBody)) return false;
+        if (!(parent instanceof KtClassBody)) return false;
         PsiElement grandparent = PsiTreeUtil.getStubOrPsiParent(parent);
-        if (!(grandparent instanceof JetObjectDeclaration)) return false;
-        return PsiTreeUtil.getStubOrPsiParent(grandparent) instanceof JetObjectLiteralExpression;
+        if (!(grandparent instanceof KtObjectDeclaration)) return false;
+        return PsiTreeUtil.getStubOrPsiParent(grandparent) instanceof KtObjectLiteralExpression;
     }
 
     @Nullable
-    public static JetElement getEnclosingElementForLocalDeclaration(@NotNull JetDeclaration declaration, boolean skipParameters) {
-        if (declaration instanceof JetTypeParameter && skipParameters) {
-            declaration = PsiTreeUtil.getParentOfType(declaration, JetNamedDeclaration.class);
+    public static KtElement getEnclosingElementForLocalDeclaration(@NotNull KtDeclaration declaration, boolean skipParameters) {
+        if (declaration instanceof KtTypeParameter && skipParameters) {
+            declaration = PsiTreeUtil.getParentOfType(declaration, KtNamedDeclaration.class);
         }
-        else if (declaration instanceof JetParameter) {
+        else if (declaration instanceof KtParameter) {
             PsiElement parent = declaration.getParent();
 
             // val/var parameter of primary constructor should be considered as local according to containing class
-            if (((JetParameter) declaration).hasValOrVar() && parent != null && parent.getParent() instanceof JetPrimaryConstructor) {
-                return getEnclosingElementForLocalDeclaration(((JetPrimaryConstructor) parent.getParent()).getContainingClassOrObject(), skipParameters);
+            if (((KtParameter) declaration).hasValOrVar() && parent != null && parent.getParent() instanceof KtPrimaryConstructor) {
+                return getEnclosingElementForLocalDeclaration(((KtPrimaryConstructor) parent.getParent()).getContainingClassOrObject(), skipParameters);
             }
 
-            else if (skipParameters && parent != null && parent.getParent() instanceof JetNamedFunction) {
-                declaration = (JetNamedFunction) parent.getParent();
+            else if (skipParameters && parent != null && parent.getParent() instanceof KtNamedFunction) {
+                declaration = (KtNamedFunction) parent.getParent();
             }
         }
 
@@ -758,20 +758,20 @@ public class JetPsiUtil {
         PsiElement current = PsiTreeUtil.getStubOrPsiParent(declaration);
         while (current != null) {
             PsiElement parent = PsiTreeUtil.getStubOrPsiParent(current);
-            if (parent instanceof JetScript) return null;
-            if (current instanceof JetClassInitializer) {
-                return ((JetClassInitializer) current).getBody();
+            if (parent instanceof KtScript) return null;
+            if (current instanceof KtClassInitializer) {
+                return ((KtClassInitializer) current).getBody();
             }
-            if (current instanceof JetProperty || current instanceof JetFunction) {
-                if (parent instanceof JetFile) {
-                    return (JetElement) current;
+            if (current instanceof KtProperty || current instanceof KtFunction) {
+                if (parent instanceof KtFile) {
+                    return (KtElement) current;
                 }
-                else if (parent instanceof JetClassBody && !isMemberOfObjectExpression((JetCallableDeclaration) current)) {
-                    return (JetElement) parent;
+                else if (parent instanceof KtClassBody && !isMemberOfObjectExpression((KtCallableDeclaration) current)) {
+                    return (KtElement) parent;
                 }
             }
-            if (current instanceof JetBlockExpression || current instanceof JetParameter) {
-                return (JetElement) current;
+            if (current instanceof KtBlockExpression || current instanceof KtParameter) {
+                return (KtElement) current;
             }
 
             current = parent;
@@ -779,51 +779,51 @@ public class JetPsiUtil {
         return null;
     }
 
-    public static boolean isLocal(@NotNull JetDeclaration declaration) {
+    public static boolean isLocal(@NotNull KtDeclaration declaration) {
         return getEnclosingElementForLocalDeclaration(declaration) != null;
     }
 
     @Nullable
-    public static JetToken getOperationToken(@NotNull JetOperationExpression expression) {
-        JetSimpleNameExpression operationExpression = expression.getOperationReference();
+    public static KtToken getOperationToken(@NotNull KtOperationExpression expression) {
+        KtSimpleNameExpression operationExpression = expression.getOperationReference();
         IElementType elementType = operationExpression.getReferencedNameElementType();
-        assert elementType == null || elementType instanceof JetToken :
-                "JetOperationExpression should have operation token of type JetToken: " +
+        assert elementType == null || elementType instanceof KtToken :
+                "JetOperationExpression should have operation token of type KtToken: " +
                 expression;
-        return (JetToken) elementType;
+        return (KtToken) elementType;
     }
 
     public static boolean isLabelIdentifierExpression(PsiElement element) {
-        return element instanceof JetLabelReferenceExpression;
+        return element instanceof KtLabelReferenceExpression;
     }
 
     @Nullable
-    public static JetExpression getParentCallIfPresent(@NotNull JetExpression expression) {
+    public static KtExpression getParentCallIfPresent(@NotNull KtExpression expression) {
         PsiElement parent = expression.getParent();
         while (parent != null) {
-            if (parent instanceof JetBinaryExpression ||
-                parent instanceof JetUnaryExpression ||
-                parent instanceof JetLabeledExpression ||
-                parent instanceof JetDotQualifiedExpression ||
-                parent instanceof JetCallExpression ||
-                parent instanceof JetArrayAccessExpression ||
-                parent instanceof JetMultiDeclaration) {
+            if (parent instanceof KtBinaryExpression ||
+                parent instanceof KtUnaryExpression ||
+                parent instanceof KtLabeledExpression ||
+                parent instanceof KtDotQualifiedExpression ||
+                parent instanceof KtCallExpression ||
+                parent instanceof KtArrayAccessExpression ||
+                parent instanceof KtMultiDeclaration) {
 
-                if (parent instanceof JetLabeledExpression) {
+                if (parent instanceof KtLabeledExpression) {
                     parent = parent.getParent();
                     continue;
                 }
 
                 //check that it's in inlineable call would be in resolve call of parent
-                return (JetExpression) parent;
+                return (KtExpression) parent;
             }
-            else if (parent instanceof JetParenthesizedExpression || parent instanceof JetBinaryExpressionWithTypeRHS) {
+            else if (parent instanceof KtParenthesizedExpression || parent instanceof KtBinaryExpressionWithTypeRHS) {
                 parent = parent.getParent();
             }
-            else if (parent instanceof JetValueArgument || parent instanceof JetValueArgumentList) {
+            else if (parent instanceof KtValueArgument || parent instanceof KtValueArgumentList) {
                 parent = parent.getParent();
             }
-            else if (parent instanceof JetFunctionLiteralExpression || parent instanceof JetAnnotatedExpression) {
+            else if (parent instanceof KtFunctionLiteralExpression || parent instanceof KtAnnotatedExpression) {
                 parent = parent.getParent();
             }
             else {
@@ -834,18 +834,18 @@ public class JetPsiUtil {
     }
 
     @Nullable
-    public static JetExpression getLastElementDeparenthesized(
-            @Nullable JetExpression expression,
+    public static KtExpression getLastElementDeparenthesized(
+            @Nullable KtExpression expression,
             @NotNull StatementFilter statementFilter
     ) {
-        JetExpression deparenthesizedExpression = deparenthesize(expression);
-        if (deparenthesizedExpression instanceof JetBlockExpression) {
-            JetBlockExpression blockExpression = (JetBlockExpression) deparenthesizedExpression;
+        KtExpression deparenthesizedExpression = deparenthesize(expression);
+        if (deparenthesizedExpression instanceof KtBlockExpression) {
+            KtBlockExpression blockExpression = (KtBlockExpression) deparenthesizedExpression;
             // todo
             // This case is a temporary hack for 'if' branches.
             // The right way to implement this logic is to interpret 'if' branches as function literals with explicitly-typed signatures
             // (no arguments and no receiver) and therefore analyze them straight away (not in the 'complete' phase).
-            JetExpression lastStatementInABlock = StatementFilterKt.getLastStatementInABlock(statementFilter, blockExpression);
+            KtExpression lastStatementInABlock = StatementFilterKt.getLastStatementInABlock(statementFilter, blockExpression);
             if (lastStatementInABlock != null) {
                 return getLastElementDeparenthesized(lastStatementInABlock, statementFilter);
             }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetQualifiedExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtQualifiedExpression.java
similarity index 78%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetQualifiedExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtQualifiedExpression.java
index a3d7a9e6457..020dec85562 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetQualifiedExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtQualifiedExpression.java
@@ -19,18 +19,18 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetToken;
+import org.jetbrains.kotlin.lexer.KtToken;
 
-public interface JetQualifiedExpression extends JetExpression {
+public interface KtQualifiedExpression extends KtExpression {
     @NotNull
-    JetExpression getReceiverExpression();
+    KtExpression getReceiverExpression();
 
     @Nullable
-    JetExpression getSelectorExpression();
+    KtExpression getSelectorExpression();
 
     @NotNull
     ASTNode getOperationTokenNode();
 
     @NotNull
-    JetToken getOperationSign();
+    KtToken getOperationSign();
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetQualifiedExpressionImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtQualifiedExpressionImpl.kt
similarity index 61%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetQualifiedExpressionImpl.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtQualifiedExpressionImpl.kt
index 1d15530d9be..2d314231b26 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetQualifiedExpressionImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtQualifiedExpressionImpl.kt
@@ -17,30 +17,30 @@
 package org.jetbrains.kotlin.psi
 
 import com.intellij.lang.ASTNode
-import org.jetbrains.kotlin.lexer.JetToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.psi.psiUtil.*
 
-object JetQualifiedExpressionImpl {
-    public fun JetQualifiedExpression.getOperationTokenNode(): ASTNode {
-        val operationNode = this.getNode()!!.findChildByType(JetTokens.OPERATIONS)
+object KtQualifiedExpressionImpl {
+    public fun KtQualifiedExpression.getOperationTokenNode(): ASTNode {
+        val operationNode = this.getNode()!!.findChildByType(KtTokens.OPERATIONS)
         return operationNode!!
     }
 
-    public fun JetQualifiedExpression.getOperationSign(): JetToken {
-        return this.getOperationTokenNode().getElementType() as JetToken
+    public fun KtQualifiedExpression.getOperationSign(): KtToken {
+        return this.getOperationTokenNode().getElementType() as KtToken
     }
 
-    private fun JetQualifiedExpression.getExpression(afterOperation: Boolean): JetExpression? {
-        return getOperationTokenNode().getPsi()?.siblings(afterOperation, false)?.firstOrNull { it is JetExpression } as? JetExpression
+    private fun KtQualifiedExpression.getExpression(afterOperation: Boolean): KtExpression? {
+        return getOperationTokenNode().getPsi()?.siblings(afterOperation, false)?.firstOrNull { it is KtExpression } as? KtExpression
     }
 
-    public fun JetQualifiedExpression.getReceiverExpression(): JetExpression {
+    public fun KtQualifiedExpression.getReceiverExpression(): KtExpression {
         return getExpression(false) ?: throw AssertionError("No receiver found: ${getElementTextWithContext()}")
     }
 
-    public fun JetQualifiedExpression.getSelectorExpression(): JetExpression? {
+    public fun KtQualifiedExpression.getSelectorExpression(): KtExpression? {
         return getExpression(true)
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetReferenceExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtReferenceExpression.java
similarity index 90%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetReferenceExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtReferenceExpression.java
index 3cfc2bb84d9..84f2383b506 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetReferenceExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtReferenceExpression.java
@@ -16,5 +16,5 @@
 
 package org.jetbrains.kotlin.psi;
 
-public interface JetReferenceExpression extends JetExpression {
+public interface KtReferenceExpression extends KtExpression {
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetReturnExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtReturnExpression.java
similarity index 72%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetReturnExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtReturnExpression.java
index d42fe5b67e1..f7b6fe78a0b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetReturnExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtReturnExpression.java
@@ -20,18 +20,18 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public class JetReturnExpression extends JetExpressionWithLabel implements JetStatementExpression {
-    public JetReturnExpression(@NotNull ASTNode node) {
+public class KtReturnExpression extends KtExpressionWithLabel implements KtStatementExpression {
+    public KtReturnExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitReturnExpression(this, data);
     }
 
     @Nullable
-    public JetExpression getReturnedExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getReturnedExpression() {
+        return findChildByClass(KtExpression.class);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetRootPackageExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtRootPackageExpression.java
similarity index 80%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetRootPackageExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtRootPackageExpression.java
index 6da06d1e176..42657c93679 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetRootPackageExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtRootPackageExpression.java
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 
-public class JetRootPackageExpression extends JetExpressionImpl {
-    public JetRootPackageExpression(@NotNull ASTNode node) {
+public class KtRootPackageExpression extends KtExpressionImpl {
+    public KtRootPackageExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitRootPackageExpression(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSafeQualifiedExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtSafeQualifiedExpression.java
similarity index 58%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetSafeQualifiedExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtSafeQualifiedExpression.java
index 45809f48fee..8c73e3f104c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSafeQualifiedExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtSafeQualifiedExpression.java
@@ -19,39 +19,39 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetToken;
+import org.jetbrains.kotlin.lexer.KtToken;
 
-public class JetSafeQualifiedExpression extends JetExpressionImpl implements JetQualifiedExpression {
-    public JetSafeQualifiedExpression(@NotNull ASTNode node) {
+public class KtSafeQualifiedExpression extends KtExpressionImpl implements KtQualifiedExpression {
+    public KtSafeQualifiedExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitSafeQualifiedExpression(this, data);
     }
 
     @NotNull
     @Override
-    public JetExpression getReceiverExpression() {
-        return JetQualifiedExpressionImpl.INSTANCE$.getReceiverExpression(this);
+    public KtExpression getReceiverExpression() {
+        return KtQualifiedExpressionImpl.INSTANCE$.getReceiverExpression(this);
     }
 
     @Nullable
     @Override
-    public JetExpression getSelectorExpression() {
-        return JetQualifiedExpressionImpl.INSTANCE$.getSelectorExpression(this);
+    public KtExpression getSelectorExpression() {
+        return KtQualifiedExpressionImpl.INSTANCE$.getSelectorExpression(this);
     }
 
     @NotNull
     @Override
     public ASTNode getOperationTokenNode() {
-        return JetQualifiedExpressionImpl.INSTANCE$.getOperationTokenNode(this);
+        return KtQualifiedExpressionImpl.INSTANCE$.getOperationTokenNode(this);
     }
 
     @NotNull
     @Override
-    public JetToken getOperationSign() {
-        return JetQualifiedExpressionImpl.INSTANCE$.getOperationSign(this);
+    public KtToken getOperationSign() {
+        return KtQualifiedExpressionImpl.INSTANCE$.getOperationSign(this);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetScript.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtScript.java
similarity index 71%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetScript.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtScript.java
index 5820761bb6d..05d218db914 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetScript.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtScript.java
@@ -23,25 +23,25 @@ import org.jetbrains.annotations.NotNull;
 import java.util.List;
 
 // SCRIPT: Script declaration
-public class JetScript extends JetDeclarationImpl implements JetDeclarationContainer {
+public class KtScript extends KtDeclarationImpl implements KtDeclarationContainer {
 
-    public JetScript(@NotNull ASTNode node) {
+    public KtScript(@NotNull ASTNode node) {
         super(node);
     }
 
     @NotNull
-    public JetBlockExpression getBlockExpression() {
-        return findNotNullChildByClass(JetBlockExpression.class);
+    public KtBlockExpression getBlockExpression() {
+        return findNotNullChildByClass(KtBlockExpression.class);
     }
 
     @Override
     @NotNull
-    public List<JetDeclaration> getDeclarations() {
-        return PsiTreeUtil.getChildrenOfTypeAsList(getBlockExpression(), JetDeclaration.class);
+    public List<KtDeclaration> getDeclarations() {
+        return PsiTreeUtil.getChildrenOfTypeAsList(getBlockExpression(), KtDeclaration.class);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitScript(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSecondaryConstructor.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtSecondaryConstructor.kt
similarity index 68%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetSecondaryConstructor.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtSecondaryConstructor.kt
index 857da6d1f65..bb59191aa36 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSecondaryConstructor.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtSecondaryConstructor.kt
@@ -19,26 +19,26 @@ package org.jetbrains.kotlin.psi
 import com.intellij.lang.ASTNode
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 
-public class JetSecondaryConstructor : JetConstructor<JetSecondaryConstructor> {
+public class KtSecondaryConstructor : KtConstructor<KtSecondaryConstructor> {
     public constructor(node: ASTNode) : super(node)
-    public constructor(stub: KotlinPlaceHolderStub<JetSecondaryConstructor>) : super(stub, JetStubElementTypes.SECONDARY_CONSTRUCTOR)
+    public constructor(stub: KotlinPlaceHolderStub<KtSecondaryConstructor>) : super(stub, KtStubElementTypes.SECONDARY_CONSTRUCTOR)
 
-    override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D) = visitor.visitSecondaryConstructor(this, data)
+    override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D) = visitor.visitSecondaryConstructor(this, data)
 
-    override fun getContainingClassOrObject() = getParent().getParent() as JetClassOrObject
+    override fun getContainingClassOrObject() = getParent().getParent() as KtClassOrObject
 
-    override fun getBodyExpression() = findChildByClass(javaClass<JetBlockExpression>())
+    override fun getBodyExpression() = findChildByClass(javaClass<KtBlockExpression>())
 
     override fun getConstructorKeyword() = notNullChild<PsiElement>(super.getConstructorKeyword())
 
-    public fun getDelegationCall(): JetConstructorDelegationCall = findNotNullChildByClass(javaClass<JetConstructorDelegationCall>())
+    public fun getDelegationCall(): KtConstructorDelegationCall = findNotNullChildByClass(javaClass<KtConstructorDelegationCall>())
 
     public fun hasImplicitDelegationCall(): Boolean = getDelegationCall().isImplicit()
 
-    public fun replaceImplicitDelegationCallWithExplicit(isThis: Boolean): JetConstructorDelegationCall {
-        val psiFactory = JetPsiFactory(getProject())
+    public fun replaceImplicitDelegationCallWithExplicit(isThis: Boolean): KtConstructorDelegationCall {
+        val psiFactory = KtPsiFactory(getProject())
         val current = getDelegationCall()
 
         assert(current.isImplicit()) { "Method should not be called with explicit delegation call: " + getText() }
@@ -48,6 +48,6 @@ public class JetSecondaryConstructor : JetConstructor<JetSecondaryConstructor> {
 
         val delegationName = if (isThis) "this" else "super"
 
-        return addAfter(psiFactory.createConstructorDelegationCall(delegationName + "()"), colon) as JetConstructorDelegationCall
+        return addAfter(psiFactory.createConstructorDelegationCall(delegationName + "()"), colon) as KtConstructorDelegationCall
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSelfType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtSelfType.java
similarity index 78%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetSelfType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtSelfType.java
index e204b73a050..fdf90acf373 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSelfType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtSelfType.java
@@ -22,19 +22,19 @@ import org.jetbrains.annotations.NotNull;
 import java.util.Collections;
 import java.util.List;
 
-public class JetSelfType extends JetElementImpl implements JetTypeElement {
-    public JetSelfType(@NotNull ASTNode node) {
+public class KtSelfType extends KtElementImpl implements KtTypeElement {
+    public KtSelfType(@NotNull ASTNode node) {
         super(node);
     }
 
     @NotNull
     @Override
-    public List<JetTypeReference> getTypeArgumentsAsTypes() {
+    public List<KtTypeReference> getTypeArgumentsAsTypes() {
         return Collections.emptyList();
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitSelfType(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSimpleNameExpression.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtSimpleNameExpression.kt
similarity index 74%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetSimpleNameExpression.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtSimpleNameExpression.kt
index cd27067605f..abad3ddf9e2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSimpleNameExpression.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtSimpleNameExpression.kt
@@ -20,10 +20,10 @@ import com.intellij.lang.ASTNode
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiReference
 import com.intellij.psi.tree.IElementType
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 
-public interface JetSimpleNameExpression : JetReferenceExpression {
+public interface KtSimpleNameExpression : KtReferenceExpression {
 
     public fun getReferencedName(): String
 
@@ -36,12 +36,12 @@ public interface JetSimpleNameExpression : JetReferenceExpression {
     public fun getReferencedNameElementType(): IElementType
 }
 
-abstract class JetSimpleNameExpressionImpl(node: ASTNode) : JetExpressionImpl(node), JetSimpleNameExpression {
-    override fun getIdentifier(): PsiElement? = findChildByType(JetTokens.IDENTIFIER)
+abstract class KtSimpleNameExpressionImpl(node: ASTNode) : KtExpressionImpl(node), KtSimpleNameExpression {
+    override fun getIdentifier(): PsiElement? = findChildByType(KtTokens.IDENTIFIER)
 
     override fun getReferencedNameElementType() = getReferencedNameElementTypeImpl(this)
 
-    override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D): R {
+    override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D): R {
         return visitor.visitSimpleNameExpression(this, data)
     }
 
@@ -51,18 +51,18 @@ abstract class JetSimpleNameExpressionImpl(node: ASTNode) : JetExpressionImpl(no
 
     //NOTE: an unfortunate way to share an implementation between stubbed and not stubbed tree
     companion object {
-        fun getReferencedNameElementTypeImpl(expression: JetSimpleNameExpression): IElementType {
+        fun getReferencedNameElementTypeImpl(expression: KtSimpleNameExpression): IElementType {
             return expression.getReferencedNameElement().getNode()!!.getElementType()
         }
 
-        fun getReferencedNameAsNameImpl(expresssion: JetSimpleNameExpression): Name {
+        fun getReferencedNameAsNameImpl(expresssion: KtSimpleNameExpression): Name {
             val name = expresssion.getReferencedName()
             return Name.identifier(name)
         }
 
-        fun getReferencedNameImpl(expression: JetSimpleNameExpression): String {
+        fun getReferencedNameImpl(expression: KtSimpleNameExpression): String {
             val text = expression.getReferencedNameElement().getNode()!!.getText()
-            return JetPsiUtil.unquoteIdentifierOrFieldReference(text)
+            return KtPsiUtil.unquoteIdentifierOrFieldReference(text)
         }
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSimpleNameStringTemplateEntry.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtSimpleNameStringTemplateEntry.java
similarity index 78%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetSimpleNameStringTemplateEntry.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtSimpleNameStringTemplateEntry.java
index 6d17c96ef83..d7ab9f000c8 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSimpleNameStringTemplateEntry.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtSimpleNameStringTemplateEntry.java
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 
-public class JetSimpleNameStringTemplateEntry extends JetStringTemplateEntryWithExpression {
-    public JetSimpleNameStringTemplateEntry(@NotNull ASTNode node) {
+public class KtSimpleNameStringTemplateEntry extends KtStringTemplateEntryWithExpression {
+    public KtSimpleNameStringTemplateEntry(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitSimpleNameStringTemplateEntry(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetStatementExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtStatementExpression.java
similarity index 81%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetStatementExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtStatementExpression.java
index 6ec84e347da..0fd1933ac78 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetStatementExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtStatementExpression.java
@@ -17,10 +17,10 @@
 package org.jetbrains.kotlin.psi;
 
 /**
- * This is an interface to show that {@link JetExpression} is not
+ * This is an interface to show that {@link KtExpression} is not
  * actually an expression (in meaning that this expression can be placed after "val x = ").
  * This is possibly redundant interface, all inheritors of this interface should be refactored that they are not
- * {@link JetExpression}, after such refactoring, this interface can be removed.
+ * {@link KtExpression}, after such refactoring, this interface can be removed.
  */
-public interface JetStatementExpression {
+public interface KtStatementExpression {
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetStringTemplateEntry.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtStringTemplateEntry.java
similarity index 78%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetStringTemplateEntry.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtStringTemplateEntry.java
index 9772aa5423a..b9b59b21980 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetStringTemplateEntry.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtStringTemplateEntry.java
@@ -20,13 +20,13 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public abstract class JetStringTemplateEntry extends JetElementImpl {
-    public JetStringTemplateEntry(@NotNull ASTNode node) {
+public abstract class KtStringTemplateEntry extends KtElementImpl {
+    public KtStringTemplateEntry(@NotNull ASTNode node) {
         super(node);
     }
 
     @Nullable
-    public JetExpression getExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getExpression() {
+        return findChildByClass(KtExpression.class);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetStringTemplateEntryWithExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtStringTemplateEntryWithExpression.java
similarity index 77%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetStringTemplateEntryWithExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtStringTemplateEntryWithExpression.java
index 72c966414b7..179a1be4810 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetStringTemplateEntryWithExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtStringTemplateEntryWithExpression.java
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 
-public abstract class JetStringTemplateEntryWithExpression extends JetStringTemplateEntry {
-    public JetStringTemplateEntryWithExpression(@NotNull ASTNode node) {
+public abstract class KtStringTemplateEntryWithExpression extends KtStringTemplateEntry {
+    public KtStringTemplateEntryWithExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitStringTemplateEntryWithExpression(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetStringTemplateExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtStringTemplateExpression.java
similarity index 73%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetStringTemplateExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtStringTemplateExpression.java
index c790fe2067a..11f463bc8c7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetStringTemplateExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtStringTemplateExpression.java
@@ -22,24 +22,24 @@ import com.intellij.psi.LiteralTextEscaper;
 import com.intellij.psi.PsiLanguageInjectionHost;
 import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-public class JetStringTemplateExpression extends JetExpressionImpl implements PsiLanguageInjectionHost {
-    private static final TokenSet TOKENS_SUITABLE_FOR_INJECTION = TokenSet.create(JetNodeTypes.LITERAL_STRING_TEMPLATE_ENTRY, JetNodeTypes.ESCAPE_STRING_TEMPLATE_ENTRY);
+public class KtStringTemplateExpression extends KtExpressionImpl implements PsiLanguageInjectionHost {
+    private static final TokenSet TOKENS_SUITABLE_FOR_INJECTION = TokenSet.create(KtNodeTypes.LITERAL_STRING_TEMPLATE_ENTRY, KtNodeTypes.ESCAPE_STRING_TEMPLATE_ENTRY);
 
-    public JetStringTemplateExpression(@NotNull ASTNode node) {
+    public KtStringTemplateExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitStringTemplateExpression(this, data);
     }
 
     @NotNull
-    public JetStringTemplateEntry[] getEntries() {
-        return findChildrenByClass(JetStringTemplateEntry.class);
+    public KtStringTemplateEntry[] getEntries() {
+        return findChildrenByClass(KtStringTemplateEntry.class);
     }
 
     @Override
@@ -47,7 +47,7 @@ public class JetStringTemplateExpression extends JetExpressionImpl implements Ps
         ASTNode node = getNode();
         ASTNode child = node.getFirstChildNode().getTreeNext();
         while (child != null) {
-            if (child.getElementType() == JetTokens.CLOSING_QUOTE) return true;
+            if (child.getElementType() == KtTokens.CLOSING_QUOTE) return true;
             if (!TOKENS_SUITABLE_FOR_INJECTION.contains(child.getElementType())) return false;
             child = child.getTreeNext();
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetStubbedPsiUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtStubbedPsiUtil.java
similarity index 73%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetStubbedPsiUtil.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtStubbedPsiUtil.java
index 777648e87e3..97962d15a7f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetStubbedPsiUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtStubbedPsiUtil.java
@@ -24,20 +24,20 @@ import com.intellij.util.ArrayFactory;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public final class JetStubbedPsiUtil {
+public final class KtStubbedPsiUtil {
     @Nullable
-    public static JetDeclaration getContainingDeclaration(@NotNull PsiElement element) {
-        return getPsiOrStubParent(element, JetDeclaration.class, true);
+    public static KtDeclaration getContainingDeclaration(@NotNull PsiElement element) {
+        return getPsiOrStubParent(element, KtDeclaration.class, true);
     }
 
     @Nullable
-    public static <T extends JetDeclaration> T getContainingDeclaration(@NotNull PsiElement element, @NotNull Class<T> declarationClass) {
+    public static <T extends KtDeclaration> T getContainingDeclaration(@NotNull PsiElement element, @NotNull Class<T> declarationClass) {
         return getPsiOrStubParent(element, declarationClass, true);
     }
 
     //TODO: contribute to idea PsiTreeUtil#getPsiOrStubParent
     @Nullable
-    public static <T extends JetElement> T getPsiOrStubParent(
+    public static <T extends KtElement> T getPsiOrStubParent(
             @NotNull PsiElement element,
             @NotNull Class<T> declarationClass,
             boolean strict
@@ -46,8 +46,8 @@ public final class JetStubbedPsiUtil {
             //noinspection unchecked
             return (T) element;
         }
-        if (element instanceof JetElementImplStub) {
-            StubElement<?> stub = ((JetElementImplStub) element).getStub();
+        if (element instanceof KtElementImplStub) {
+            StubElement<?> stub = ((KtElementImplStub) element).getStub();
             if (stub != null) {
                 return stub.getParentStubOfType(declarationClass);
             }
@@ -56,8 +56,8 @@ public final class JetStubbedPsiUtil {
     }
 
     @Nullable
-    public static <T extends JetElement> T getStubOrPsiChild(
-            @NotNull JetElementImplStub<?> element,
+    public static <T extends KtElement> T getStubOrPsiChild(
+            @NotNull KtElementImplStub<?> element,
             @NotNull TokenSet types,
             @NotNull ArrayFactory<T> factory
     ) {
@@ -68,6 +68,6 @@ public final class JetStubbedPsiUtil {
         return typeElements[0];
     }
 
-    private JetStubbedPsiUtil() {
+    private KtStubbedPsiUtil() {
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSuperExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtSuperExpression.java
similarity index 71%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetSuperExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtSuperExpression.java
index 4bfa2494e01..2d407c6b565 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSuperExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtSuperExpression.java
@@ -19,16 +19,16 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
-public class JetSuperExpression extends JetInstanceExpressionWithLabel implements JetStatementExpression {
+public class KtSuperExpression extends KtInstanceExpressionWithLabel implements KtStatementExpression {
 
-    public JetSuperExpression(@NotNull ASTNode node) {
+    public KtSuperExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitSuperExpression(this, data);
     }
 
@@ -41,7 +41,7 @@ public class JetSuperExpression extends JetInstanceExpressionWithLabel implement
      * }
      */
     @Nullable
-    public JetTypeReference getSuperTypeQualifier() {
-        return (JetTypeReference) findChildByType(JetNodeTypes.TYPE_REFERENCE);
+    public KtTypeReference getSuperTypeQualifier() {
+        return (KtTypeReference) findChildByType(KtNodeTypes.TYPE_REFERENCE);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetThisExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtThisExpression.java
similarity index 80%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetThisExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtThisExpression.java
index e74f6ef0c8d..beaf6de870c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetThisExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtThisExpression.java
@@ -19,14 +19,14 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 
-public class JetThisExpression extends JetInstanceExpressionWithLabel {
+public class KtThisExpression extends KtInstanceExpressionWithLabel {
 
-    public JetThisExpression(@NotNull ASTNode node) {
+    public KtThisExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitThisExpression(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetThrowExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtThrowExpression.java
similarity index 73%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetThrowExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtThrowExpression.java
index 5eaff6e4630..739955c2b01 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetThrowExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtThrowExpression.java
@@ -20,18 +20,18 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public class JetThrowExpression extends JetExpressionImpl implements JetStatementExpression {
-    public JetThrowExpression(@NotNull ASTNode node) {
+public class KtThrowExpression extends KtExpressionImpl implements KtStatementExpression {
+    public KtThrowExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitThrowExpression(this, data);
     }
 
     @Nullable @IfNotParsed
-    public JetExpression getThrownExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getThrownExpression() {
+        return findChildByClass(KtExpression.class);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTreeVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTreeVisitor.java
similarity index 82%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTreeVisitor.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTreeVisitor.java
index 8283d80252c..5094da0fb7e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTreeVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTreeVisitor.java
@@ -18,15 +18,15 @@ package org.jetbrains.kotlin.psi;
 
 import org.jetbrains.annotations.NotNull;
 
-public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
+public class KtTreeVisitor<D> extends KtVisitor<Void, D> {
     @Override
-    public Void visitJetElement(@NotNull JetElement element, D data) {
+    public Void visitJetElement(@NotNull KtElement element, D data) {
         element.acceptChildren(this, data);
         return null;
     }
 
     @Override
-    public Void visitJetFile(@NotNull JetFile file, D data) {
+    public Void visitJetFile(@NotNull KtFile file, D data) {
         super.visitJetFile(file, data);
         file.acceptChildren(this, data);
         return null;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTreeVisitorVoid.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTreeVisitorVoid.java
similarity index 93%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTreeVisitorVoid.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTreeVisitorVoid.java
index 82b4d8f4bd0..1517cfa9ba0 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTreeVisitorVoid.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTreeVisitorVoid.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 
-public class JetTreeVisitorVoid extends JetVisitorVoid {
+public class KtTreeVisitorVoid extends KtVisitorVoid {
     @Override
     public void visitElement(@NotNull PsiElement element) {
         element.acceptChildren(this);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTryExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTryExpression.java
similarity index 62%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTryExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTryExpression.java
index b4ac80f51cd..8d82d7d4b5d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTryExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTryExpression.java
@@ -19,33 +19,33 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
 import java.util.List;
 
-public class JetTryExpression extends JetExpressionImpl {
-    public JetTryExpression(@NotNull ASTNode node) {
+public class KtTryExpression extends KtExpressionImpl {
+    public KtTryExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitTryExpression(this, data);
     }
 
     @NotNull
-    public JetBlockExpression getTryBlock() {
-        return (JetBlockExpression) findChildByType(JetNodeTypes.BLOCK);
+    public KtBlockExpression getTryBlock() {
+        return (KtBlockExpression) findChildByType(KtNodeTypes.BLOCK);
     }
 
     @NotNull
-    public List<JetCatchClause> getCatchClauses() {
-        return findChildrenByType(JetNodeTypes.CATCH);
+    public List<KtCatchClause> getCatchClauses() {
+        return findChildrenByType(KtNodeTypes.CATCH);
     }
 
     @Nullable
-    public JetFinallySection getFinallyBlock() {
-        return (JetFinallySection) findChildByType(JetNodeTypes.FINALLY);
+    public KtFinallySection getFinallyBlock() {
+        return (KtFinallySection) findChildByType(KtNodeTypes.FINALLY);
     }
 
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeArgumentList.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeArgumentList.java
similarity index 61%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeArgumentList.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeArgumentList.java
index 1c6736ced58..cc5739ce942 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeArgumentList.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeArgumentList.java
@@ -19,26 +19,26 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.List;
 
-public class JetTypeArgumentList extends JetElementImplStub<KotlinPlaceHolderStub<JetTypeArgumentList>> {
-    public JetTypeArgumentList(@NotNull ASTNode node) {
+public class KtTypeArgumentList extends KtElementImplStub<KotlinPlaceHolderStub<KtTypeArgumentList>> {
+    public KtTypeArgumentList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetTypeArgumentList(@NotNull KotlinPlaceHolderStub<JetTypeArgumentList> stub) {
-        super(stub, JetStubElementTypes.TYPE_ARGUMENT_LIST);
+    public KtTypeArgumentList(@NotNull KotlinPlaceHolderStub<KtTypeArgumentList> stub) {
+        super(stub, KtStubElementTypes.TYPE_ARGUMENT_LIST);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitTypeArgumentList(this, data);
     }
 
     @NotNull
-    public List<JetTypeProjection> getArguments() {
-        return getStubOrPsiChildrenAsList(JetStubElementTypes.TYPE_PROJECTION);
+    public List<KtTypeProjection> getArguments() {
+        return getStubOrPsiChildrenAsList(KtStubElementTypes.TYPE_PROJECTION);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeCodeFragment.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeCodeFragment.java
similarity index 65%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeCodeFragment.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeCodeFragment.java
index 0537c2d0234..fe012c085dd 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeCodeFragment.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeCodeFragment.java
@@ -19,20 +19,20 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
-public class JetTypeCodeFragment extends JetCodeFragment {
-    public JetTypeCodeFragment(Project project, String name, CharSequence text, PsiElement context) {
-        super(project, name, text, null, JetNodeTypes.TYPE_CODE_FRAGMENT, context);
+public class KtTypeCodeFragment extends KtCodeFragment {
+    public KtTypeCodeFragment(Project project, String name, CharSequence text, PsiElement context) {
+        super(project, name, text, null, KtNodeTypes.TYPE_CODE_FRAGMENT, context);
     }
 
     public boolean hasTypeReference() {
-        return getContentElement() instanceof JetTypeReference;
+        return getContentElement() instanceof KtTypeReference;
     }
 
     @Nullable
     @Override
-    public JetElement getContentElement() {
-        return findChildByClass(JetTypeReference.class);
+    public KtElement getContentElement() {
+        return findChildByClass(KtTypeReference.class);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeCodeFragmentType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeCodeFragmentType.java
similarity index 90%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeCodeFragmentType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeCodeFragmentType.java
index 14862e9846a..c2fee791ddc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeCodeFragmentType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeCodeFragmentType.java
@@ -24,12 +24,12 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.parsing.JetParser;
-import org.jetbrains.kotlin.psi.stubs.elements.JetFileElementType;
+import org.jetbrains.kotlin.psi.stubs.elements.KtFileElementType;
 
-public class JetTypeCodeFragmentType extends JetFileElementType {
+public class KtTypeCodeFragmentType extends KtFileElementType {
     private static final String NAME = "kotlin.TYPE_CODE_FRAGMENT";
 
-    public JetTypeCodeFragmentType() {
+    public KtTypeCodeFragmentType() {
         super(NAME);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeConstraint.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeConstraint.java
similarity index 58%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeConstraint.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeConstraint.java
index 64b5c748ab1..d77e061d85d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeConstraint.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeConstraint.java
@@ -20,29 +20,29 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
-public class JetTypeConstraint extends JetElementImplStub<KotlinPlaceHolderStub<JetTypeConstraint>> {
-    public JetTypeConstraint(@NotNull ASTNode node) {
+public class KtTypeConstraint extends KtElementImplStub<KotlinPlaceHolderStub<KtTypeConstraint>> {
+    public KtTypeConstraint(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetTypeConstraint(@NotNull KotlinPlaceHolderStub<JetTypeConstraint> stub) {
-        super(stub, JetStubElementTypes.TYPE_CONSTRAINT);
+    public KtTypeConstraint(@NotNull KotlinPlaceHolderStub<KtTypeConstraint> stub) {
+        super(stub, KtStubElementTypes.TYPE_CONSTRAINT);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitTypeConstraint(this, data);
     }
 
     @Nullable @IfNotParsed
-    public JetSimpleNameExpression getSubjectTypeParameterName() {
-        return getStubOrPsiChild(JetStubElementTypes.REFERENCE_EXPRESSION);
+    public KtSimpleNameExpression getSubjectTypeParameterName() {
+        return getStubOrPsiChild(KtStubElementTypes.REFERENCE_EXPRESSION);
     }
 
     @Nullable @IfNotParsed
-    public JetTypeReference getBoundTypeReference() {
-        return getStubOrPsiChild(JetStubElementTypes.TYPE_REFERENCE);
+    public KtTypeReference getBoundTypeReference() {
+        return getStubOrPsiChild(KtStubElementTypes.TYPE_REFERENCE);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeConstraintList.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeConstraintList.java
similarity index 60%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeConstraintList.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeConstraintList.java
index 8f467600949..0097e7e1045 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeConstraintList.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeConstraintList.java
@@ -19,26 +19,26 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.List;
 
-public class JetTypeConstraintList extends JetElementImplStub<KotlinPlaceHolderStub<JetTypeConstraintList>> {
-    public JetTypeConstraintList(@NotNull ASTNode node) {
+public class KtTypeConstraintList extends KtElementImplStub<KotlinPlaceHolderStub<KtTypeConstraintList>> {
+    public KtTypeConstraintList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetTypeConstraintList(@NotNull KotlinPlaceHolderStub<JetTypeConstraintList> stub) {
-        super(stub, JetStubElementTypes.TYPE_CONSTRAINT_LIST);
+    public KtTypeConstraintList(@NotNull KotlinPlaceHolderStub<KtTypeConstraintList> stub) {
+        super(stub, KtStubElementTypes.TYPE_CONSTRAINT_LIST);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitTypeConstraintList(this, data);
     }
 
     @NotNull
-    public List<JetTypeConstraint> getConstraints() {
-        return getStubOrPsiChildrenAsList(JetStubElementTypes.TYPE_CONSTRAINT);
+    public List<KtTypeConstraint> getConstraints() {
+        return getStubOrPsiChildrenAsList(KtStubElementTypes.TYPE_CONSTRAINT);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeElement.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeElement.java
similarity index 68%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeElement.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeElement.java
index 903c621fda3..75fc78aebb7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeElement.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeElement.java
@@ -21,18 +21,18 @@ import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 
-public interface JetTypeElement extends JetElement {
-    JetTypeElement[] EMPTY_ARRAY = new JetTypeElement[0];
+public interface KtTypeElement extends KtElement {
+    KtTypeElement[] EMPTY_ARRAY = new KtTypeElement[0];
 
-    ArrayFactory<JetTypeElement> ARRAY_FACTORY = new ArrayFactory<JetTypeElement>() {
+    ArrayFactory<KtTypeElement> ARRAY_FACTORY = new ArrayFactory<KtTypeElement>() {
         @NotNull
         @Override
-        public JetTypeElement[] create(int count) {
-            return count == 0 ? EMPTY_ARRAY : new JetTypeElement[count];
+        public KtTypeElement[] create(int count) {
+            return count == 0 ? EMPTY_ARRAY : new KtTypeElement[count];
         }
     };
 
     // may contain null
     @NotNull
-    List<JetTypeReference> getTypeArgumentsAsTypes();
+    List<KtTypeReference> getTypeArgumentsAsTypes();
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameter.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameter.java
similarity index 57%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameter.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameter.java
index 5a8cbd5930b..fd39d8c327b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameter.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameter.java
@@ -18,26 +18,25 @@ package org.jetbrains.kotlin.psi;
 
 import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
-import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.stubs.KotlinTypeParameterStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 import org.jetbrains.kotlin.types.Variance;
-import org.jetbrains.kotlin.lexer.JetTokens;
 
-public class JetTypeParameter extends JetNamedDeclarationStub<KotlinTypeParameterStub> {
+public class KtTypeParameter extends KtNamedDeclarationStub<KotlinTypeParameterStub> {
 
-    public JetTypeParameter(@NotNull ASTNode node) {
+    public KtTypeParameter(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetTypeParameter(@NotNull KotlinTypeParameterStub stub) {
-        super(stub, JetStubElementTypes.TYPE_PARAMETER);
+    public KtTypeParameter(@NotNull KotlinTypeParameterStub stub) {
+        super(stub, KtStubElementTypes.TYPE_PARAMETER);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitTypeParameter(this, data);
     }
 
@@ -50,37 +49,37 @@ public class JetTypeParameter extends JetNamedDeclarationStub<KotlinTypeParamete
             return Variance.INVARIANT;
         }
 
-        JetModifierList modifierList = getModifierList();
+        KtModifierList modifierList = getModifierList();
         if (modifierList == null) return Variance.INVARIANT;
 
-        if (modifierList.hasModifier(JetTokens.OUT_KEYWORD)) return Variance.OUT_VARIANCE;
-        if (modifierList.hasModifier(JetTokens.IN_KEYWORD)) return Variance.IN_VARIANCE;
+        if (modifierList.hasModifier(KtTokens.OUT_KEYWORD)) return Variance.OUT_VARIANCE;
+        if (modifierList.hasModifier(KtTokens.IN_KEYWORD)) return Variance.IN_VARIANCE;
         return Variance.INVARIANT;
     }
 
     @Nullable
-    public JetTypeReference setExtendsBound(@Nullable JetTypeReference typeReference) {
-        JetTypeReference currentExtendsBound = getExtendsBound();
+    public KtTypeReference setExtendsBound(@Nullable KtTypeReference typeReference) {
+        KtTypeReference currentExtendsBound = getExtendsBound();
         if (currentExtendsBound != null) {
             if (typeReference == null) {
-                PsiElement colon = findChildByType(JetTokens.COLON);
+                PsiElement colon = findChildByType(KtTokens.COLON);
                 if (colon != null) colon.delete();
                 currentExtendsBound.delete();
                 return null;
             }
-            return (JetTypeReference) currentExtendsBound.replace(typeReference);
+            return (KtTypeReference) currentExtendsBound.replace(typeReference);
         }
 
         if (typeReference != null) {
-            PsiElement colon = addAfter(new JetPsiFactory(getProject()).createColon(), getNameIdentifier());
-            return (JetTypeReference) addAfter(typeReference, colon);
+            PsiElement colon = addAfter(new KtPsiFactory(getProject()).createColon(), getNameIdentifier());
+            return (KtTypeReference) addAfter(typeReference, colon);
         }
 
         return null;
     }
 
     @Nullable
-    public JetTypeReference getExtendsBound() {
-        return getStubOrPsiChild(JetStubElementTypes.TYPE_REFERENCE);
+    public KtTypeReference getExtendsBound() {
+        return getStubOrPsiChild(KtStubElementTypes.TYPE_REFERENCE);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameterList.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameterList.java
similarity index 61%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameterList.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameterList.java
index 5dc272d540f..7c6233fa26c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameterList.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameterList.java
@@ -19,26 +19,26 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.List;
 
-public class JetTypeParameterList extends JetElementImplStub<KotlinPlaceHolderStub<JetTypeParameterList>> {
-    public JetTypeParameterList(@NotNull ASTNode node) {
+public class KtTypeParameterList extends KtElementImplStub<KotlinPlaceHolderStub<KtTypeParameterList>> {
+    public KtTypeParameterList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetTypeParameterList(@NotNull KotlinPlaceHolderStub<JetTypeParameterList> stub) {
-        super(stub, JetStubElementTypes.TYPE_PARAMETER_LIST);
+    public KtTypeParameterList(@NotNull KotlinPlaceHolderStub<KtTypeParameterList> stub) {
+        super(stub, KtStubElementTypes.TYPE_PARAMETER_LIST);
     }
 
     @NotNull
-    public List<JetTypeParameter> getParameters() {
-        return getStubOrPsiChildrenAsList(JetStubElementTypes.TYPE_PARAMETER);
+    public List<KtTypeParameter> getParameters() {
+        return getStubOrPsiChildrenAsList(KtStubElementTypes.TYPE_PARAMETER);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitTypeParameterList(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameterListOwner.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameterListOwner.java
similarity index 74%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameterListOwner.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameterListOwner.java
index a3e66664218..956f0c16763 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameterListOwner.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameterListOwner.java
@@ -21,16 +21,16 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-public interface JetTypeParameterListOwner extends JetNamedDeclaration {
+public interface KtTypeParameterListOwner extends KtNamedDeclaration {
     @Nullable
-    JetTypeParameterList getTypeParameterList();
+    KtTypeParameterList getTypeParameterList();
 
     @Nullable
-    JetTypeConstraintList getTypeConstraintList();
+    KtTypeConstraintList getTypeConstraintList();
 
     @NotNull
-    List<JetTypeConstraint> getTypeConstraints();
+    List<KtTypeConstraint> getTypeConstraints();
 
     @NotNull
-    List<JetTypeParameter> getTypeParameters();
+    List<KtTypeParameter> getTypeParameters();
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameterListOwnerNotStubbed.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameterListOwnerNotStubbed.java
similarity index 62%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameterListOwnerNotStubbed.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameterListOwnerNotStubbed.java
index f82e2508b2a..5253e28e90e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameterListOwnerNotStubbed.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameterListOwnerNotStubbed.java
@@ -19,34 +19,34 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
 import java.util.Collections;
 import java.util.List;
 
 // TODO: Remove when all implementations of JetTypeParameterListOwner get stubs
 @Deprecated
-abstract class JetTypeParameterListOwnerNotStubbed extends JetNamedDeclarationNotStubbed implements JetTypeParameterListOwner {
-    public JetTypeParameterListOwnerNotStubbed(@NotNull ASTNode node) {
+abstract class KtTypeParameterListOwnerNotStubbed extends KtNamedDeclarationNotStubbed implements KtTypeParameterListOwner {
+    public KtTypeParameterListOwnerNotStubbed(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
     @Nullable
-    public JetTypeParameterList getTypeParameterList() {
-        return (JetTypeParameterList) findChildByType(JetNodeTypes.TYPE_PARAMETER_LIST);
+    public KtTypeParameterList getTypeParameterList() {
+        return (KtTypeParameterList) findChildByType(KtNodeTypes.TYPE_PARAMETER_LIST);
     }
 
     @Override
     @Nullable
-    public JetTypeConstraintList getTypeConstraintList() {
-        return (JetTypeConstraintList) findChildByType(JetNodeTypes.TYPE_CONSTRAINT_LIST);
+    public KtTypeConstraintList getTypeConstraintList() {
+        return (KtTypeConstraintList) findChildByType(KtNodeTypes.TYPE_CONSTRAINT_LIST);
     }
 
     @Override
     @NotNull
-    public List<JetTypeConstraint> getTypeConstraints() {
-        JetTypeConstraintList typeConstraintList = getTypeConstraintList();
+    public List<KtTypeConstraint> getTypeConstraints() {
+        KtTypeConstraintList typeConstraintList = getTypeConstraintList();
         if (typeConstraintList == null) {
             return Collections.emptyList();
         }
@@ -55,8 +55,8 @@ abstract class JetTypeParameterListOwnerNotStubbed extends JetNamedDeclarationNo
 
     @Override
     @NotNull
-    public List<JetTypeParameter> getTypeParameters() {
-        JetTypeParameterList list = getTypeParameterList();
+    public List<KtTypeParameter> getTypeParameters() {
+        KtTypeParameterList list = getTypeParameterList();
         if (list == null) return Collections.emptyList();
 
         return list.getParameters();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameterListOwnerStub.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameterListOwnerStub.java
similarity index 59%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameterListOwnerStub.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameterListOwnerStub.java
index 457c746b950..055e653298b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeParameterListOwnerStub.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeParameterListOwnerStub.java
@@ -21,37 +21,37 @@ import com.intellij.psi.stubs.IStubElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.psi.stubs.KotlinStubWithFqName;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-public abstract class JetTypeParameterListOwnerStub<T extends KotlinStubWithFqName<?>>
-        extends JetNamedDeclarationStub<T> implements JetTypeParameterListOwner {
-    public JetTypeParameterListOwnerStub(@NotNull T stub, @NotNull IStubElementType nodeType) {
+public abstract class KtTypeParameterListOwnerStub<T extends KotlinStubWithFqName<?>>
+        extends KtNamedDeclarationStub<T> implements KtTypeParameterListOwner {
+    public KtTypeParameterListOwnerStub(@NotNull T stub, @NotNull IStubElementType nodeType) {
         super(stub, nodeType);
     }
 
-    public JetTypeParameterListOwnerStub(@NotNull ASTNode node) {
+    public KtTypeParameterListOwnerStub(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
     @Nullable
-    public JetTypeParameterList getTypeParameterList() {
-        return getStubOrPsiChild(JetStubElementTypes.TYPE_PARAMETER_LIST);
+    public KtTypeParameterList getTypeParameterList() {
+        return getStubOrPsiChild(KtStubElementTypes.TYPE_PARAMETER_LIST);
     }
 
     @Override
     @Nullable
-    public JetTypeConstraintList getTypeConstraintList() {
-        return getStubOrPsiChild(JetStubElementTypes.TYPE_CONSTRAINT_LIST);
+    public KtTypeConstraintList getTypeConstraintList() {
+        return getStubOrPsiChild(KtStubElementTypes.TYPE_CONSTRAINT_LIST);
     }
 
     @Override
     @NotNull
-    public List<JetTypeConstraint> getTypeConstraints() {
-        JetTypeConstraintList typeConstraintList = getTypeConstraintList();
+    public List<KtTypeConstraint> getTypeConstraints() {
+        KtTypeConstraintList typeConstraintList = getTypeConstraintList();
         if (typeConstraintList == null) {
             return Collections.emptyList();
         }
@@ -60,8 +60,8 @@ public abstract class JetTypeParameterListOwnerStub<T extends KotlinStubWithFqNa
 
     @Override
     @NotNull
-    public List<JetTypeParameter> getTypeParameters() {
-        JetTypeParameterList list = getTypeParameterList();
+    public List<KtTypeParameter> getTypeParameters() {
+        KtTypeParameterList list = getTypeParameterList();
         if (list == null) return Collections.emptyList();
 
         return list.getParameters();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeProjection.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeProjection.java
similarity index 65%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeProjection.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeProjection.java
index 1990037c382..094e512f5d2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeProjection.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeProjection.java
@@ -21,22 +21,22 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.stubs.KotlinTypeProjectionStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
-public class JetTypeProjection extends JetModifierListOwnerStub<KotlinTypeProjectionStub> {
+public class KtTypeProjection extends KtModifierListOwnerStub<KotlinTypeProjectionStub> {
 
-    public JetTypeProjection(@NotNull ASTNode node) {
+    public KtTypeProjection(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetTypeProjection(@NotNull KotlinTypeProjectionStub stub) {
-        super(stub, JetStubElementTypes.TYPE_PROJECTION);
+    public KtTypeProjection(@NotNull KotlinTypeProjectionStub stub) {
+        super(stub, KtStubElementTypes.TYPE_PROJECTION);
     }
 
     @NotNull
-    public JetProjectionKind getProjectionKind() {
+    public KtProjectionKind getProjectionKind() {
         KotlinTypeProjectionStub stub = getStub();
         if (stub != null) {
             return stub.getProjectionKind();
@@ -44,7 +44,7 @@ public class JetTypeProjection extends JetModifierListOwnerStub<KotlinTypeProjec
 
         PsiElement projectionToken = getProjectionToken();
         IElementType token = projectionToken != null ? projectionToken.getNode().getElementType() : null;
-        for (JetProjectionKind projectionKind : JetProjectionKind.values()) {
+        for (KtProjectionKind projectionKind : KtProjectionKind.values()) {
             if (projectionKind.getToken() == token) {
                 return projectionKind;
             }
@@ -53,28 +53,28 @@ public class JetTypeProjection extends JetModifierListOwnerStub<KotlinTypeProjec
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitTypeProjection(this, data);
     }
 
     @Nullable
-    public JetTypeReference getTypeReference() {
-        return getStubOrPsiChild(JetStubElementTypes.TYPE_REFERENCE);
+    public KtTypeReference getTypeReference() {
+        return getStubOrPsiChild(KtStubElementTypes.TYPE_REFERENCE);
     }
 
     @Nullable
     public PsiElement getProjectionToken() {
-        PsiElement star = findChildByType(JetTokens.MUL);
+        PsiElement star = findChildByType(KtTokens.MUL);
         if (star != null) {
             return star;
         }
 
-        JetModifierList modifierList = getModifierList();
+        KtModifierList modifierList = getModifierList();
         if (modifierList != null) {
-            PsiElement element = modifierList.getModifier(JetTokens.IN_KEYWORD);
+            PsiElement element = modifierList.getModifier(KtTokens.IN_KEYWORD);
             if (element != null) return element;
 
-            element = modifierList.getModifier(JetTokens.OUT_KEYWORD);
+            element = modifierList.getModifier(KtTokens.OUT_KEYWORD);
             if (element != null) return element;
         }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeReference.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeReference.kt
similarity index 52%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeReference.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeReference.kt
index 98591e2d6af..c0eb9a109bb 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypeReference.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypeReference.kt
@@ -18,37 +18,37 @@ package org.jetbrains.kotlin.psi
 
 import com.intellij.lang.ASTNode
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.psiUtil.collectAnnotationEntriesFromStubOrPsi
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 
 /**
  * Type reference element.
- * Underlying token is [org.jetbrains.kotlin.JetNodeTypes.TYPE_REFERENCE]
+ * Underlying token is [org.jetbrains.kotlin.KtNodeTypes.TYPE_REFERENCE]
  */
-class JetTypeReference : JetElementImplStub<KotlinPlaceHolderStub<JetTypeReference>>, JetAnnotated, JetAnnotationsContainer {
+class KtTypeReference : KtElementImplStub<KotlinPlaceHolderStub<KtTypeReference>>, KtAnnotated, KtAnnotationsContainer {
 
     constructor(node: ASTNode) : super(node)
 
-    constructor(stub: KotlinPlaceHolderStub<JetTypeReference>) : super(stub, JetStubElementTypes.TYPE_REFERENCE)
+    constructor(stub: KotlinPlaceHolderStub<KtTypeReference>) : super(stub, KtStubElementTypes.TYPE_REFERENCE)
 
-    override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D): R {
+    override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D): R {
         return visitor.visitTypeReference(this, data)
     }
 
-    val typeElement: JetTypeElement?
-        get() = JetStubbedPsiUtil.getStubOrPsiChild(this, JetStubElementTypes.TYPE_ELEMENT_TYPES, JetTypeElement.ARRAY_FACTORY)
+    val typeElement: KtTypeElement?
+        get() = KtStubbedPsiUtil.getStubOrPsiChild(this, KtStubElementTypes.TYPE_ELEMENT_TYPES, KtTypeElement.ARRAY_FACTORY)
 
-    override fun getAnnotations(): List<JetAnnotation> {
-        return getStubOrPsiChildrenAsList(JetStubElementTypes.ANNOTATION)
+    override fun getAnnotations(): List<KtAnnotation> {
+        return getStubOrPsiChildrenAsList(KtStubElementTypes.ANNOTATION)
     }
 
-    override fun getAnnotationEntries(): List<JetAnnotationEntry> {
+    override fun getAnnotationEntries(): List<KtAnnotationEntry> {
         return this.collectAnnotationEntriesFromStubOrPsi()
     }
 
     fun hasParentheses(): Boolean {
-        return findChildByType<PsiElement>(JetTokens.LPAR) != null && findChildByType<PsiElement>(JetTokens.LPAR) != null
+        return findChildByType<PsiElement>(KtTokens.LPAR) != null && findChildByType<PsiElement>(KtTokens.LPAR) != null
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypedef.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypedef.java
similarity index 74%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypedef.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypedef.java
index 642309735bc..5912fc763c2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetTypedef.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtTypedef.java
@@ -19,22 +19,22 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 import org.jetbrains.kotlin.name.FqName;
 
-public class JetTypedef extends JetTypeParameterListOwnerNotStubbed {
-    public JetTypedef(@NotNull ASTNode node) {
+public class KtTypedef extends KtTypeParameterListOwnerNotStubbed {
+    public KtTypedef(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitTypedef(this, data);
     }
 
     @Nullable @IfNotParsed
-    public JetTypeReference getTypeReference() {
-        return (JetTypeReference) findChildByType(JetNodeTypes.TYPE_REFERENCE);
+    public KtTypeReference getTypeReference() {
+        return (KtTypeReference) findChildByType(KtNodeTypes.TYPE_REFERENCE);
     }
 
     @Nullable
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetUnaryExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtUnaryExpression.java
similarity index 71%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetUnaryExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtUnaryExpression.java
index aeacea970ce..2d7a7bfdac9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetUnaryExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtUnaryExpression.java
@@ -20,20 +20,20 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
-public abstract class JetUnaryExpression extends JetExpressionImpl implements JetOperationExpression {
-    public JetUnaryExpression(ASTNode node) {
+public abstract class KtUnaryExpression extends KtExpressionImpl implements KtOperationExpression {
+    public KtUnaryExpression(ASTNode node) {
         super(node);
     }
 
     @Nullable @IfNotParsed
-    public abstract JetExpression getBaseExpression();
+    public abstract KtExpression getBaseExpression();
 
     @Override
     @NotNull
-    public JetSimpleNameExpression getOperationReference() {
-        return (JetSimpleNameExpression) findChildByType(JetNodeTypes.OPERATION_REFERENCE);
+    public KtSimpleNameExpression getOperationReference() {
+        return (KtSimpleNameExpression) findChildByType(KtNodeTypes.OPERATION_REFERENCE);
     }
 
     public IElementType getOperationToken() {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetUserType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtUserType.java
similarity index 55%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetUserType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtUserType.java
index 149828da4fd..1012a57cefc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetUserType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtUserType.java
@@ -21,20 +21,20 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.stubs.KotlinUserTypeStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetUserType extends JetElementImplStub<KotlinUserTypeStub> implements JetTypeElement {
-    public JetUserType(@NotNull ASTNode node) {
+public class KtUserType extends KtElementImplStub<KotlinUserTypeStub> implements KtTypeElement {
+    public KtUserType(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetUserType(@NotNull KotlinUserTypeStub stub) {
-        super(stub, JetStubElementTypes.USER_TYPE);
+    public KtUserType(@NotNull KotlinUserTypeStub stub) {
+        super(stub, KtStubElementTypes.USER_TYPE);
     }
 
     public boolean isAbsoluteInRootPackage() {
@@ -42,48 +42,48 @@ public class JetUserType extends JetElementImplStub<KotlinUserTypeStub> implemen
         if (stub != null) {
             return stub.isAbsoluteInRootPackage();
         }
-        return findChildByType(JetTokens.PACKAGE_KEYWORD) != null;
+        return findChildByType(KtTokens.PACKAGE_KEYWORD) != null;
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitUserType(this, data);
     }
 
-    public JetTypeArgumentList getTypeArgumentList() {
-        return getStubOrPsiChild(JetStubElementTypes.TYPE_ARGUMENT_LIST);
+    public KtTypeArgumentList getTypeArgumentList() {
+        return getStubOrPsiChild(KtStubElementTypes.TYPE_ARGUMENT_LIST);
     }
 
     @NotNull
-    public List<JetTypeProjection> getTypeArguments() {
+    public List<KtTypeProjection> getTypeArguments() {
         // TODO: empty elements in PSI
-        JetTypeArgumentList typeArgumentList = getTypeArgumentList();
-        return typeArgumentList == null ? Collections.<JetTypeProjection>emptyList() : typeArgumentList.getArguments();
+        KtTypeArgumentList typeArgumentList = getTypeArgumentList();
+        return typeArgumentList == null ? Collections.<KtTypeProjection>emptyList() : typeArgumentList.getArguments();
     }
 
     @NotNull
     @Override
-    public List<JetTypeReference> getTypeArgumentsAsTypes() {
-        List<JetTypeReference> result = Lists.newArrayList();
-        for (JetTypeProjection projection : getTypeArguments()) {
+    public List<KtTypeReference> getTypeArgumentsAsTypes() {
+        List<KtTypeReference> result = Lists.newArrayList();
+        for (KtTypeProjection projection : getTypeArguments()) {
             result.add(projection.getTypeReference());
         }
         return result;
     }
 
     @Nullable @IfNotParsed
-    public JetSimpleNameExpression getReferenceExpression() {
-        JetNameReferenceExpression nameRefExpr = getStubOrPsiChild(JetStubElementTypes.REFERENCE_EXPRESSION);
-        return nameRefExpr != null ? nameRefExpr : getStubOrPsiChild(JetStubElementTypes.ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION);
+    public KtSimpleNameExpression getReferenceExpression() {
+        KtNameReferenceExpression nameRefExpr = getStubOrPsiChild(KtStubElementTypes.REFERENCE_EXPRESSION);
+        return nameRefExpr != null ? nameRefExpr : getStubOrPsiChild(KtStubElementTypes.ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION);
     }
 
     @Nullable
-    public JetUserType getQualifier() {
-        return getStubOrPsiChild(JetStubElementTypes.USER_TYPE);
+    public KtUserType getQualifier() {
+        return getStubOrPsiChild(KtStubElementTypes.USER_TYPE);
     }
 
     public boolean hasTypesWithTypeArgsInside() {
-        for (JetUserType type : getStubOrPsiChildrenAsList(JetStubElementTypes.USER_TYPE)) {
+        for (KtUserType type : getStubOrPsiChildrenAsList(KtStubElementTypes.USER_TYPE)) {
             if (!type.getTypeArguments().isEmpty() || type.hasTypesWithTypeArgsInside()) {
                 return true;
             }
@@ -92,9 +92,9 @@ public class JetUserType extends JetElementImplStub<KotlinUserTypeStub> implemen
     }
 
     public void deleteQualifier() {
-        JetUserType qualifier = getQualifier();
+        KtUserType qualifier = getQualifier();
         assert qualifier != null;
-        PsiElement dot = findChildByType(JetTokens.DOT);
+        PsiElement dot = findChildByType(KtTokens.DOT);
         assert dot != null;
         qualifier.delete();
         dot.delete();
@@ -102,7 +102,7 @@ public class JetUserType extends JetElementImplStub<KotlinUserTypeStub> implemen
 
     @Nullable
     public String getReferencedName() {
-        JetSimpleNameExpression referenceExpression = getReferenceExpression();
+        KtSimpleNameExpression referenceExpression = getReferenceExpression();
         return referenceExpression == null ? null : referenceExpression.getReferencedName();
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetValueArgument.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtValueArgument.java
similarity index 68%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetValueArgument.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtValueArgument.java
index ee9de455f97..9703303ffc8 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetValueArgument.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtValueArgument.java
@@ -21,34 +21,34 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.impl.source.tree.LeafPsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-public class JetValueArgument extends JetElementImpl implements ValueArgument {
-    public JetValueArgument(@NotNull ASTNode node) {
+public class KtValueArgument extends KtElementImpl implements ValueArgument {
+    public KtValueArgument(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitArgument(this, data);
     }
 
     @Override
     @Nullable @IfNotParsed
-    public JetExpression getArgumentExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getArgumentExpression() {
+        return findChildByClass(KtExpression.class);
     }
 
     @Override
     @Nullable
-    public JetValueArgumentName getArgumentName() {
-        return (JetValueArgumentName) findChildByType(JetNodeTypes.VALUE_ARGUMENT_NAME);
+    public KtValueArgumentName getArgumentName() {
+        return (KtValueArgumentName) findChildByType(KtNodeTypes.VALUE_ARGUMENT_NAME);
     }
 
     @Nullable
     public PsiElement getEqualsToken() {
-        return findChildByType(JetTokens.EQ);
+        return findChildByType(KtTokens.EQ);
     }
 
     @Override
@@ -58,13 +58,13 @@ public class JetValueArgument extends JetElementImpl implements ValueArgument {
 
     @NotNull
     @Override
-    public JetElement asElement() {
+    public KtElement asElement() {
         return this;
     }
 
     @Override
     public LeafPsiElement getSpreadElement() {
-        ASTNode node = getNode().findChildByType(JetTokens.MUL);
+        ASTNode node = getNode().findChildByType(KtTokens.MUL);
         return node == null ? null : (LeafPsiElement) node.getPsi();
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetValueArgumentList.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtValueArgumentList.java
similarity index 64%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetValueArgumentList.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtValueArgumentList.java
index e656db1dfe6..47f6b66ed9d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetValueArgumentList.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtValueArgumentList.java
@@ -20,52 +20,52 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
 import java.util.List;
 
-public class JetValueArgumentList extends JetElementImpl {
-    public JetValueArgumentList(@NotNull ASTNode node) {
+public class KtValueArgumentList extends KtElementImpl {
+    public KtValueArgumentList(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitValueArgumentList(this, data);
     }
 
     @NotNull
-    public List<JetValueArgument> getArguments() {
-        return findChildrenByType(JetNodeTypes.VALUE_ARGUMENT);
+    public List<KtValueArgument> getArguments() {
+        return findChildrenByType(KtNodeTypes.VALUE_ARGUMENT);
     }
 
     @Nullable
     public PsiElement getRightParenthesis() {
-        return findChildByType(JetTokens.RPAR);
+        return findChildByType(KtTokens.RPAR);
     }
 
     @Nullable
     public PsiElement getLeftParenthesis() {
-        return findChildByType(JetTokens.LPAR);
+        return findChildByType(KtTokens.LPAR);
     }
 
     @NotNull
-    public JetValueArgument addArgument(@NotNull JetValueArgument argument) {
+    public KtValueArgument addArgument(@NotNull KtValueArgument argument) {
         return EditCommaSeparatedListHelper.INSTANCE$.addItem(this, getArguments(), argument);
     }
 
     @NotNull
-    public JetValueArgument addArgumentAfter(@NotNull JetValueArgument argument, @Nullable JetValueArgument anchor) {
+    public KtValueArgument addArgumentAfter(@NotNull KtValueArgument argument, @Nullable KtValueArgument anchor) {
         return EditCommaSeparatedListHelper.INSTANCE$.addItemAfter(this, getArguments(), argument, anchor);
     }
 
     @NotNull
-    public JetValueArgument addArgumentBefore(@NotNull JetValueArgument argument, @Nullable JetValueArgument anchor) {
+    public KtValueArgument addArgumentBefore(@NotNull KtValueArgument argument, @Nullable KtValueArgument anchor) {
         return EditCommaSeparatedListHelper.INSTANCE$.addItemBefore(this, getArguments(), argument, anchor);
     }
 
-    public void removeArgument(@NotNull JetValueArgument argument) {
+    public void removeArgument(@NotNull KtValueArgument argument) {
         assert argument.getParent() == this;
         EditCommaSeparatedListHelper.INSTANCE$.removeItem(argument);
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetValueArgumentName.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtValueArgumentName.java
similarity index 73%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetValueArgumentName.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtValueArgumentName.java
index 466e1bb1f8d..1f27f9aa11b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetValueArgumentName.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtValueArgumentName.java
@@ -18,18 +18,18 @@ package org.jetbrains.kotlin.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 import org.jetbrains.kotlin.name.Name;
 
-public class JetValueArgumentName extends JetElementImpl implements ValueArgumentName {
-    public JetValueArgumentName(@NotNull ASTNode node) {
+public class KtValueArgumentName extends KtElementImpl implements ValueArgumentName {
+    public KtValueArgumentName(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
     @NotNull
-    public JetSimpleNameExpression getReferenceExpression() {
-        return (JetSimpleNameExpression) findChildByType(JetNodeTypes.REFERENCE_EXPRESSION);
+    public KtSimpleNameExpression getReferenceExpression() {
+        return (KtSimpleNameExpression) findChildByType(KtNodeTypes.REFERENCE_EXPRESSION);
     }
 
     @NotNull
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVariableDeclaration.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtVariableDeclaration.java
similarity index 88%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetVariableDeclaration.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtVariableDeclaration.java
index 1822e551e62..572b19bedbe 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVariableDeclaration.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtVariableDeclaration.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.Nullable;
 
-public interface JetVariableDeclaration extends JetCallableDeclaration, JetWithExpressionInitializer {
+public interface KtVariableDeclaration extends KtCallableDeclaration, KtWithExpressionInitializer {
     boolean isVar();
 
     @Nullable
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/KtVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtVisitor.java
new file mode 100644
index 00000000000..8db17d51c47
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtVisitor.java
@@ -0,0 +1,448 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.psi;
+
+import com.intellij.psi.PsiElementVisitor;
+import org.jetbrains.annotations.NotNull;
+
+public class KtVisitor<R, D> extends PsiElementVisitor {
+    public R visitJetElement(@NotNull KtElement element, D data) {
+        visitElement(element);
+        return null;
+    }
+
+    public R visitDeclaration(@NotNull KtDeclaration dcl, D data) {
+        return visitExpression(dcl, data);
+    }
+
+    public R visitClass(@NotNull KtClass klass, D data) {
+        return visitClassOrObject(klass, data);
+    }
+
+    public R visitObjectDeclaration(@NotNull KtObjectDeclaration declaration, D data) {
+        return visitClassOrObject(declaration, data);
+    }
+
+    public R visitClassOrObject(@NotNull KtClassOrObject classOrObject, D data) {
+        return visitNamedDeclaration(classOrObject, data);
+    }
+
+    public R visitSecondaryConstructor(@NotNull KtSecondaryConstructor constructor, D data) {
+        return visitDeclaration(constructor, data);
+    }
+
+    public R visitPrimaryConstructor(@NotNull KtPrimaryConstructor constructor, D data) {
+        return visitDeclaration(constructor, data);
+    }
+
+    public R visitNamedFunction(@NotNull KtNamedFunction function, D data) {
+        return visitNamedDeclaration(function, data);
+    }
+
+    public R visitProperty(@NotNull KtProperty property, D data) {
+        return visitNamedDeclaration(property, data);
+    }
+
+    public R visitMultiDeclaration(@NotNull KtMultiDeclaration multiDeclaration, D data) {
+        return visitDeclaration(multiDeclaration, data);
+    }
+
+    public R visitMultiDeclarationEntry(@NotNull KtMultiDeclarationEntry multiDeclarationEntry, D data) {
+        return visitNamedDeclaration(multiDeclarationEntry, data);
+    }
+
+    public R visitTypedef(@NotNull KtTypedef typedef, D data) {
+        return visitNamedDeclaration(typedef, data);
+    }
+
+    public R visitJetFile(@NotNull KtFile file, D data) {
+        visitFile(file);
+        return null;
+    }
+
+    public R visitScript(@NotNull KtScript script, D data) {
+        return visitDeclaration(script, data);
+    }
+
+    public R visitImportDirective(@NotNull KtImportDirective importDirective, D data) {
+        return visitJetElement(importDirective, data);
+    }
+
+    public R visitImportList(@NotNull KtImportList importList, D data) {
+        return visitJetElement(importList, data);
+    }
+
+    public R visitFileAnnotationList(@NotNull KtFileAnnotationList fileAnnotationList, D data) {
+        return visitJetElement(fileAnnotationList, data);
+    }
+
+    public R visitClassBody(@NotNull KtClassBody classBody, D data) {
+        return visitJetElement(classBody, data);
+    }
+
+    public R visitModifierList(@NotNull KtModifierList list, D data) {
+        return visitJetElement(list, data);
+    }
+
+    public R visitAnnotation(@NotNull KtAnnotation annotation, D data) {
+        return visitJetElement(annotation, data);
+    }
+
+    public R visitAnnotationEntry(@NotNull KtAnnotationEntry annotationEntry, D data) {
+        return visitJetElement(annotationEntry, data);
+    }
+
+    public R visitAnnotationUseSiteTarget(@NotNull KtAnnotationUseSiteTarget annotationTarget, D data) {
+        return visitJetElement(annotationTarget, data);
+    }
+
+    public R visitConstructorCalleeExpression(@NotNull KtConstructorCalleeExpression constructorCalleeExpression, D data) {
+        return visitJetElement(constructorCalleeExpression, data);
+    }
+
+    public R visitTypeParameterList(@NotNull KtTypeParameterList list, D data) {
+        return visitJetElement(list, data);
+    }
+
+    public R visitTypeParameter(@NotNull KtTypeParameter parameter, D data) {
+        return visitNamedDeclaration(parameter, data);
+    }
+
+    public R visitEnumEntry(@NotNull KtEnumEntry enumEntry, D data) {
+        return visitClass(enumEntry, data);
+    }
+
+    public R visitParameterList(@NotNull KtParameterList list, D data) {
+        return visitJetElement(list, data);
+    }
+
+    public R visitParameter(@NotNull KtParameter parameter, D data) {
+        return visitNamedDeclaration(parameter, data);
+    }
+
+    public R visitDelegationSpecifierList(@NotNull KtDelegationSpecifierList list, D data) {
+        return visitJetElement(list, data);
+    }
+
+    public R visitDelegationSpecifier(@NotNull KtDelegationSpecifier specifier, D data) {
+        return visitJetElement(specifier, data);
+    }
+
+    public R visitDelegationByExpressionSpecifier(@NotNull KtDelegatorByExpressionSpecifier specifier, D data) {
+        return visitDelegationSpecifier(specifier, data);
+    }
+
+    public R visitDelegationToSuperCallSpecifier(@NotNull KtDelegatorToSuperCall call, D data) {
+        return visitDelegationSpecifier(call, data);
+    }
+
+    public R visitDelegationToSuperClassSpecifier(@NotNull KtDelegatorToSuperClass specifier, D data) {
+        return visitDelegationSpecifier(specifier, data);
+    }
+
+    public R visitConstructorDelegationCall(@NotNull KtConstructorDelegationCall call, D data) {
+        return visitJetElement(call, data);
+    }
+
+    public R visitPropertyDelegate(@NotNull KtPropertyDelegate delegate, D data) {
+        return visitJetElement(delegate, data);
+    }
+
+    public R visitTypeReference(@NotNull KtTypeReference typeReference, D data) {
+        return visitJetElement(typeReference, data);
+    }
+
+    public R visitValueArgumentList(@NotNull KtValueArgumentList list, D data) {
+        return visitJetElement(list, data);
+    }
+
+    public R visitArgument(@NotNull KtValueArgument argument, D data) {
+        return visitJetElement(argument, data);
+    }
+
+    public R visitExpression(@NotNull KtExpression expression, D data) {
+        return visitJetElement(expression, data);
+    }
+
+    public R visitLoopExpression(@NotNull KtLoopExpression loopExpression, D data) {
+        return visitExpression(loopExpression, data);
+    }
+
+    public R visitConstantExpression(@NotNull KtConstantExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression, D data) {
+        return visitReferenceExpression(expression, data);
+    }
+
+    public R visitReferenceExpression(@NotNull KtReferenceExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitLabeledExpression(@NotNull KtLabeledExpression expression, D data) {
+        return visitExpressionWithLabel(expression, data);
+    }
+
+    public R visitPrefixExpression(@NotNull KtPrefixExpression expression, D data) {
+        return visitUnaryExpression(expression, data);
+    }
+
+    public R visitPostfixExpression(@NotNull KtPostfixExpression expression, D data) {
+        return visitUnaryExpression(expression, data);
+    }
+
+    public R visitUnaryExpression(@NotNull KtUnaryExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitBinaryExpression(@NotNull KtBinaryExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitReturnExpression(@NotNull KtReturnExpression expression, D data) {
+        return visitExpressionWithLabel(expression, data);
+    }
+
+    public R visitExpressionWithLabel(@NotNull KtExpressionWithLabel expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitThrowExpression(@NotNull KtThrowExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitBreakExpression(@NotNull KtBreakExpression expression, D data) {
+        return visitExpressionWithLabel(expression, data);
+    }
+
+    public R visitContinueExpression(@NotNull KtContinueExpression expression, D data) {
+        return visitExpressionWithLabel(expression, data);
+    }
+
+    public R visitIfExpression(@NotNull KtIfExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitWhenExpression(@NotNull KtWhenExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitTryExpression(@NotNull KtTryExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitForExpression(@NotNull KtForExpression expression, D data) {
+        return visitLoopExpression(expression, data);
+    }
+
+    public R visitWhileExpression(@NotNull KtWhileExpression expression, D data) {
+        return visitLoopExpression(expression, data);
+    }
+
+    public R visitDoWhileExpression(@NotNull KtDoWhileExpression expression, D data) {
+        return visitLoopExpression(expression, data);
+    }
+
+    public R visitFunctionLiteralExpression(@NotNull KtFunctionLiteralExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitAnnotatedExpression(@NotNull KtAnnotatedExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitCallExpression(@NotNull KtCallExpression expression, D data) {
+        return visitReferenceExpression(expression, data);
+    }
+
+    public R visitArrayAccessExpression(@NotNull KtArrayAccessExpression expression, D data) {
+        return visitReferenceExpression(expression, data);
+    }
+
+    public R visitQualifiedExpression(@NotNull KtQualifiedExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitDoubleColonExpression(@NotNull KtDoubleColonExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitCallableReferenceExpression(@NotNull KtCallableReferenceExpression expression, D data) {
+        return visitDoubleColonExpression(expression, data);
+    }
+
+    public R visitClassLiteralExpression(@NotNull KtClassLiteralExpression expression, D data) {
+        return visitDoubleColonExpression(expression, data);
+    }
+
+    public R visitDotQualifiedExpression(@NotNull KtDotQualifiedExpression expression, D data) {
+        return visitQualifiedExpression(expression, data);
+    }
+
+    public R visitSafeQualifiedExpression(@NotNull KtSafeQualifiedExpression expression, D data) {
+        return visitQualifiedExpression(expression, data);
+    }
+
+    public R visitObjectLiteralExpression(@NotNull KtObjectLiteralExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitRootPackageExpression(@NotNull KtRootPackageExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitBlockExpression(@NotNull KtBlockExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitCatchSection(@NotNull KtCatchClause catchClause, D data) {
+        return visitJetElement(catchClause, data);
+    }
+
+    public R visitFinallySection(@NotNull KtFinallySection finallySection, D data) {
+        return visitJetElement(finallySection, data);
+    }
+
+    public R visitTypeArgumentList(@NotNull KtTypeArgumentList typeArgumentList, D data) {
+        return visitJetElement(typeArgumentList, data);
+    }
+
+    public R visitThisExpression(@NotNull KtThisExpression expression, D data) {
+        return visitExpressionWithLabel(expression, data);
+    }
+
+    public R visitSuperExpression(@NotNull KtSuperExpression expression, D data) {
+        return visitExpressionWithLabel(expression, data);
+    }
+
+    public R visitParenthesizedExpression(@NotNull KtParenthesizedExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitInitializerList(@NotNull KtInitializerList list, D data) {
+        return visitJetElement(list, data);
+    }
+
+    public R visitAnonymousInitializer(@NotNull KtClassInitializer initializer, D data) {
+        return visitDeclaration(initializer, data);
+    }
+
+    public R visitPropertyAccessor(@NotNull KtPropertyAccessor accessor, D data) {
+        return visitDeclaration(accessor, data);
+    }
+
+    public R visitTypeConstraintList(@NotNull KtTypeConstraintList list, D data) {
+        return visitJetElement(list, data);
+    }
+
+    public R visitTypeConstraint(@NotNull KtTypeConstraint constraint, D data) {
+        return visitJetElement(constraint, data);
+    }
+
+    private R visitTypeElement(@NotNull KtTypeElement type, D data) {
+        return visitJetElement(type, data);
+    }
+
+    public R visitUserType(@NotNull KtUserType type, D data) {
+        return visitTypeElement(type, data);
+    }
+
+    public R visitDynamicType(@NotNull KtDynamicType type, D data) {
+        return visitTypeElement(type, data);
+    }
+
+    public R visitFunctionType(@NotNull KtFunctionType type, D data) {
+        return visitTypeElement(type, data);
+    }
+
+    public R visitSelfType(@NotNull KtSelfType type, D data) {
+        return visitTypeElement(type, data);
+    }
+
+    public R visitBinaryWithTypeRHSExpression(@NotNull KtBinaryExpressionWithTypeRHS expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitStringTemplateExpression(@NotNull KtStringTemplateExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitNamedDeclaration(@NotNull KtNamedDeclaration declaration, D data) {
+        return visitDeclaration(declaration, data);
+    }
+
+    public R visitNullableType(@NotNull KtNullableType nullableType, D data) {
+        return visitTypeElement(nullableType, data);
+    }
+
+    public R visitTypeProjection(@NotNull KtTypeProjection typeProjection, D data) {
+        return visitJetElement(typeProjection, data);
+    }
+
+    public R visitWhenEntry(@NotNull KtWhenEntry jetWhenEntry, D data) {
+        return visitJetElement(jetWhenEntry, data);
+    }
+
+    public R visitIsExpression(@NotNull KtIsExpression expression, D data) {
+        return visitExpression(expression, data);
+    }
+
+    public R visitWhenConditionIsPattern(@NotNull KtWhenConditionIsPattern condition, D data) {
+        return visitJetElement(condition, data);
+    }
+
+    public R visitWhenConditionInRange(@NotNull KtWhenConditionInRange condition, D data) {
+        return visitJetElement(condition, data);
+    }
+
+    public R visitWhenConditionWithExpression(@NotNull KtWhenConditionWithExpression condition, D data) {
+        return visitJetElement(condition, data);
+    }
+
+    public R visitObjectDeclarationName(@NotNull KtObjectDeclarationName declarationName, D data) {
+        return visitExpression(declarationName, data);
+    }
+
+    public R visitStringTemplateEntry(@NotNull KtStringTemplateEntry entry, D data) {
+        return visitJetElement(entry, data);
+    }
+
+    public R visitStringTemplateEntryWithExpression(@NotNull KtStringTemplateEntryWithExpression entry, D data) {
+        return visitStringTemplateEntry(entry, data);
+    }
+
+    public R visitBlockStringTemplateEntry(@NotNull KtBlockStringTemplateEntry entry, D data) {
+        return visitStringTemplateEntryWithExpression(entry, data);
+    }
+
+    public R visitSimpleNameStringTemplateEntry(@NotNull KtSimpleNameStringTemplateEntry entry, D data) {
+        return visitStringTemplateEntryWithExpression(entry, data);
+    }
+
+    public R visitLiteralStringTemplateEntry(@NotNull KtLiteralStringTemplateEntry entry, D data) {
+        return visitStringTemplateEntry(entry, data);
+    }
+
+    public R visitEscapeStringTemplateEntry(@NotNull KtEscapeStringTemplateEntry entry, D data) {
+        return visitStringTemplateEntry(entry, data);
+    }
+
+    public R visitPackageDirective(@NotNull KtPackageDirective directive, D data) {
+        return visitJetElement(directive, data);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/KtVisitorVoid.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtVisitorVoid.java
new file mode 100644
index 00000000000..55c4f946588
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtVisitorVoid.java
@@ -0,0 +1,1056 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.psi;
+
+import org.jetbrains.annotations.NotNull;
+
+public class KtVisitorVoid extends KtVisitor<Void, Void> {
+    // methods with void return
+
+    public void visitJetElement(@NotNull KtElement element) {
+        super.visitJetElement(element, null);
+    }
+
+    public void visitDeclaration(@NotNull KtDeclaration dcl) {
+        super.visitDeclaration(dcl, null);
+    }
+
+    public void visitClass(@NotNull KtClass klass) {
+        super.visitClass(klass, null);
+    }
+
+    public void visitClassOrObject(@NotNull KtClassOrObject classOrObject) {
+        super.visitClassOrObject(classOrObject, null);
+    }
+
+    public void visitSecondaryConstructor(@NotNull KtSecondaryConstructor constructor) {
+        super.visitSecondaryConstructor(constructor, null);
+    }
+
+    public void visitPrimaryConstructor(@NotNull KtPrimaryConstructor constructor) {
+        super.visitPrimaryConstructor(constructor, null);
+    }
+
+    public void visitNamedFunction(@NotNull KtNamedFunction function) {
+        super.visitNamedFunction(function, null);
+    }
+
+    public void visitProperty(@NotNull KtProperty property) {
+        super.visitProperty(property, null);
+    }
+
+    public void visitMultiDeclaration(@NotNull KtMultiDeclaration multiDeclaration) {
+        super.visitMultiDeclaration(multiDeclaration, null);
+    }
+
+    public void visitMultiDeclarationEntry(@NotNull KtMultiDeclarationEntry multiDeclarationEntry) {
+        super.visitMultiDeclarationEntry(multiDeclarationEntry, null);
+    }
+
+    public void visitTypedef(@NotNull KtTypedef typedef) {
+        super.visitTypedef(typedef, null);
+    }
+
+    public void visitJetFile(@NotNull KtFile file) {
+        super.visitJetFile(file, null);
+    }
+
+    public void visitScript(@NotNull KtScript script) {
+        super.visitScript(script, null);
+    }
+
+    public void visitImportDirective(@NotNull KtImportDirective importDirective) {
+        super.visitImportDirective(importDirective, null);
+    }
+
+    public void visitImportList(@NotNull KtImportList importList) {
+        super.visitImportList(importList, null);
+    }
+
+    public void visitClassBody(@NotNull KtClassBody classBody) {
+        super.visitClassBody(classBody, null);
+    }
+
+    public void visitModifierList(@NotNull KtModifierList list) {
+        super.visitModifierList(list, null);
+    }
+
+    public void visitAnnotation(@NotNull KtAnnotation annotation) {
+        super.visitAnnotation(annotation, null);
+    }
+
+    public void visitAnnotationEntry(@NotNull KtAnnotationEntry annotationEntry) {
+        super.visitAnnotationEntry(annotationEntry, null);
+    }
+
+    public void visitConstructorCalleeExpression(@NotNull KtConstructorCalleeExpression constructorCalleeExpression) {
+        super.visitConstructorCalleeExpression(constructorCalleeExpression, null);
+    }
+
+    public void visitTypeParameterList(@NotNull KtTypeParameterList list) {
+        super.visitTypeParameterList(list, null);
+    }
+
+    public void visitTypeParameter(@NotNull KtTypeParameter parameter) {
+        super.visitTypeParameter(parameter, null);
+    }
+
+    public void visitEnumEntry(@NotNull KtEnumEntry enumEntry) {
+        super.visitEnumEntry(enumEntry, null);
+    }
+
+    public void visitParameterList(@NotNull KtParameterList list) {
+        super.visitParameterList(list, null);
+    }
+
+    public void visitParameter(@NotNull KtParameter parameter) {
+        super.visitParameter(parameter, null);
+    }
+
+    public void visitDelegationSpecifierList(@NotNull KtDelegationSpecifierList list) {
+        super.visitDelegationSpecifierList(list, null);
+    }
+
+    public void visitDelegationSpecifier(@NotNull KtDelegationSpecifier specifier) {
+        super.visitDelegationSpecifier(specifier, null);
+    }
+
+    public void visitDelegationByExpressionSpecifier(@NotNull KtDelegatorByExpressionSpecifier specifier) {
+        super.visitDelegationByExpressionSpecifier(specifier, null);
+    }
+
+    public void visitDelegationToSuperCallSpecifier(@NotNull KtDelegatorToSuperCall call) {
+        super.visitDelegationToSuperCallSpecifier(call, null);
+    }
+
+    public void visitDelegationToSuperClassSpecifier(@NotNull KtDelegatorToSuperClass specifier) {
+        super.visitDelegationToSuperClassSpecifier(specifier, null);
+    }
+
+    public void visitConstructorDelegationCall(@NotNull KtConstructorDelegationCall call) {
+        super.visitConstructorDelegationCall(call, null);
+    }
+
+    public void visitPropertyDelegate(@NotNull KtPropertyDelegate delegate) {
+        super.visitPropertyDelegate(delegate, null);
+    }
+
+    public void visitTypeReference(@NotNull KtTypeReference typeReference) {
+        super.visitTypeReference(typeReference, null);
+    }
+
+    public void visitValueArgumentList(@NotNull KtValueArgumentList list) {
+        super.visitValueArgumentList(list, null);
+    }
+
+    public void visitArgument(@NotNull KtValueArgument argument) {
+        super.visitArgument(argument, null);
+    }
+
+    public void visitExpression(@NotNull KtExpression expression) {
+        super.visitExpression(expression, null);
+    }
+
+    public void visitLoopExpression(@NotNull KtLoopExpression loopExpression) {
+        super.visitLoopExpression(loopExpression, null);
+    }
+
+    public void visitConstantExpression(@NotNull KtConstantExpression expression) {
+        super.visitConstantExpression(expression, null);
+    }
+
+    public void visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression) {
+        super.visitSimpleNameExpression(expression, null);
+    }
+
+    public void visitReferenceExpression(@NotNull KtReferenceExpression expression) {
+        super.visitReferenceExpression(expression, null);
+    }
+
+    public void visitLabeledExpression(@NotNull KtLabeledExpression expression) {
+        super.visitLabeledExpression(expression, null);
+    }
+
+    public void visitPrefixExpression(@NotNull KtPrefixExpression expression) {
+        super.visitPrefixExpression(expression, null);
+    }
+
+    public void visitPostfixExpression(@NotNull KtPostfixExpression expression) {
+        super.visitPostfixExpression(expression, null);
+    }
+
+    public void visitUnaryExpression(@NotNull KtUnaryExpression expression) {
+        super.visitUnaryExpression(expression, null);
+    }
+
+    public void visitBinaryExpression(@NotNull KtBinaryExpression expression) {
+        super.visitBinaryExpression(expression, null);
+    }
+
+    public void visitReturnExpression(@NotNull KtReturnExpression expression) {
+        super.visitReturnExpression(expression, null);
+    }
+
+    public void visitExpressionWithLabel(@NotNull KtExpressionWithLabel expression) {
+        super.visitExpressionWithLabel(expression, null);
+    }
+
+    public void visitThrowExpression(@NotNull KtThrowExpression expression) {
+        super.visitThrowExpression(expression, null);
+    }
+
+    public void visitBreakExpression(@NotNull KtBreakExpression expression) {
+        super.visitBreakExpression(expression, null);
+    }
+
+    public void visitContinueExpression(@NotNull KtContinueExpression expression) {
+        super.visitContinueExpression(expression, null);
+    }
+
+    public void visitIfExpression(@NotNull KtIfExpression expression) {
+        super.visitIfExpression(expression, null);
+    }
+
+    public void visitWhenExpression(@NotNull KtWhenExpression expression) {
+        super.visitWhenExpression(expression, null);
+    }
+
+    public void visitTryExpression(@NotNull KtTryExpression expression) {
+        super.visitTryExpression(expression, null);
+    }
+
+    public void visitForExpression(@NotNull KtForExpression expression) {
+        super.visitForExpression(expression, null);
+    }
+
+    public void visitWhileExpression(@NotNull KtWhileExpression expression) {
+        super.visitWhileExpression(expression, null);
+    }
+
+    public void visitDoWhileExpression(@NotNull KtDoWhileExpression expression) {
+        super.visitDoWhileExpression(expression, null);
+    }
+
+    public void visitFunctionLiteralExpression(@NotNull KtFunctionLiteralExpression expression) {
+        super.visitFunctionLiteralExpression(expression, null);
+    }
+
+    public void visitAnnotatedExpression(@NotNull KtAnnotatedExpression expression) {
+        super.visitAnnotatedExpression(expression, null);
+    }
+
+    public void visitCallExpression(@NotNull KtCallExpression expression) {
+        super.visitCallExpression(expression, null);
+    }
+
+    public void visitArrayAccessExpression(@NotNull KtArrayAccessExpression expression) {
+        super.visitArrayAccessExpression(expression, null);
+    }
+
+    public void visitQualifiedExpression(@NotNull KtQualifiedExpression expression) {
+        super.visitQualifiedExpression(expression, null);
+    }
+
+    public void visitDoubleColonExpression(@NotNull KtDoubleColonExpression expression) {
+        super.visitDoubleColonExpression(expression, null);
+    }
+
+    public void visitCallableReferenceExpression(@NotNull KtCallableReferenceExpression expression) {
+        super.visitCallableReferenceExpression(expression, null);
+    }
+
+    public void visitClassLiteralExpression(@NotNull KtClassLiteralExpression expression) {
+        super.visitClassLiteralExpression(expression, null);
+    }
+
+    public void visitDotQualifiedExpression(@NotNull KtDotQualifiedExpression expression) {
+        super.visitDotQualifiedExpression(expression, null);
+    }
+
+    public void visitSafeQualifiedExpression(@NotNull KtSafeQualifiedExpression expression) {
+        super.visitSafeQualifiedExpression(expression, null);
+    }
+
+    public void visitObjectLiteralExpression(@NotNull KtObjectLiteralExpression expression) {
+        super.visitObjectLiteralExpression(expression, null);
+    }
+
+    public void visitRootPackageExpression(@NotNull KtRootPackageExpression expression) {
+        super.visitRootPackageExpression(expression, null);
+    }
+
+    public void visitBlockExpression(@NotNull KtBlockExpression expression) {
+        super.visitBlockExpression(expression, null);
+    }
+
+    public void visitCatchSection(@NotNull KtCatchClause catchClause) {
+        super.visitCatchSection(catchClause, null);
+    }
+
+    public void visitFinallySection(@NotNull KtFinallySection finallySection) {
+        super.visitFinallySection(finallySection, null);
+    }
+
+    public void visitTypeArgumentList(@NotNull KtTypeArgumentList typeArgumentList) {
+        super.visitTypeArgumentList(typeArgumentList, null);
+    }
+
+    public void visitThisExpression(@NotNull KtThisExpression expression) {
+        super.visitThisExpression(expression, null);
+    }
+
+    public void visitSuperExpression(@NotNull KtSuperExpression expression) {
+        super.visitSuperExpression(expression, null);
+    }
+
+    public void visitParenthesizedExpression(@NotNull KtParenthesizedExpression expression) {
+        super.visitParenthesizedExpression(expression, null);
+    }
+
+    public void visitInitializerList(@NotNull KtInitializerList list) {
+        super.visitInitializerList(list, null);
+    }
+
+    public void visitAnonymousInitializer(@NotNull KtClassInitializer initializer) {
+        super.visitAnonymousInitializer(initializer, null);
+    }
+
+    public void visitPropertyAccessor(@NotNull KtPropertyAccessor accessor) {
+        super.visitPropertyAccessor(accessor, null);
+    }
+
+    public void visitTypeConstraintList(@NotNull KtTypeConstraintList list) {
+        super.visitTypeConstraintList(list, null);
+    }
+
+    public void visitTypeConstraint(@NotNull KtTypeConstraint constraint) {
+        super.visitTypeConstraint(constraint, null);
+    }
+
+    public void visitUserType(@NotNull KtUserType type) {
+        super.visitUserType(type, null);
+    }
+
+    public void visitDynamicType(@NotNull KtDynamicType type) {
+        super.visitDynamicType(type, null);
+    }
+
+    public void visitFunctionType(@NotNull KtFunctionType type) {
+        super.visitFunctionType(type, null);
+    }
+
+    public void visitSelfType(@NotNull KtSelfType type) {
+        super.visitSelfType(type, null);
+    }
+
+    public void visitBinaryWithTypeRHSExpression(@NotNull KtBinaryExpressionWithTypeRHS expression) {
+        super.visitBinaryWithTypeRHSExpression(expression, null);
+    }
+
+    public void visitStringTemplateExpression(@NotNull KtStringTemplateExpression expression) {
+        super.visitStringTemplateExpression(expression, null);
+    }
+
+    public void visitNamedDeclaration(@NotNull KtNamedDeclaration declaration) {
+        super.visitNamedDeclaration(declaration, null);
+    }
+
+    public void visitNullableType(@NotNull KtNullableType nullableType) {
+        super.visitNullableType(nullableType, null);
+    }
+
+    public void visitTypeProjection(@NotNull KtTypeProjection typeProjection) {
+        super.visitTypeProjection(typeProjection, null);
+    }
+
+    public void visitWhenEntry(@NotNull KtWhenEntry jetWhenEntry) {
+        super.visitWhenEntry(jetWhenEntry, null);
+    }
+
+    public void visitIsExpression(@NotNull KtIsExpression expression) {
+        super.visitIsExpression(expression, null);
+    }
+
+    public void visitWhenConditionIsPattern(@NotNull KtWhenConditionIsPattern condition) {
+        super.visitWhenConditionIsPattern(condition, null);
+    }
+
+    public void visitWhenConditionInRange(@NotNull KtWhenConditionInRange condition) {
+        super.visitWhenConditionInRange(condition, null);
+    }
+
+    public void visitWhenConditionWithExpression(@NotNull KtWhenConditionWithExpression condition) {
+        super.visitWhenConditionWithExpression(condition, null);
+    }
+
+    public void visitObjectDeclaration(@NotNull KtObjectDeclaration declaration) {
+        super.visitObjectDeclaration(declaration, null);
+    }
+
+    public void visitObjectDeclarationName(@NotNull KtObjectDeclarationName declarationName) {
+        super.visitObjectDeclarationName(declarationName, null);
+    }
+
+    public void visitStringTemplateEntry(@NotNull KtStringTemplateEntry entry) {
+        super.visitStringTemplateEntry(entry, null);
+    }
+
+    public void visitStringTemplateEntryWithExpression(@NotNull KtStringTemplateEntryWithExpression entry) {
+        super.visitStringTemplateEntryWithExpression(entry, null);
+    }
+
+    public void visitBlockStringTemplateEntry(@NotNull KtBlockStringTemplateEntry entry) {
+        super.visitBlockStringTemplateEntry(entry, null);
+    }
+
+    public void visitSimpleNameStringTemplateEntry(@NotNull KtSimpleNameStringTemplateEntry entry) {
+        super.visitSimpleNameStringTemplateEntry(entry, null);
+    }
+
+    public void visitLiteralStringTemplateEntry(@NotNull KtLiteralStringTemplateEntry entry) {
+        super.visitLiteralStringTemplateEntry(entry, null);
+    }
+
+    public void visitEscapeStringTemplateEntry(@NotNull KtEscapeStringTemplateEntry entry) {
+        super.visitEscapeStringTemplateEntry(entry, null);
+    }
+
+    public void visitPackageDirective(@NotNull KtPackageDirective directive) {
+        super.visitPackageDirective(directive, null);
+    }
+
+    // hidden methods
+    @Override
+    public final Void visitJetElement(@NotNull KtElement element, Void data) {
+        visitJetElement(element);
+        return null;
+    }
+
+    @Override
+    public final Void visitDeclaration(@NotNull KtDeclaration dcl, Void data) {
+        visitDeclaration(dcl);
+        return null;
+    }
+
+    @Override
+    public final Void visitClass(@NotNull KtClass klass, Void data) {
+        visitClass(klass);
+        return null;
+    }
+
+    @Override
+    public final Void visitClassOrObject(@NotNull KtClassOrObject classOrObject, Void data) {
+        visitClassOrObject(classOrObject);
+        return null;
+    }
+
+    @Override
+    public final Void visitSecondaryConstructor(@NotNull KtSecondaryConstructor constructor, Void data) {
+        visitSecondaryConstructor(constructor);
+        return null;
+    }
+
+    @Override
+    public final Void visitPrimaryConstructor(@NotNull KtPrimaryConstructor constructor, Void data) {
+        visitPrimaryConstructor(constructor);
+        return null;
+    }
+
+    @Override
+    public final Void visitNamedFunction(@NotNull KtNamedFunction function, Void data) {
+        visitNamedFunction(function);
+        return null;
+    }
+
+    @Override
+    public final Void visitProperty(@NotNull KtProperty property, Void data) {
+        visitProperty(property);
+        return null;
+    }
+
+    @Override
+    public final Void visitMultiDeclaration(@NotNull KtMultiDeclaration multiDeclaration, Void data) {
+        visitMultiDeclaration(multiDeclaration);
+        return null;
+    }
+
+    @Override
+    public final Void visitMultiDeclarationEntry(@NotNull KtMultiDeclarationEntry multiDeclarationEntry, Void data) {
+        visitMultiDeclarationEntry(multiDeclarationEntry);
+        return null;
+    }
+
+    @Override
+    public final Void visitTypedef(@NotNull KtTypedef typedef, Void data) {
+        visitTypedef(typedef);
+        return null;
+    }
+
+    @Override
+    public final Void visitJetFile(@NotNull KtFile file, Void data) {
+        visitJetFile(file);
+        return null;
+    }
+
+    @Override
+    public final Void visitScript(@NotNull KtScript script, Void data) {
+        visitScript(script);
+        return null;
+    }
+
+    @Override
+    public final Void visitImportDirective(@NotNull KtImportDirective importDirective, Void data) {
+        visitImportDirective(importDirective);
+        return null;
+    }
+
+    @Override
+    public final Void visitImportList(@NotNull KtImportList importList, Void data) {
+        visitImportList(importList);
+        return null;
+    }
+
+    @Override
+    public final Void visitClassBody(@NotNull KtClassBody classBody, Void data) {
+        visitClassBody(classBody);
+        return null;
+    }
+
+    @Override
+    public final Void visitModifierList(@NotNull KtModifierList list, Void data) {
+        visitModifierList(list);
+        return null;
+    }
+
+    @Override
+    public final Void visitAnnotation(@NotNull KtAnnotation annotation, Void data) {
+        visitAnnotation(annotation);
+        return null;
+    }
+
+    @Override
+    public final Void visitAnnotationEntry(@NotNull KtAnnotationEntry annotationEntry, Void data) {
+        visitAnnotationEntry(annotationEntry);
+        return null;
+    }
+
+    @Override
+    public final Void visitConstructorCalleeExpression(@NotNull KtConstructorCalleeExpression constructorCalleeExpression, Void data) {
+        visitConstructorCalleeExpression(constructorCalleeExpression);
+        return null;
+    }
+
+    @Override
+    public final Void visitTypeParameterList(@NotNull KtTypeParameterList list, Void data) {
+        visitTypeParameterList(list);
+        return null;
+    }
+
+    @Override
+    public final Void visitTypeParameter(@NotNull KtTypeParameter parameter, Void data) {
+        visitTypeParameter(parameter);
+        return null;
+    }
+
+    @Override
+    public final Void visitEnumEntry(@NotNull KtEnumEntry enumEntry, Void data) {
+        visitEnumEntry(enumEntry);
+        return null;
+    }
+
+    @Override
+    public final Void visitParameterList(@NotNull KtParameterList list, Void data) {
+        visitParameterList(list);
+        return null;
+    }
+
+    @Override
+    public final Void visitParameter(@NotNull KtParameter parameter, Void data) {
+        visitParameter(parameter);
+        return null;
+    }
+
+    @Override
+    public final Void visitDelegationSpecifierList(@NotNull KtDelegationSpecifierList list, Void data) {
+        visitDelegationSpecifierList(list);
+        return null;
+    }
+
+    @Override
+    public final Void visitDelegationSpecifier(@NotNull KtDelegationSpecifier specifier, Void data) {
+        visitDelegationSpecifier(specifier);
+        return null;
+    }
+
+    @Override
+    public final Void visitDelegationByExpressionSpecifier(
+            @NotNull KtDelegatorByExpressionSpecifier specifier, Void data
+    ) {
+        visitDelegationByExpressionSpecifier(specifier);
+        return null;
+    }
+
+    @Override
+    public final Void visitDelegationToSuperCallSpecifier(@NotNull KtDelegatorToSuperCall call, Void data) {
+        visitDelegationToSuperCallSpecifier(call);
+        return null;
+    }
+
+    @Override
+    public final Void visitDelegationToSuperClassSpecifier(@NotNull KtDelegatorToSuperClass specifier, Void data) {
+        visitDelegationToSuperClassSpecifier(specifier);
+        return null;
+    }
+
+    @Override
+    public final Void visitConstructorDelegationCall(@NotNull KtConstructorDelegationCall call, Void data) {
+        visitConstructorDelegationCall(call);
+        return null;
+    }
+
+    @Override
+    public final Void visitPropertyDelegate(@NotNull KtPropertyDelegate delegate, Void data) {
+        visitPropertyDelegate(delegate);
+        return null;
+    }
+
+    @Override
+    public final Void visitTypeReference(@NotNull KtTypeReference typeReference, Void data) {
+        visitTypeReference(typeReference);
+        return null;
+    }
+
+    @Override
+    public final Void visitValueArgumentList(@NotNull KtValueArgumentList list, Void data) {
+        visitValueArgumentList(list);
+        return null;
+    }
+
+    @Override
+    public final Void visitArgument(@NotNull KtValueArgument argument, Void data) {
+        visitArgument(argument);
+        return null;
+    }
+
+    @Override
+    public final Void visitExpression(@NotNull KtExpression expression, Void data) {
+        visitExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitLoopExpression(@NotNull KtLoopExpression loopExpression, Void data) {
+        visitLoopExpression(loopExpression);
+        return null;
+    }
+
+    @Override
+    public final Void visitConstantExpression(@NotNull KtConstantExpression expression, Void data) {
+        visitConstantExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression, Void data) {
+        visitSimpleNameExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitReferenceExpression(@NotNull KtReferenceExpression expression, Void data) {
+        visitReferenceExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitLabeledExpression(@NotNull KtLabeledExpression expression, Void data) {
+        visitLabeledExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitPrefixExpression(@NotNull KtPrefixExpression expression, Void data) {
+        visitPrefixExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitPostfixExpression(@NotNull KtPostfixExpression expression, Void data) {
+        visitPostfixExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitUnaryExpression(@NotNull KtUnaryExpression expression, Void data) {
+        visitUnaryExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitBinaryExpression(@NotNull KtBinaryExpression expression, Void data) {
+        visitBinaryExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitReturnExpression(@NotNull KtReturnExpression expression, Void data) {
+        visitReturnExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitExpressionWithLabel(@NotNull KtExpressionWithLabel expression, Void data) {
+        visitExpressionWithLabel(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitThrowExpression(@NotNull KtThrowExpression expression, Void data) {
+        visitThrowExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitBreakExpression(@NotNull KtBreakExpression expression, Void data) {
+        visitBreakExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitContinueExpression(@NotNull KtContinueExpression expression, Void data) {
+        visitContinueExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitIfExpression(@NotNull KtIfExpression expression, Void data) {
+        visitIfExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitWhenExpression(@NotNull KtWhenExpression expression, Void data) {
+        visitWhenExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitTryExpression(@NotNull KtTryExpression expression, Void data) {
+        visitTryExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitForExpression(@NotNull KtForExpression expression, Void data) {
+        visitForExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitWhileExpression(@NotNull KtWhileExpression expression, Void data) {
+        visitWhileExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitDoWhileExpression(@NotNull KtDoWhileExpression expression, Void data) {
+        visitDoWhileExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitFunctionLiteralExpression(@NotNull KtFunctionLiteralExpression expression, Void data) {
+        visitFunctionLiteralExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitAnnotatedExpression(@NotNull KtAnnotatedExpression expression, Void data) {
+        visitAnnotatedExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitCallExpression(@NotNull KtCallExpression expression, Void data) {
+        visitCallExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitArrayAccessExpression(@NotNull KtArrayAccessExpression expression, Void data) {
+        visitArrayAccessExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitQualifiedExpression(@NotNull KtQualifiedExpression expression, Void data) {
+        visitQualifiedExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitDoubleColonExpression(@NotNull KtDoubleColonExpression expression, Void data) {
+        visitDoubleColonExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitCallableReferenceExpression(@NotNull KtCallableReferenceExpression expression, Void data) {
+        visitCallableReferenceExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitClassLiteralExpression(@NotNull KtClassLiteralExpression expression, Void data) {
+        visitClassLiteralExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitDotQualifiedExpression(@NotNull KtDotQualifiedExpression expression, Void data) {
+        visitDotQualifiedExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitSafeQualifiedExpression(@NotNull KtSafeQualifiedExpression expression, Void data) {
+        visitSafeQualifiedExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitObjectLiteralExpression(@NotNull KtObjectLiteralExpression expression, Void data) {
+        visitObjectLiteralExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitRootPackageExpression(@NotNull KtRootPackageExpression expression, Void data) {
+        visitRootPackageExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitBlockExpression(@NotNull KtBlockExpression expression, Void data) {
+        visitBlockExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitCatchSection(@NotNull KtCatchClause catchClause, Void data) {
+        visitCatchSection(catchClause);
+        return null;
+    }
+
+    @Override
+    public final Void visitFinallySection(@NotNull KtFinallySection finallySection, Void data) {
+        visitFinallySection(finallySection);
+        return null;
+    }
+
+    @Override
+    public final Void visitTypeArgumentList(@NotNull KtTypeArgumentList typeArgumentList, Void data) {
+        visitTypeArgumentList(typeArgumentList);
+        return null;
+    }
+
+    @Override
+    public final Void visitThisExpression(@NotNull KtThisExpression expression, Void data) {
+        visitThisExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitSuperExpression(@NotNull KtSuperExpression expression, Void data) {
+        visitSuperExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitParenthesizedExpression(@NotNull KtParenthesizedExpression expression, Void data) {
+        visitParenthesizedExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitInitializerList(@NotNull KtInitializerList list, Void data) {
+        visitInitializerList(list);
+        return null;
+    }
+
+    @Override
+    public final Void visitAnonymousInitializer(@NotNull KtClassInitializer initializer, Void data) {
+        visitAnonymousInitializer(initializer);
+        return null;
+    }
+
+    @Override
+    public final Void visitPropertyAccessor(@NotNull KtPropertyAccessor accessor, Void data) {
+        visitPropertyAccessor(accessor);
+        return null;
+    }
+
+    @Override
+    public final Void visitTypeConstraintList(@NotNull KtTypeConstraintList list, Void data) {
+        visitTypeConstraintList(list);
+        return null;
+    }
+
+    @Override
+    public final Void visitTypeConstraint(@NotNull KtTypeConstraint constraint, Void data) {
+        visitTypeConstraint(constraint);
+        return null;
+    }
+
+    @Override
+    public final Void visitUserType(@NotNull KtUserType type, Void data) {
+        visitUserType(type);
+        return null;
+    }
+
+    @Override
+    public Void visitDynamicType(@NotNull KtDynamicType type, Void data) {
+        visitDynamicType(type);
+        return null;
+    }
+
+    @Override
+    public final Void visitFunctionType(@NotNull KtFunctionType type, Void data) {
+        visitFunctionType(type);
+        return null;
+    }
+
+    @Override
+    public final Void visitSelfType(@NotNull KtSelfType type, Void data) {
+        visitSelfType(type);
+        return null;
+    }
+
+    @Override
+    public final Void visitBinaryWithTypeRHSExpression(@NotNull KtBinaryExpressionWithTypeRHS expression, Void data) {
+        visitBinaryWithTypeRHSExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitStringTemplateExpression(@NotNull KtStringTemplateExpression expression, Void data) {
+        visitStringTemplateExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitNamedDeclaration(@NotNull KtNamedDeclaration declaration, Void data) {
+        visitNamedDeclaration(declaration);
+        return null;
+    }
+
+    @Override
+    public final Void visitNullableType(@NotNull KtNullableType nullableType, Void data) {
+        visitNullableType(nullableType);
+        return null;
+    }
+
+    @Override
+    public final Void visitTypeProjection(@NotNull KtTypeProjection typeProjection, Void data) {
+        visitTypeProjection(typeProjection);
+        return null;
+    }
+
+    @Override
+    public final Void visitWhenEntry(@NotNull KtWhenEntry jetWhenEntry, Void data) {
+        visitWhenEntry(jetWhenEntry);
+        return null;
+    }
+
+    @Override
+    public final Void visitIsExpression(@NotNull KtIsExpression expression, Void data) {
+        visitIsExpression(expression);
+        return null;
+    }
+
+    @Override
+    public final Void visitWhenConditionIsPattern(@NotNull KtWhenConditionIsPattern condition, Void data) {
+        visitWhenConditionIsPattern(condition);
+        return null;
+    }
+
+    @Override
+    public final Void visitWhenConditionInRange(@NotNull KtWhenConditionInRange condition, Void data) {
+        visitWhenConditionInRange(condition);
+        return null;
+    }
+
+    @Override
+    public final Void visitWhenConditionWithExpression(@NotNull KtWhenConditionWithExpression condition, Void data) {
+        visitWhenConditionWithExpression(condition);
+        return null;
+    }
+
+    @Override
+    public final Void visitObjectDeclaration(@NotNull KtObjectDeclaration declaration, Void data) {
+        visitObjectDeclaration(declaration);
+        return null;
+    }
+
+    @Override
+    public final Void visitObjectDeclarationName(@NotNull KtObjectDeclarationName declarationName, Void data) {
+        visitObjectDeclarationName(declarationName);
+        return null;
+    }
+
+    @Override
+    public final Void visitStringTemplateEntry(@NotNull KtStringTemplateEntry entry, Void data) {
+        visitStringTemplateEntry(entry);
+        return null;
+    }
+
+    @Override
+    public final Void visitStringTemplateEntryWithExpression(@NotNull KtStringTemplateEntryWithExpression entry, Void data) {
+        visitStringTemplateEntryWithExpression(entry);
+        return null;
+    }
+
+    @Override
+    public final Void visitBlockStringTemplateEntry(@NotNull KtBlockStringTemplateEntry entry, Void data) {
+        visitBlockStringTemplateEntry(entry);
+        return null;
+    }
+
+    @Override
+    public final Void visitSimpleNameStringTemplateEntry(@NotNull KtSimpleNameStringTemplateEntry entry, Void data) {
+        visitSimpleNameStringTemplateEntry(entry);
+        return null;
+    }
+
+    @Override
+    public final Void visitLiteralStringTemplateEntry(@NotNull KtLiteralStringTemplateEntry entry, Void data) {
+        visitLiteralStringTemplateEntry(entry);
+        return null;
+    }
+
+    @Override
+    public final Void visitEscapeStringTemplateEntry(@NotNull KtEscapeStringTemplateEntry entry, Void data) {
+        visitEscapeStringTemplateEntry(entry);
+        return null;
+    }
+
+    @Override
+    public Void visitPackageDirective(@NotNull KtPackageDirective directive, Void data) {
+        visitPackageDirective(directive);
+        return null;
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/KtVisitorVoidWithParameter.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtVisitorVoidWithParameter.java
new file mode 100644
index 00000000000..b84b5810899
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtVisitorVoidWithParameter.java
@@ -0,0 +1,1025 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.psi;
+
+import org.jetbrains.annotations.NotNull;
+
+public class KtVisitorVoidWithParameter<P> extends KtVisitor<Void, P> {
+
+    // methods with parameter
+
+    public void visitJetElementVoid(@NotNull KtElement element, P data) {
+        super.visitJetElement(element, data);
+    }
+
+    public void visitDeclarationVoid(@NotNull KtDeclaration dcl, P data) {
+        super.visitDeclaration(dcl, data);
+    }
+
+    public void visitClassVoid(@NotNull KtClass klass, P data) {
+        super.visitClass(klass, data);
+    }
+
+    public void visitSecondaryConstructorVoid(@NotNull KtSecondaryConstructor constructor, P data) {
+        super.visitSecondaryConstructor(constructor, data);
+    }
+
+    public void visitPrimaryConstructorVoid(@NotNull KtPrimaryConstructor constructor, P data) {
+        super.visitPrimaryConstructor(constructor, data);
+    }
+
+    public void visitNamedFunctionVoid(@NotNull KtNamedFunction function, P data) {
+        super.visitNamedFunction(function, data);
+    }
+
+    public void visitPropertyVoid(@NotNull KtProperty property, P data) {
+        super.visitProperty(property, data);
+    }
+
+    public void visitMultiDeclarationVoid(@NotNull KtMultiDeclaration multiDeclaration, P data) {
+        super.visitMultiDeclaration(multiDeclaration, data);
+    }
+
+    public void visitMultiDeclarationEntryVoid(@NotNull KtMultiDeclarationEntry multiDeclarationEntry, P data) {
+        super.visitMultiDeclarationEntry(multiDeclarationEntry, data);
+    }
+
+    public void visitTypedefVoid(@NotNull KtTypedef typedef, P data) {
+        super.visitTypedef(typedef, data);
+    }
+
+    public void visitJetFileVoid(@NotNull KtFile file, P data) {
+        super.visitJetFile(file, data);
+    }
+
+    public void visitScriptVoid(@NotNull KtScript script, P data) {
+        super.visitScript(script, data);
+    }
+
+    public void visitImportDirectiveVoid(@NotNull KtImportDirective importDirective, P data) {
+        super.visitImportDirective(importDirective, data);
+    }
+
+    public void visitImportListVoid(@NotNull KtImportList importList, P data) {
+        super.visitImportList(importList, data);
+    }
+
+    public void visitClassBodyVoid(@NotNull KtClassBody classBody, P data) {
+        super.visitClassBody(classBody, data);
+    }
+
+    public void visitModifierListVoid(@NotNull KtModifierList list, P data) {
+        super.visitModifierList(list, data);
+    }
+
+    public void visitAnnotationVoid(@NotNull KtAnnotation annotation, P data) {
+        super.visitAnnotation(annotation, data);
+    }
+
+    public void visitAnnotationEntryVoid(@NotNull KtAnnotationEntry annotationEntry, P data) {
+        super.visitAnnotationEntry(annotationEntry, data);
+    }
+
+    public void visitConstructorCalleeExpressionVoid(@NotNull KtConstructorCalleeExpression constructorCalleeExpression, P data) {
+        super.visitConstructorCalleeExpression(constructorCalleeExpression, data);
+    }
+
+    public void visitTypeParameterListVoid(@NotNull KtTypeParameterList list, P data) {
+        super.visitTypeParameterList(list, data);
+    }
+
+    public void visitTypeParameterVoid(@NotNull KtTypeParameter parameter, P data) {
+        super.visitTypeParameter(parameter, data);
+    }
+
+    public void visitEnumEntryVoid(@NotNull KtEnumEntry enumEntry, P data) {
+        super.visitEnumEntry(enumEntry, data);
+    }
+
+    public void visitParameterListVoid(@NotNull KtParameterList list, P data) {
+        super.visitParameterList(list, data);
+    }
+
+    public void visitParameterVoid(@NotNull KtParameter parameter, P data) {
+        super.visitParameter(parameter, data);
+    }
+
+    public void visitDelegationSpecifierListVoid(@NotNull KtDelegationSpecifierList list, P data) {
+        super.visitDelegationSpecifierList(list, data);
+    }
+
+    public void visitDelegationSpecifierVoid(@NotNull KtDelegationSpecifier specifier, P data) {
+        super.visitDelegationSpecifier(specifier, data);
+    }
+
+    public void visitDelegationByExpressionSpecifierVoid(@NotNull KtDelegatorByExpressionSpecifier specifier, P data) {
+        super.visitDelegationByExpressionSpecifier(specifier, data);
+    }
+
+    public void visitDelegationToSuperCallSpecifierVoid(@NotNull KtDelegatorToSuperCall call, P data) {
+        super.visitDelegationToSuperCallSpecifier(call, data);
+    }
+
+    public void visitDelegationToSuperClassSpecifierVoid(@NotNull KtDelegatorToSuperClass specifier, P data) {
+        super.visitDelegationToSuperClassSpecifier(specifier, data);
+    }
+
+    public void visitDelegationCallVoid(@NotNull KtConstructorDelegationCall call, P data) {
+        super.visitConstructorDelegationCall(call, data);
+    }
+
+    public void visitPropertyDelegateVoid(@NotNull KtPropertyDelegate delegate, P data) {
+        super.visitPropertyDelegate(delegate, data);
+    }
+
+    public void visitTypeReferenceVoid(@NotNull KtTypeReference typeReference, P data) {
+        super.visitTypeReference(typeReference, data);
+    }
+
+    public void visitValueArgumentListVoid(@NotNull KtValueArgumentList list, P data) {
+        super.visitValueArgumentList(list, data);
+    }
+
+    public void visitArgumentVoid(@NotNull KtValueArgument argument, P data) {
+        super.visitArgument(argument, data);
+    }
+
+    public void visitExpressionVoid(@NotNull KtExpression expression, P data) {
+        super.visitExpression(expression, data);
+    }
+
+    public void visitLoopExpressionVoid(@NotNull KtLoopExpression loopExpression, P data) {
+        super.visitLoopExpression(loopExpression, data);
+    }
+
+    public void visitConstantExpressionVoid(@NotNull KtConstantExpression expression, P data) {
+        super.visitConstantExpression(expression, data);
+    }
+
+    public void visitSimpleNameExpressionVoid(@NotNull KtSimpleNameExpression expression, P data) {
+        super.visitSimpleNameExpression(expression, data);
+    }
+
+    public void visitReferenceExpressionVoid(@NotNull KtReferenceExpression expression, P data) {
+        super.visitReferenceExpression(expression, data);
+    }
+
+    public void visitLabeledExpressionVoid(@NotNull KtLabeledExpression expression, P data) {
+        super.visitLabeledExpression(expression, data);
+    }
+
+    public void visitPrefixExpressionVoid(@NotNull KtPrefixExpression expression, P data) {
+        super.visitPrefixExpression(expression, data);
+    }
+
+    public void visitPostfixExpressionVoid(@NotNull KtPostfixExpression expression, P data) {
+        super.visitPostfixExpression(expression, data);
+    }
+
+    public void visitUnaryExpressionVoid(@NotNull KtUnaryExpression expression, P data) {
+        super.visitUnaryExpression(expression, data);
+    }
+
+    public void visitBinaryExpressionVoid(@NotNull KtBinaryExpression expression, P data) {
+        super.visitBinaryExpression(expression, data);
+    }
+
+    public void visitReturnExpressionVoid(@NotNull KtReturnExpression expression, P data) {
+        super.visitReturnExpression(expression, data);
+    }
+
+    public void visitExpressionWithLabelVoid(@NotNull KtExpressionWithLabel expression, P data) {
+        super.visitExpressionWithLabel(expression, data);
+    }
+
+    public void visitThrowExpressionVoid(@NotNull KtThrowExpression expression, P data) {
+        super.visitThrowExpression(expression, data);
+    }
+
+    public void visitBreakExpressionVoid(@NotNull KtBreakExpression expression, P data) {
+        super.visitBreakExpression(expression, data);
+    }
+
+    public void visitContinueExpressionVoid(@NotNull KtContinueExpression expression, P data) {
+        super.visitContinueExpression(expression, data);
+    }
+
+    public void visitIfExpressionVoid(@NotNull KtIfExpression expression, P data) {
+        super.visitIfExpression(expression, data);
+    }
+
+    public void visitWhenExpressionVoid(@NotNull KtWhenExpression expression, P data) {
+        super.visitWhenExpression(expression, data);
+    }
+
+    public void visitTryExpressionVoid(@NotNull KtTryExpression expression, P data) {
+        super.visitTryExpression(expression, data);
+    }
+
+    public void visitForExpressionVoid(@NotNull KtForExpression expression, P data) {
+        super.visitForExpression(expression, data);
+    }
+
+    public void visitWhileExpressionVoid(@NotNull KtWhileExpression expression, P data) {
+        super.visitWhileExpression(expression, data);
+    }
+
+    public void visitDoWhileExpressionVoid(@NotNull KtDoWhileExpression expression, P data) {
+        super.visitDoWhileExpression(expression, data);
+    }
+
+    public void visitFunctionLiteralExpressionVoid(@NotNull KtFunctionLiteralExpression expression, P data) {
+        super.visitFunctionLiteralExpression(expression, data);
+    }
+
+    public void visitAnnotatedExpressionVoid(@NotNull KtAnnotatedExpression expression, P data) {
+        super.visitAnnotatedExpression(expression, data);
+    }
+
+    public void visitCallExpressionVoid(@NotNull KtCallExpression expression, P data) {
+        super.visitCallExpression(expression, data);
+    }
+
+    public void visitArrayAccessExpressionVoid(@NotNull KtArrayAccessExpression expression, P data) {
+        super.visitArrayAccessExpression(expression, data);
+    }
+
+    public void visitQualifiedExpressionVoid(@NotNull KtQualifiedExpression expression, P data) {
+        super.visitQualifiedExpression(expression, data);
+    }
+
+    public void visitDoubleColonExpressionVoid(@NotNull KtDoubleColonExpression expression, P data) {
+        super.visitDoubleColonExpression(expression, data);
+    }
+
+    public void visitCallableReferenceExpressionVoid(@NotNull KtCallableReferenceExpression expression, P data) {
+        super.visitCallableReferenceExpression(expression, data);
+    }
+
+    public void visitClassLiteralExpressionVoid(@NotNull KtClassLiteralExpression expression, P data) {
+        super.visitClassLiteralExpression(expression, data);
+    }
+
+    public void visitDotQualifiedExpressionVoid(@NotNull KtDotQualifiedExpression expression, P data) {
+        super.visitDotQualifiedExpression(expression, data);
+    }
+
+    public void visitSafeQualifiedExpressionVoid(@NotNull KtSafeQualifiedExpression expression, P data) {
+        super.visitSafeQualifiedExpression(expression, data);
+    }
+
+    public void visitObjectLiteralExpressionVoid(@NotNull KtObjectLiteralExpression expression, P data) {
+        super.visitObjectLiteralExpression(expression, data);
+    }
+
+    public void visitRootPackageExpressionVoid(@NotNull KtRootPackageExpression expression, P data) {
+        super.visitRootPackageExpression(expression, data);
+    }
+
+    public void visitBlockExpressionVoid(@NotNull KtBlockExpression expression, P data) {
+        super.visitBlockExpression(expression, data);
+    }
+
+    public void visitCatchSectionVoid(@NotNull KtCatchClause catchClause, P data) {
+        super.visitCatchSection(catchClause, data);
+    }
+
+    public void visitFinallySectionVoid(@NotNull KtFinallySection finallySection, P data) {
+        super.visitFinallySection(finallySection, data);
+    }
+
+    public void visitTypeArgumentListVoid(@NotNull KtTypeArgumentList typeArgumentList, P data) {
+        super.visitTypeArgumentList(typeArgumentList, data);
+    }
+
+    public void visitThisExpressionVoid(@NotNull KtThisExpression expression, P data) {
+        super.visitThisExpression(expression, data);
+    }
+
+    public void visitSuperExpressionVoid(@NotNull KtSuperExpression expression, P data) {
+        super.visitSuperExpression(expression, data);
+    }
+
+    public void visitParenthesizedExpressionVoid(@NotNull KtParenthesizedExpression expression, P data) {
+        super.visitParenthesizedExpression(expression, data);
+    }
+
+    public void visitInitializerListVoid(@NotNull KtInitializerList list, P data) {
+        super.visitInitializerList(list, data);
+    }
+
+    public void visitAnonymousInitializerVoid(@NotNull KtClassInitializer initializer, P data) {
+        super.visitAnonymousInitializer(initializer, data);
+    }
+
+    public void visitPropertyAccessorVoid(@NotNull KtPropertyAccessor accessor, P data) {
+        super.visitPropertyAccessor(accessor, data);
+    }
+
+    public void visitTypeConstraintListVoid(@NotNull KtTypeConstraintList list, P data) {
+        super.visitTypeConstraintList(list, data);
+    }
+
+    public void visitTypeConstraintVoid(@NotNull KtTypeConstraint constraint, P data) {
+        super.visitTypeConstraint(constraint, data);
+    }
+
+    public void visitUserTypeVoid(@NotNull KtUserType type, P data) {
+        super.visitUserType(type, data);
+    }
+
+    public void visitDynamicTypeVoid(@NotNull KtDynamicType type, P data) {
+        super.visitDynamicType(type, data);
+    }
+
+    public void visitFunctionTypeVoid(@NotNull KtFunctionType type, P data) {
+        super.visitFunctionType(type, data);
+    }
+
+    public void visitSelfTypeVoid(@NotNull KtSelfType type, P data) {
+        super.visitSelfType(type, data);
+    }
+
+    public void visitBinaryWithTypeRHSExpressionVoid(@NotNull KtBinaryExpressionWithTypeRHS expression, P data) {
+        super.visitBinaryWithTypeRHSExpression(expression, data);
+    }
+
+    public void visitStringTemplateExpressionVoid(@NotNull KtStringTemplateExpression expression, P data) {
+        super.visitStringTemplateExpression(expression, data);
+    }
+
+    public void visitNamedDeclarationVoid(@NotNull KtNamedDeclaration declaration, P data) {
+        super.visitNamedDeclaration(declaration, data);
+    }
+
+    public void visitNullableTypeVoid(@NotNull KtNullableType nullableType, P data) {
+        super.visitNullableType(nullableType, data);
+    }
+
+    public void visitTypeProjectionVoid(@NotNull KtTypeProjection typeProjection, P data) {
+        super.visitTypeProjection(typeProjection, data);
+    }
+
+    public void visitWhenEntryVoid(@NotNull KtWhenEntry jetWhenEntry, P data) {
+        super.visitWhenEntry(jetWhenEntry, data);
+    }
+
+    public void visitIsExpressionVoid(@NotNull KtIsExpression expression, P data) {
+        super.visitIsExpression(expression, data);
+    }
+
+    public void visitWhenConditionIsPatternVoid(@NotNull KtWhenConditionIsPattern condition, P data) {
+        super.visitWhenConditionIsPattern(condition, data);
+    }
+
+    public void visitWhenConditionInRangeVoid(@NotNull KtWhenConditionInRange condition, P data) {
+        super.visitWhenConditionInRange(condition, data);
+    }
+
+    public void visitWhenConditionWithExpressionVoid(@NotNull KtWhenConditionWithExpression condition, P data) {
+        super.visitWhenConditionWithExpression(condition, data);
+    }
+
+    public void visitObjectDeclarationVoid(@NotNull KtObjectDeclaration declaration, P data) {
+        super.visitObjectDeclaration(declaration, data);
+    }
+
+    public void visitObjectDeclarationNameVoid(@NotNull KtObjectDeclarationName declarationName, P data) {
+        super.visitObjectDeclarationName(declarationName, data);
+    }
+
+    public void visitStringTemplateEntryVoid(@NotNull KtStringTemplateEntry entry, P data) {
+        super.visitStringTemplateEntry(entry, data);
+    }
+
+    public void visitStringTemplateEntryWithExpressionVoid(@NotNull KtStringTemplateEntryWithExpression entry, P data) {
+        super.visitStringTemplateEntryWithExpression(entry, data);
+    }
+
+    public void visitBlockStringTemplateEntryVoid(@NotNull KtBlockStringTemplateEntry entry, P data) {
+        super.visitBlockStringTemplateEntry(entry, data);
+    }
+
+    public void visitSimpleNameStringTemplateEntryVoid(@NotNull KtSimpleNameStringTemplateEntry entry, P data) {
+        super.visitSimpleNameStringTemplateEntry(entry, data);
+    }
+
+    public void visitLiteralStringTemplateEntryVoid(@NotNull KtLiteralStringTemplateEntry entry, P data) {
+        super.visitLiteralStringTemplateEntry(entry, data);
+    }
+
+    public void visitEscapeStringTemplateEntryVoid(@NotNull KtEscapeStringTemplateEntry entry, P data) {
+        super.visitEscapeStringTemplateEntry(entry, data);
+    }
+
+    // hidden methods
+    @Override
+    public final Void visitJetElement(@NotNull KtElement element, P data) {
+        visitJetElementVoid(element, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitDeclaration(@NotNull KtDeclaration dcl, P data) {
+        visitDeclarationVoid(dcl, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitClass(@NotNull KtClass klass, P data) {
+        visitClassVoid(klass, data);
+    	return null;
+    }
+
+    @Override
+    public Void visitPrimaryConstructor(@NotNull KtPrimaryConstructor constructor, P data) {
+        visitPrimaryConstructorVoid(constructor, data);
+        return null;
+    }
+
+    @Override
+    public final Void visitNamedFunction(@NotNull KtNamedFunction function, P data) {
+        visitNamedFunctionVoid(function, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitProperty(@NotNull KtProperty property, P data) {
+        visitPropertyVoid(property, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitMultiDeclaration(@NotNull KtMultiDeclaration multiDeclaration, P data) {
+        visitMultiDeclarationVoid(multiDeclaration, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitMultiDeclarationEntry(@NotNull KtMultiDeclarationEntry multiDeclarationEntry, P data) {
+        visitMultiDeclarationEntryVoid(multiDeclarationEntry, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitTypedef(@NotNull KtTypedef typedef, P data) {
+        visitTypedefVoid(typedef, data);
+        return null;
+    }
+
+    @Override
+    public final Void visitJetFile(@NotNull KtFile file, P data) {
+        visitJetFileVoid(file, data);
+        return null;
+    }
+
+    @Override
+    public final Void visitScript(@NotNull KtScript script, P data) {
+        visitScriptVoid(script, data);
+        return null;
+    }
+
+    @Override
+    public final Void visitImportDirective(@NotNull KtImportDirective importDirective, P data) {
+        visitImportDirectiveVoid(importDirective, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitImportList(@NotNull KtImportList importList, P data) {
+        visitImportListVoid(importList, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitClassBody(@NotNull KtClassBody classBody, P data) {
+        visitClassBodyVoid(classBody, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitModifierList(@NotNull KtModifierList list, P data) {
+        visitModifierListVoid(list, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitAnnotation(@NotNull KtAnnotation annotation, P data) {
+        visitAnnotationVoid(annotation, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitAnnotationEntry(@NotNull KtAnnotationEntry annotationEntry, P data) {
+        visitAnnotationEntryVoid(annotationEntry, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitTypeParameterList(@NotNull KtTypeParameterList list, P data) {
+        visitTypeParameterListVoid(list, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitTypeParameter(@NotNull KtTypeParameter parameter, P data) {
+        visitTypeParameterVoid(parameter, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitEnumEntry(@NotNull KtEnumEntry enumEntry, P data) {
+        visitEnumEntryVoid(enumEntry, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitParameterList(@NotNull KtParameterList list, P data) {
+        visitParameterListVoid(list, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitParameter(@NotNull KtParameter parameter, P data) {
+        visitParameterVoid(parameter, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitDelegationSpecifierList(@NotNull KtDelegationSpecifierList list, P data) {
+        visitDelegationSpecifierListVoid(list, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitDelegationSpecifier(@NotNull KtDelegationSpecifier specifier, P data) {
+        visitDelegationSpecifierVoid(specifier, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitDelegationByExpressionSpecifier(
+            @NotNull KtDelegatorByExpressionSpecifier specifier, P data
+    ) {
+        visitDelegationByExpressionSpecifierVoid(specifier, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitDelegationToSuperCallSpecifier(@NotNull KtDelegatorToSuperCall call, P data) {
+        visitDelegationToSuperCallSpecifierVoid(call, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitDelegationToSuperClassSpecifier(@NotNull KtDelegatorToSuperClass specifier, P data) {
+        visitDelegationToSuperClassSpecifierVoid(specifier, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitConstructorDelegationCall(@NotNull KtConstructorDelegationCall call, P data) {
+        visitDelegationCallVoid(call, data);
+        return null;
+    }
+
+    @Override
+    public final Void visitPropertyDelegate(@NotNull KtPropertyDelegate delegate, P data) {
+        visitPropertyDelegateVoid(delegate, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitTypeReference(@NotNull KtTypeReference typeReference, P data) {
+        visitTypeReferenceVoid(typeReference, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitValueArgumentList(@NotNull KtValueArgumentList list, P data) {
+        visitValueArgumentListVoid(list, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitArgument(@NotNull KtValueArgument argument, P data) {
+        visitArgumentVoid(argument, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitExpression(@NotNull KtExpression expression, P data) {
+        visitExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitLoopExpression(@NotNull KtLoopExpression loopExpression, P data) {
+        visitLoopExpressionVoid(loopExpression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitConstantExpression(@NotNull KtConstantExpression expression, P data) {
+        visitConstantExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression, P data) {
+        visitSimpleNameExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitReferenceExpression(@NotNull KtReferenceExpression expression, P data) {
+        visitReferenceExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitLabeledExpression(@NotNull KtLabeledExpression expression, P data) {
+        visitLabeledExpressionVoid(expression, data);
+        return null;
+    }
+
+    @Override
+    public final Void visitPrefixExpression(@NotNull KtPrefixExpression expression, P data) {
+        visitPrefixExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitPostfixExpression(@NotNull KtPostfixExpression expression, P data) {
+        visitPostfixExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitUnaryExpression(@NotNull KtUnaryExpression expression, P data) {
+        visitUnaryExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitBinaryExpression(@NotNull KtBinaryExpression expression, P data) {
+        visitBinaryExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitReturnExpression(@NotNull KtReturnExpression expression, P data) {
+        visitReturnExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitExpressionWithLabel(@NotNull KtExpressionWithLabel expression, P data) {
+        visitExpressionWithLabelVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitThrowExpression(@NotNull KtThrowExpression expression, P data) {
+        visitThrowExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitBreakExpression(@NotNull KtBreakExpression expression, P data) {
+        visitBreakExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitContinueExpression(@NotNull KtContinueExpression expression, P data) {
+        visitContinueExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitIfExpression(@NotNull KtIfExpression expression, P data) {
+        visitIfExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitWhenExpression(@NotNull KtWhenExpression expression, P data) {
+        visitWhenExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitTryExpression(@NotNull KtTryExpression expression, P data) {
+        visitTryExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitForExpression(@NotNull KtForExpression expression, P data) {
+        visitForExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitWhileExpression(@NotNull KtWhileExpression expression, P data) {
+        visitWhileExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitDoWhileExpression(@NotNull KtDoWhileExpression expression, P data) {
+        visitDoWhileExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitFunctionLiteralExpression(@NotNull KtFunctionLiteralExpression expression, P data) {
+        visitFunctionLiteralExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitAnnotatedExpression(@NotNull KtAnnotatedExpression expression, P data) {
+        visitAnnotatedExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitCallExpression(@NotNull KtCallExpression expression, P data) {
+        visitCallExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitArrayAccessExpression(@NotNull KtArrayAccessExpression expression, P data) {
+        visitArrayAccessExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitQualifiedExpression(@NotNull KtQualifiedExpression expression, P data) {
+        visitQualifiedExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitDoubleColonExpression(@NotNull KtDoubleColonExpression expression, P data) {
+        visitDoubleColonExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitCallableReferenceExpression(@NotNull KtCallableReferenceExpression expression, P data) {
+        visitCallableReferenceExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitClassLiteralExpression(@NotNull KtClassLiteralExpression expression, P data) {
+        visitClassLiteralExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitDotQualifiedExpression(@NotNull KtDotQualifiedExpression expression, P data) {
+        visitDotQualifiedExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitSafeQualifiedExpression(@NotNull KtSafeQualifiedExpression expression, P data) {
+        visitSafeQualifiedExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitObjectLiteralExpression(@NotNull KtObjectLiteralExpression expression, P data) {
+        visitObjectLiteralExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitRootPackageExpression(@NotNull KtRootPackageExpression expression, P data) {
+        visitRootPackageExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitBlockExpression(@NotNull KtBlockExpression expression, P data) {
+        visitBlockExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitCatchSection(@NotNull KtCatchClause catchClause, P data) {
+        visitCatchSectionVoid(catchClause, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitFinallySection(@NotNull KtFinallySection finallySection, P data) {
+        visitFinallySectionVoid(finallySection, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitTypeArgumentList(@NotNull KtTypeArgumentList typeArgumentList, P data) {
+        visitTypeArgumentListVoid(typeArgumentList, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitThisExpression(@NotNull KtThisExpression expression, P data) {
+        visitThisExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitSuperExpression(@NotNull KtSuperExpression expression, P data) {
+        visitSuperExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitParenthesizedExpression(@NotNull KtParenthesizedExpression expression, P data) {
+        visitParenthesizedExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitInitializerList(@NotNull KtInitializerList list, P data) {
+        visitInitializerListVoid(list, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitAnonymousInitializer(@NotNull KtClassInitializer initializer, P data) {
+        visitAnonymousInitializerVoid(initializer, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitPropertyAccessor(@NotNull KtPropertyAccessor accessor, P data) {
+        visitPropertyAccessorVoid(accessor, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitTypeConstraintList(@NotNull KtTypeConstraintList list, P data) {
+        visitTypeConstraintListVoid(list, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitTypeConstraint(@NotNull KtTypeConstraint constraint, P data) {
+        visitTypeConstraintVoid(constraint, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitUserType(@NotNull KtUserType type, P data) {
+        visitUserTypeVoid(type, data);
+    	return null;
+    }
+
+    @Override
+    public Void visitDynamicType(@NotNull KtDynamicType type, P data) {
+        visitDynamicTypeVoid(type, data);
+        return null;
+    }
+
+    @Override
+    public final Void visitFunctionType(@NotNull KtFunctionType type, P data) {
+        visitFunctionTypeVoid(type, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitSelfType(@NotNull KtSelfType type, P data) {
+        visitSelfTypeVoid(type, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitBinaryWithTypeRHSExpression(@NotNull KtBinaryExpressionWithTypeRHS expression, P data) {
+        visitBinaryWithTypeRHSExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitStringTemplateExpression(@NotNull KtStringTemplateExpression expression, P data) {
+        visitStringTemplateExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitNamedDeclaration(@NotNull KtNamedDeclaration declaration, P data) {
+        visitNamedDeclarationVoid(declaration, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitNullableType(@NotNull KtNullableType nullableType, P data) {
+        visitNullableTypeVoid(nullableType, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitTypeProjection(@NotNull KtTypeProjection typeProjection, P data) {
+        visitTypeProjectionVoid(typeProjection, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitWhenEntry(@NotNull KtWhenEntry jetWhenEntry, P data) {
+        visitWhenEntryVoid(jetWhenEntry, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitIsExpression(@NotNull KtIsExpression expression, P data) {
+        visitIsExpressionVoid(expression, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitWhenConditionIsPattern(@NotNull KtWhenConditionIsPattern condition, P data) {
+        visitWhenConditionIsPatternVoid(condition, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitWhenConditionInRange(@NotNull KtWhenConditionInRange condition, P data) {
+        visitWhenConditionInRangeVoid(condition, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitWhenConditionWithExpression(@NotNull KtWhenConditionWithExpression condition, P data) {
+        visitWhenConditionWithExpressionVoid(condition, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitObjectDeclaration(@NotNull KtObjectDeclaration declaration, P data) {
+        visitObjectDeclarationVoid(declaration, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitObjectDeclarationName(@NotNull KtObjectDeclarationName declarationName, P data) {
+        visitObjectDeclarationNameVoid(declarationName, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitStringTemplateEntry(@NotNull KtStringTemplateEntry entry, P data) {
+        visitStringTemplateEntryVoid(entry, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitStringTemplateEntryWithExpression(@NotNull KtStringTemplateEntryWithExpression entry, P data) {
+        visitStringTemplateEntryWithExpressionVoid(entry, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitBlockStringTemplateEntry(@NotNull KtBlockStringTemplateEntry entry, P data) {
+        visitBlockStringTemplateEntryVoid(entry, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitSimpleNameStringTemplateEntry(@NotNull KtSimpleNameStringTemplateEntry entry, P data) {
+        visitSimpleNameStringTemplateEntryVoid(entry, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitLiteralStringTemplateEntry(@NotNull KtLiteralStringTemplateEntry entry, P data) {
+        visitLiteralStringTemplateEntryVoid(entry, data);
+    	return null;
+    }
+
+    @Override
+    public final Void visitEscapeStringTemplateEntry(@NotNull KtEscapeStringTemplateEntry entry, P data) {
+        visitEscapeStringTemplateEntryVoid(entry, data);
+        return null;
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenCondition.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenCondition.java
similarity index 86%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenCondition.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenCondition.java
index 061809072b4..b819233c5eb 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenCondition.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenCondition.java
@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 
-public abstract class JetWhenCondition extends JetElementImpl {
-    public JetWhenCondition(@NotNull ASTNode node) {
+public abstract class KtWhenCondition extends KtElementImpl {
+    public KtWhenCondition(@NotNull ASTNode node) {
         super(node);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenConditionInRange.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenConditionInRange.java
similarity index 66%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenConditionInRange.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenConditionInRange.java
index 616f2d227ef..ec329709068 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenConditionInRange.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenConditionInRange.java
@@ -20,26 +20,26 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-public class JetWhenConditionInRange extends JetWhenCondition {
-    public JetWhenConditionInRange(@NotNull ASTNode node) {
+public class KtWhenConditionInRange extends KtWhenCondition {
+    public KtWhenConditionInRange(@NotNull ASTNode node) {
         super(node);
     }
 
     public boolean isNegated() {
-        return getNode().findChildByType(JetTokens.NOT_IN) != null;
+        return getNode().findChildByType(KtTokens.NOT_IN) != null;
     }
 
     @Nullable @IfNotParsed
-    public JetExpression getRangeExpression() {
+    public KtExpression getRangeExpression() {
         // Copied from JetBinaryExpression
         ASTNode node = getOperationReference().getNode().getTreeNext();
         while (node != null) {
             PsiElement psi = node.getPsi();
-            if (psi instanceof JetExpression) {
-                return (JetExpression) psi;
+            if (psi instanceof KtExpression) {
+                return (KtExpression) psi;
             }
             node = node.getTreeNext();
         }
@@ -48,12 +48,12 @@ public class JetWhenConditionInRange extends JetWhenCondition {
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitWhenConditionInRange(this, data);
     }
 
     @NotNull
-    public JetSimpleNameExpression getOperationReference() {
-        return (JetSimpleNameExpression) findChildByType(JetNodeTypes.OPERATION_REFERENCE);
+    public KtSimpleNameExpression getOperationReference() {
+        return (KtSimpleNameExpression) findChildByType(KtNodeTypes.OPERATION_REFERENCE);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenConditionIsPattern.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenConditionIsPattern.java
similarity index 66%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenConditionIsPattern.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenConditionIsPattern.java
index 8d84d08ab1c..c7f0dab6641 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenConditionIsPattern.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenConditionIsPattern.java
@@ -19,25 +19,25 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-public class JetWhenConditionIsPattern extends JetWhenCondition {
-    public JetWhenConditionIsPattern(@NotNull ASTNode node) {
+public class KtWhenConditionIsPattern extends KtWhenCondition {
+    public KtWhenConditionIsPattern(@NotNull ASTNode node) {
         super(node);
     }
 
     public boolean isNegated() {
-        return getNode().findChildByType(JetTokens.NOT_IS) != null;
+        return getNode().findChildByType(KtTokens.NOT_IS) != null;
     }
 
     @Nullable @IfNotParsed
-    public JetTypeReference getTypeReference() {
-        return (JetTypeReference) findChildByType(JetNodeTypes.TYPE_REFERENCE);
+    public KtTypeReference getTypeReference() {
+        return (KtTypeReference) findChildByType(KtNodeTypes.TYPE_REFERENCE);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitWhenConditionIsPattern(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenConditionWithExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenConditionWithExpression.java
similarity index 74%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenConditionWithExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenConditionWithExpression.java
index eda288667f8..16998dbd768 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenConditionWithExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenConditionWithExpression.java
@@ -20,19 +20,19 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public class JetWhenConditionWithExpression extends JetWhenCondition {
-    public JetWhenConditionWithExpression(@NotNull ASTNode node) {
+public class KtWhenConditionWithExpression extends KtWhenCondition {
+    public KtWhenConditionWithExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Nullable
     @IfNotParsed
-    public JetExpression getExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getExpression() {
+        return findChildByClass(KtExpression.class);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitWhenConditionWithExpression(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenEntry.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenEntry.java
similarity index 69%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenEntry.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenEntry.java
index f0b54940007..908a0237cf8 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenEntry.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenEntry.java
@@ -20,10 +20,10 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
-public class JetWhenEntry extends JetElementImpl {
-    public JetWhenEntry(@NotNull ASTNode node) {
+public class KtWhenEntry extends KtElementImpl {
+    public KtWhenEntry(@NotNull ASTNode node) {
         super(node);
     }
 
@@ -33,21 +33,21 @@ public class JetWhenEntry extends JetElementImpl {
 
     @Nullable
     public PsiElement getElseKeyword() {
-        return findChildByType(JetTokens.ELSE_KEYWORD);
+        return findChildByType(KtTokens.ELSE_KEYWORD);
     }
 
     @Nullable
-    public JetExpression getExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getExpression() {
+        return findChildByClass(KtExpression.class);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitWhenEntry(this, data);
     }
 
     @NotNull
-    public JetWhenCondition[] getConditions() {
-        return findChildrenByClass(JetWhenCondition.class);
+    public KtWhenCondition[] getConditions() {
+        return findChildrenByClass(KtWhenCondition.class);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenExpression.java
similarity index 63%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenExpression.java
index 013d0ea7d86..10c113d7fb8 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhenExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhenExpression.java
@@ -20,60 +20,60 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
 import java.util.List;
 
-public class JetWhenExpression extends JetExpressionImpl {
-    public JetWhenExpression(@NotNull ASTNode node) {
+public class KtWhenExpression extends KtExpressionImpl {
+    public KtWhenExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @NotNull
-    public List<JetWhenEntry> getEntries() {
-        return findChildrenByType(JetNodeTypes.WHEN_ENTRY);
+    public List<KtWhenEntry> getEntries() {
+        return findChildrenByType(KtNodeTypes.WHEN_ENTRY);
     }
 
     @Nullable
-    public JetExpression getSubjectExpression() {
-        return findChildByClass(JetExpression.class);
+    public KtExpression getSubjectExpression() {
+        return findChildByClass(KtExpression.class);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitWhenExpression(this, data);
     }
 
     @NotNull
     public PsiElement getWhenKeyword() {
         //noinspection ConstantConditions
-        return findChildByType(JetTokens.WHEN_KEYWORD);
+        return findChildByType(KtTokens.WHEN_KEYWORD);
     }
 
     @Nullable
     public PsiElement getCloseBrace() {
-        return findChildByType(JetTokens.RBRACE);
+        return findChildByType(KtTokens.RBRACE);
     }
 
     @Nullable
     public PsiElement getOpenBrace() {
-        return findChildByType(JetTokens.LBRACE);
+        return findChildByType(KtTokens.LBRACE);
     }
 
     @Nullable
     public PsiElement getLeftParenthesis() {
-        return findChildByType(JetTokens.LPAR);
+        return findChildByType(KtTokens.LPAR);
     }
 
     @Nullable
     public PsiElement getRightParenthesis() {
-        return findChildByType(JetTokens.RPAR);
+        return findChildByType(KtTokens.RPAR);
     }
 
     @Nullable
-    public JetExpression getElseExpression() {
-        for (JetWhenEntry entry : getEntries()) {
+    public KtExpression getElseExpression() {
+        for (KtWhenEntry entry : getEntries()) {
             if (entry.isElse()) {
                 return entry.getExpression();
             }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhileExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhileExpression.java
similarity index 81%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhileExpression.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhileExpression.java
index d7ddb09f83b..ccd1f0ce108 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhileExpression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhileExpression.java
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 
-public class JetWhileExpression extends JetWhileExpressionBase {
-    public JetWhileExpression(@NotNull ASTNode node) {
+public class KtWhileExpression extends KtWhileExpressionBase {
+    public KtWhileExpression(@NotNull ASTNode node) {
         super(node);
     }
 
     @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
         return visitor.visitWhileExpression(this, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhileExpressionBase.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhileExpressionBase.java
similarity index 74%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhileExpressionBase.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhileExpressionBase.java
index 2f6a451a9f3..a7d8168d90e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWhileExpressionBase.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWhileExpressionBase.java
@@ -19,16 +19,16 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 
-public abstract class JetWhileExpressionBase extends JetLoopExpression {
-    public JetWhileExpressionBase(@NotNull ASTNode node) {
+public abstract class KtWhileExpressionBase extends KtLoopExpression {
+    public KtWhileExpressionBase(@NotNull ASTNode node) {
         super(node);
     }
 
     @Nullable
     @IfNotParsed
-    public JetExpression getCondition() {
-        return findExpressionUnder(JetNodeTypes.CONDITION);
+    public KtExpression getCondition() {
+        return findExpressionUnder(KtNodeTypes.CONDITION);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWithExpressionInitializer.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWithExpressionInitializer.java
similarity index 88%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetWithExpressionInitializer.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/KtWithExpressionInitializer.java
index 01a8148e907..24f6c66e10c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetWithExpressionInitializer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtWithExpressionInitializer.java
@@ -19,9 +19,9 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.Nullable;
 
-public interface JetWithExpressionInitializer extends PsiElement {
+public interface KtWithExpressionInitializer extends PsiElement {
     @Nullable
-    JetExpression getInitializer();
+    KtExpression getInitializer();
 
     boolean hasInitializer();
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/TypeRefHelpers.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/TypeRefHelpers.kt
index 7853a3d4fa9..b4673563d37 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/TypeRefHelpers.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/TypeRefHelpers.kt
@@ -16,33 +16,33 @@
 
 package org.jetbrains.kotlin.psi.typeRefHelpers
 
-import org.jetbrains.kotlin.psi.JetTypeReference
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.psi.KtTypeReference
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.psiUtil.siblings
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import com.intellij.psi.PsiWhiteSpace
 import com.intellij.psi.PsiErrorElement
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
-import org.jetbrains.kotlin.psi.JetFunctionType
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtFunctionType
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 
-fun getTypeReference(declaration: JetCallableDeclaration): JetTypeReference? {
+fun getTypeReference(declaration: KtCallableDeclaration): KtTypeReference? {
     return declaration.getFirstChild()!!.siblings(forward = true)
-            .dropWhile { it.getNode()!!.getElementType() != JetTokens.COLON }
-            .firstIsInstanceOrNull<JetTypeReference>()
+            .dropWhile { it.getNode()!!.getElementType() != KtTokens.COLON }
+            .firstIsInstanceOrNull<KtTypeReference>()
 }
 
-fun setTypeReference(declaration: JetCallableDeclaration, addAfter: PsiElement?, typeRef: JetTypeReference?): JetTypeReference? {
+fun setTypeReference(declaration: KtCallableDeclaration, addAfter: PsiElement?, typeRef: KtTypeReference?): KtTypeReference? {
     val oldTypeRef = getTypeReference(declaration)
     if (typeRef != null) {
         if (oldTypeRef != null) {
-            return oldTypeRef.replace(typeRef) as JetTypeReference
+            return oldTypeRef.replace(typeRef) as KtTypeReference
         }
         else {
             var anchor = addAfter ?: declaration.getNameIdentifier()?.siblings(forward = true)?.firstOrNull { it is PsiErrorElement }
-            val newTypeRef = declaration.addAfter(typeRef, anchor) as JetTypeReference
-            declaration.addAfter(JetPsiFactory(declaration.getProject()).createColon(), anchor)
+            val newTypeRef = declaration.addAfter(typeRef, anchor) as KtTypeReference
+            declaration.addAfter(KtPsiFactory(declaration.getProject()).createColon(), anchor)
             return newTypeRef
         }
     }
@@ -56,22 +56,22 @@ fun setTypeReference(declaration: JetCallableDeclaration, addAfter: PsiElement?,
     }
 }
 
-fun JetCallableDeclaration.setReceiverTypeReference(typeRef: JetTypeReference?): JetTypeReference? {
-    val needParentheses = typeRef != null && typeRef.typeElement is JetFunctionType && !typeRef.hasParentheses()
+fun KtCallableDeclaration.setReceiverTypeReference(typeRef: KtTypeReference?): KtTypeReference? {
+    val needParentheses = typeRef != null && typeRef.typeElement is KtFunctionType && !typeRef.hasParentheses()
     val oldTypeRef = getReceiverTypeReference()
     if (typeRef != null) {
         val newTypeRef =
                 if (oldTypeRef != null) {
-                    oldTypeRef.replace(typeRef) as JetTypeReference
+                    oldTypeRef.replace(typeRef) as KtTypeReference
                 }
                 else {
                     val anchor = getNameIdentifier() ?: valueParameterList
-                    val newTypeRef = addBefore(typeRef, anchor) as JetTypeReference
-                    addAfter(JetPsiFactory(getProject()).createDot(), newTypeRef)
+                    val newTypeRef = addBefore(typeRef, anchor) as KtTypeReference
+                    addAfter(KtPsiFactory(getProject()).createDot(), newTypeRef)
                     newTypeRef
                 }
         if (needParentheses) {
-            val argList = JetPsiFactory(getProject()).createCallArguments("()")
+            val argList = KtPsiFactory(getProject()).createCallArguments("()")
             newTypeRef.addBefore(argList.getLeftParenthesis()!!, newTypeRef.getFirstChild())
             newTypeRef.add(argList.getRightParenthesis()!!)
         }
@@ -79,7 +79,7 @@ fun JetCallableDeclaration.setReceiverTypeReference(typeRef: JetTypeReference?):
     }
     else {
         if (oldTypeRef != null) {
-            val dot = oldTypeRef.siblings(forward = true).firstOrNull { it.getNode().getElementType() == JetTokens.DOT }
+            val dot = oldTypeRef.siblings(forward = true).firstOrNull { it.getNode().getElementType() == KtTokens.DOT }
             deleteChildRange(oldTypeRef, dot ?: oldTypeRef)
         }
         return null
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/ValueArgument.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/ValueArgument.kt
index a515f46f095..ce8758cc193 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/ValueArgument.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/ValueArgument.kt
@@ -21,13 +21,13 @@ import org.jetbrains.kotlin.name.Name
 
 public interface ValueArgument {
     @IfNotParsed
-    public fun getArgumentExpression(): JetExpression?
+    public fun getArgumentExpression(): KtExpression?
 
     public fun getArgumentName(): ValueArgumentName?
 
     public fun isNamed(): Boolean
 
-    public fun asElement(): JetElement
+    public fun asElement(): KtElement
 
     /* The '*' in something like foo(*arr) i.e. pass an array as a number of vararg arguments */
     public fun getSpreadElement(): LeafPsiElement?
@@ -37,12 +37,12 @@ public interface ValueArgument {
 }
 
 public interface FunctionLiteralArgument : ValueArgument {
-    public fun getFunctionLiteral(): JetFunctionLiteralExpression
+    public fun getFunctionLiteral(): KtFunctionLiteralExpression
 
-    override fun getArgumentExpression(): JetExpression
+    override fun getArgumentExpression(): KtExpression
 }
 
 public interface ValueArgumentName {
     public val asName: Name
-    public val referenceExpression: JetSimpleNameExpression?
+    public val referenceExpression: KtSimpleNameExpression?
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/addRemoveModifier.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/addRemoveModifier.kt
index a689a9619ee..4f40397f5de 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/addRemoveModifier.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/addRemoveModifier.kt
@@ -19,21 +19,21 @@ package org.jetbrains.kotlin.psi.addRemoveModifier
 import com.intellij.psi.PsiComment
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiWhiteSpace
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens.*
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.siblings
 
-private fun createModifierList(text: String, owner: JetModifierListOwner): JetModifierList {
-    val newModifierList = JetPsiFactory(owner).createModifierList(text)
+private fun createModifierList(text: String, owner: KtModifierListOwner): KtModifierList {
+    val newModifierList = KtPsiFactory(owner).createModifierList(text)
     val anchor = owner.firstChild!!
             .siblings(forward = true)
             .dropWhile { it is PsiComment || it is PsiWhiteSpace }
             .first()
-    return owner.addBefore(newModifierList, anchor) as JetModifierList
+    return owner.addBefore(newModifierList, anchor) as KtModifierList
 }
 
-fun addModifier(owner: JetModifierListOwner, modifier: JetModifierKeywordToken) {
+fun addModifier(owner: KtModifierListOwner, modifier: KtModifierKeywordToken) {
     val modifierList = owner.modifierList
     if (modifierList == null) {
         createModifierList(modifier.value, owner)
@@ -43,20 +43,20 @@ fun addModifier(owner: JetModifierListOwner, modifier: JetModifierKeywordToken)
     }
 }
 
-fun addAnnotationEntry(owner: JetModifierListOwner, annotationEntry: JetAnnotationEntry): JetAnnotationEntry {
+fun addAnnotationEntry(owner: KtModifierListOwner, annotationEntry: KtAnnotationEntry): KtAnnotationEntry {
     val modifierList = owner.modifierList
     return if (modifierList == null) {
         createModifierList(annotationEntry.text, owner).annotationEntries.first()
     }
     else {
-        modifierList.addBefore(annotationEntry, modifierList.firstChild) as JetAnnotationEntry
+        modifierList.addBefore(annotationEntry, modifierList.firstChild) as KtAnnotationEntry
     }
 }
 
-internal fun addModifier(modifierList: JetModifierList, modifier: JetModifierKeywordToken) {
+internal fun addModifier(modifierList: KtModifierList, modifier: KtModifierKeywordToken) {
     if (modifierList.hasModifier(modifier)) return
 
-    val newModifier = JetPsiFactory(modifierList).createModifier(modifier)
+    val newModifier = KtPsiFactory(modifierList).createModifier(modifier)
     val modifierToReplace = MODIFIERS_TO_REPLACE[modifier]
             ?.map { modifierList.getModifier(it) }
             ?.filterNotNull()
@@ -70,7 +70,7 @@ internal fun addModifier(modifierList: JetModifierList, modifier: JetModifierKey
 
         fun placeAfter(child: PsiElement): Boolean {
             if (child is PsiWhiteSpace) return false
-            if (child is JetAnnotation) return true // place modifiers after annotations
+            if (child is KtAnnotation) return true // place modifiers after annotations
             val elementType = child.getNode()!!.getElementType()
             val order = MODIFIERS_ORDER.indexOf(elementType)
             return newModifierOrder > order
@@ -90,7 +90,7 @@ internal fun addModifier(modifierList: JetModifierList, modifier: JetModifierKey
     }
 }
 
-fun removeModifier(owner: JetModifierListOwner, modifier: JetModifierKeywordToken) {
+fun removeModifier(owner: KtModifierListOwner, modifier: KtModifierKeywordToken) {
     owner.getModifierList()?.let {
         it.getModifier(modifier)?.delete()
         if (it.firstChild == null) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/codeFragmentUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/codeFragmentUtil.kt
index b6c5a013fd8..80e171f2ff5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/codeFragmentUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/codeFragmentUtil.kt
@@ -17,17 +17,17 @@
 package org.jetbrains.kotlin.psi.codeFragmentUtil
 
 import com.intellij.openapi.util.Key
-import org.jetbrains.kotlin.psi.JetCodeFragment
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetTypeReference
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.psi.KtCodeFragment
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtTypeReference
+import org.jetbrains.kotlin.types.KtType
 
 public val SUPPRESS_DIAGNOSTICS_IN_DEBUG_MODE: Key<Boolean> = Key.create<Boolean>("SUPPRESS_DIAGNOSTICS_IN_DEBUG_MODE")
 
-public var JetFile.suppressDiagnosticsInDebugMode: Boolean
+public var KtFile.suppressDiagnosticsInDebugMode: Boolean
     get() = when (this) {
-        is JetCodeFragment -> true
-        is JetFile -> getUserData(SUPPRESS_DIAGNOSTICS_IN_DEBUG_MODE) ?: false
+        is KtCodeFragment -> true
+        is KtFile -> getUserData(SUPPRESS_DIAGNOSTICS_IN_DEBUG_MODE) ?: false
         else -> false
     }
     set(skip: Boolean) {
@@ -36,10 +36,10 @@ public var JetFile.suppressDiagnosticsInDebugMode: Boolean
 
 public val DEBUG_TYPE_REFERENCE_STRING: String = "DebugTypeKotlinRulezzzz"
 
-public val DEBUG_TYPE_INFO: Key<JetType> = Key.create<JetType>("DEBUG_TYPE_INFO")
-public var JetTypeReference.debugTypeInfo: JetType?
+public val DEBUG_TYPE_INFO: Key<KtType> = Key.create<KtType>("DEBUG_TYPE_INFO")
+public var KtTypeReference.debugTypeInfo: KtType?
     get() = getUserData(DEBUG_TYPE_INFO)
-    set(type: JetType?) {
+    set(type: KtType?) {
         if (type != null && this.getText() == DEBUG_TYPE_REFERENCE_STRING) {
             putUserData(DEBUG_TYPE_INFO, type)
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/createByPattern.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/createByPattern.kt
index 2d0502ceec7..d61f890daa1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/createByPattern.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/createByPattern.kt
@@ -30,10 +30,10 @@ import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.renderer.render
 import java.util.*
 
-public fun JetPsiFactory.createExpressionByPattern(pattern: String, vararg args: Any): JetExpression
+public fun KtPsiFactory.createExpressionByPattern(pattern: String, vararg args: Any): KtExpression
         = createByPattern(pattern, *args) { createExpression(it) }
 
-public fun <TDeclaration : JetDeclaration> JetPsiFactory.createDeclarationByPattern(pattern: String, vararg args: Any): TDeclaration
+public fun <TDeclaration : KtDeclaration> KtPsiFactory.createDeclarationByPattern(pattern: String, vararg args: Any): TDeclaration
         = createByPattern(pattern, *args) { createDeclaration<TDeclaration>(it) }
 
 private abstract class ArgumentType<T : Any>(val klass: Class<T>)
@@ -56,8 +56,8 @@ private class PsiElementArgumentType<T : PsiElement>(klass: Class<T>) : PsiEleme
     }
 }
 
-private object PsiChildRangeArgumentType : PsiElementPlaceholderArgumentType<PsiChildRange, JetElement>(javaClass(), javaClass()) {
-    override fun replacePlaceholderElement(placeholder: JetElement, argument: PsiChildRange) {
+private object PsiChildRangeArgumentType : PsiElementPlaceholderArgumentType<PsiChildRange, KtElement>(javaClass(), javaClass()) {
+    override fun replacePlaceholderElement(placeholder: KtElement, argument: PsiChildRange) {
         val project = placeholder.getProject()
         val codeStyleManager = CodeStyleManager.getInstance(project)
 
@@ -78,14 +78,14 @@ private object PsiChildRangeArgumentType : PsiElementPlaceholderArgumentType<Psi
 }
 
 private val SUPPORTED_ARGUMENT_TYPES = listOf(
-        PsiElementArgumentType<JetExpression>(javaClass()),
-        PsiElementArgumentType<JetTypeReference>(javaClass()),
+        PsiElementArgumentType<KtExpression>(javaClass()),
+        PsiElementArgumentType<KtTypeReference>(javaClass()),
         PlainTextArgumentType<String>(javaClass(), toPlainText = { it }),
         PlainTextArgumentType<Name>(javaClass(), toPlainText = { it.render() }),
         PsiChildRangeArgumentType
 )
 
-public fun <TElement : JetElement> createByPattern(pattern: String, vararg args: Any, factory: (String) -> TElement): TElement {
+public fun <TElement : KtElement> createByPattern(pattern: String, vararg args: Any, factory: (String) -> TElement): TElement {
     val argumentTypes = args.map { arg ->
         SUPPORTED_ARGUMENT_TYPES.firstOrNull { it.klass.isInstance(arg) }
             ?: throw IllegalArgumentException("Unsupported argument type: ${arg.javaClass}, should be one of: ${SUPPORTED_ARGUMENT_TYPES.map { it.klass.getSimpleName() }.joinToString()}")
@@ -163,8 +163,8 @@ public fun <TElement : JetElement> createByPattern(pattern: String, vararg args:
 
     for ((pointer, n) in pointers) {
         var element = pointer.getElement()!!
-        if (element is JetFunctionLiteral) {
-            element = element.getParent() as JetFunctionLiteralExpression
+        if (element is KtFunctionLiteral) {
+            element = element.getParent() as KtFunctionLiteralExpression
         }
         (argumentTypes[n] as PsiElementPlaceholderArgumentType<in Any, in PsiElement>).replacePlaceholderElement(element, args[n])
     }
@@ -264,7 +264,7 @@ public class BuilderByPattern<TElement> {
         return this
     }
 
-    public fun appendExpression(expression: JetExpression?): BuilderByPattern<TElement> {
+    public fun appendExpression(expression: KtExpression?): BuilderByPattern<TElement> {
         if (expression != null) {
             patternBuilder.append("$" + arguments.size())
             arguments.add(expression)
@@ -272,7 +272,7 @@ public class BuilderByPattern<TElement> {
         return this
     }
 
-    public fun appendTypeReference(typeRef: JetTypeReference?): BuilderByPattern<TElement> {
+    public fun appendTypeReference(typeRef: KtTypeReference?): BuilderByPattern<TElement> {
         if (typeRef != null) {
             patternBuilder.append("$" + arguments.size())
             arguments.add(typeRef)
@@ -291,11 +291,11 @@ public class BuilderByPattern<TElement> {
     }
 }
 
-public fun JetPsiFactory.buildExpression(build: BuilderByPattern<JetExpression>.() -> Unit): JetExpression {
+public fun KtPsiFactory.buildExpression(build: BuilderByPattern<KtExpression>.() -> Unit): KtExpression {
     return buildByPattern({ pattern, args -> this.createExpressionByPattern(pattern, *args) }, build)
 }
 
-public fun JetPsiFactory.buildDeclaration(build: BuilderByPattern<JetDeclaration>.() -> Unit): JetDeclaration {
+public fun KtPsiFactory.buildDeclaration(build: BuilderByPattern<KtDeclaration>.() -> Unit): KtDeclaration {
     return buildByPattern({ pattern, args -> this.createDeclarationByPattern(pattern, *args) }, build)
 }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/JetStringTemplateExpressionManipulator.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/KtStringTemplateExpressionManipulator.kt
similarity index 70%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/JetStringTemplateExpressionManipulator.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/KtStringTemplateExpressionManipulator.kt
index a9b5b3003dc..d37d459ea4f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/JetStringTemplateExpressionManipulator.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/KtStringTemplateExpressionManipulator.kt
@@ -16,24 +16,24 @@
 
 package org.jetbrains.kotlin.psi.psiUtil
 
-import com.intellij.psi.AbstractElementManipulator
-import org.jetbrains.kotlin.psi.JetStringTemplateExpression
 import com.intellij.openapi.util.TextRange
-import org.jetbrains.kotlin.psi.JetPsiFactory
 import com.intellij.openapi.util.text.StringUtil
+import com.intellij.psi.AbstractElementManipulator
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtStringTemplateExpression
 
-public class JetStringTemplateExpressionManipulator : AbstractElementManipulator<JetStringTemplateExpression>() {
-    override fun handleContentChange(element: JetStringTemplateExpression, range: TextRange, newContent: String): JetStringTemplateExpression? {
+public class KtStringTemplateExpressionManipulator : AbstractElementManipulator<KtStringTemplateExpression>() {
+    override fun handleContentChange(element: KtStringTemplateExpression, range: TextRange, newContent: String): KtStringTemplateExpression? {
         val node = element.getNode()
         val content = if (element.isSingleQuoted()) StringUtil.escapeStringCharacters(newContent) else newContent
         val oldText = node.getText()
         val newText = oldText.substring(0, range.getStartOffset()) + content + oldText.substring(range.getEndOffset())
-        val expression = JetPsiFactory(element.getProject()).createExpression(newText)
+        val expression = KtPsiFactory(element.getProject()).createExpression(newText)
         node.replaceAllChildrenToChildrenOf(expression.getNode())
         return node.getPsi(javaClass())
     }
 
-    override fun getRangeInElement(element: JetStringTemplateExpression): TextRange {
+    override fun getRangeInElement(element: KtStringTemplateExpression): TextRange {
         return element.getContentRange()
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/StringTemplateExpressionManipulator.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/StringTemplateExpressionManipulator.kt
index d6fb9f04d1c..f6e05ec6977 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/StringTemplateExpressionManipulator.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/StringTemplateExpressionManipulator.kt
@@ -17,23 +17,23 @@
 package org.jetbrains.kotlin.psi.psiUtil
 
 import com.intellij.psi.AbstractElementManipulator
-import org.jetbrains.kotlin.psi.JetStringTemplateExpression
+import org.jetbrains.kotlin.psi.KtStringTemplateExpression
 import com.intellij.openapi.util.TextRange
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import com.intellij.openapi.util.text.StringUtil
 
-public class StringTemplateExpressionManipulator: AbstractElementManipulator<JetStringTemplateExpression>() {
-    override fun handleContentChange(element: JetStringTemplateExpression, range: TextRange, newContent: String): JetStringTemplateExpression? {
+public class StringTemplateExpressionManipulator: AbstractElementManipulator<KtStringTemplateExpression>() {
+    override fun handleContentChange(element: KtStringTemplateExpression, range: TextRange, newContent: String): KtStringTemplateExpression? {
         val node = element.getNode()
         val content = if (node.getFirstChildNode().getTextLength() == 1) StringUtil.escapeStringCharacters(newContent) else newContent
         val oldText = node.getText()
         val newText = oldText.substring(0, range.getStartOffset()) + content + oldText.substring(range.getEndOffset())
-        val expression = JetPsiFactory(element.getProject()).createExpression(newText)
+        val expression = KtPsiFactory(element.getProject()).createExpression(newText)
         node.replaceAllChildrenToChildrenOf(expression.getNode())
         return node.getPsi(javaClass())
     }
 
-    override fun getRangeInElement(element: JetStringTemplateExpression): TextRange {
+    override fun getRangeInElement(element: KtStringTemplateExpression): TextRange {
         return element.getContentRange()
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt
index 9b041292439..d34734a5f25 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt
@@ -24,9 +24,9 @@ import com.intellij.psi.PsiParameterList
 import com.intellij.psi.PsiWhiteSpace
 import com.intellij.psi.stubs.StubElement
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.JetNodeTypes
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.KtNodeTypes
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub
@@ -41,81 +41,81 @@ import kotlin.test.assertTrue
 
 // ----------- Calls and qualified expressions ---------------------------------------------------------------------------------------------
 
-public fun JetCallElement.getCallNameExpression(): JetSimpleNameExpression? {
+public fun KtCallElement.getCallNameExpression(): KtSimpleNameExpression? {
     val calleeExpression = getCalleeExpression() ?: return null
 
     return when (calleeExpression) {
-        is JetSimpleNameExpression -> calleeExpression
-        is JetConstructorCalleeExpression -> calleeExpression.getConstructorReferenceExpression()
+        is KtSimpleNameExpression -> calleeExpression
+        is KtConstructorCalleeExpression -> calleeExpression.getConstructorReferenceExpression()
         else -> null
     }
 }
 
 /**
- * Returns enclosing qualifying element for given [[JetSimpleNameExpression]]
- * ([[JetQualifiedExpression]] or [[JetUserType]] or original expression)
+ * Returns enclosing qualifying element for given [[KtSimpleNameExpression]]
+ * ([[KtQualifiedExpression]] or [[KtUserType]] or original expression)
  */
-public fun JetSimpleNameExpression.getQualifiedElement(): JetElement {
-    val baseExpression = (parent as? JetCallExpression) ?: this
+public fun KtSimpleNameExpression.getQualifiedElement(): KtElement {
+    val baseExpression = (parent as? KtCallExpression) ?: this
     val parent = baseExpression.parent
     return when (parent) {
-        is JetQualifiedExpression -> if (parent.selectorExpression == baseExpression) parent else baseExpression
-        is JetUserType -> if (parent.referenceExpression == baseExpression) parent else baseExpression
+        is KtQualifiedExpression -> if (parent.selectorExpression == baseExpression) parent else baseExpression
+        is KtUserType -> if (parent.referenceExpression == baseExpression) parent else baseExpression
         else -> baseExpression
     }
 }
 
-public fun JetSimpleNameExpression.getTopmostParentQualifiedExpressionForSelector(): JetQualifiedExpression? {
-    return sequence<JetExpression>(this) {
-        val parentQualified = it.getParent() as? JetQualifiedExpression
+public fun KtSimpleNameExpression.getTopmostParentQualifiedExpressionForSelector(): KtQualifiedExpression? {
+    return sequence<KtExpression>(this) {
+        val parentQualified = it.getParent() as? KtQualifiedExpression
         if (parentQualified?.getSelectorExpression() == it) parentQualified else null
-    }.last() as? JetQualifiedExpression
+    }.last() as? KtQualifiedExpression
 }
 
 /**
  * Returns rightmost selector of the qualified element (null if there is no such selector)
  */
-public fun JetElement.getQualifiedElementSelector(): JetElement? {
+public fun KtElement.getQualifiedElementSelector(): KtElement? {
     return when (this) {
-        is JetSimpleNameExpression -> this
-        is JetCallExpression -> getCalleeExpression()
-        is JetQualifiedExpression -> {
+        is KtSimpleNameExpression -> this
+        is KtCallExpression -> getCalleeExpression()
+        is KtQualifiedExpression -> {
             val selector = getSelectorExpression()
-            if (selector is JetCallExpression) selector.getCalleeExpression() else selector
+            if (selector is KtCallExpression) selector.getCalleeExpression() else selector
         }
-        is JetUserType -> getReferenceExpression()
+        is KtUserType -> getReferenceExpression()
         else -> null
     }
 }
 
-public fun JetSimpleNameExpression.getReceiverExpression(): JetExpression? {
+public fun KtSimpleNameExpression.getReceiverExpression(): KtExpression? {
     val parent = getParent()
     when {
-        parent is JetQualifiedExpression -> {
+        parent is KtQualifiedExpression -> {
             val receiverExpression = parent.getReceiverExpression()
             // Name expression can't be receiver for itself
             if (receiverExpression != this) {
                 return receiverExpression
             }
         }
-        parent is JetCallExpression -> {
+        parent is KtCallExpression -> {
             //This is in case `a().b()`
             val callExpression = parent
             val grandParent = callExpression.getParent()
-            if (grandParent is JetQualifiedExpression) {
+            if (grandParent is KtQualifiedExpression) {
                 val parentsReceiver = grandParent.getReceiverExpression()
                 if (parentsReceiver != callExpression) {
                     return parentsReceiver
                 }
             }
         }
-        parent is JetBinaryExpression && parent.getOperationReference() == this -> {
+        parent is KtBinaryExpression && parent.getOperationReference() == this -> {
             return if (parent.getOperationToken() in OperatorConventions.IN_OPERATIONS) parent.getRight() else parent.getLeft()
         }
-        parent is JetUnaryExpression && parent.getOperationReference() == this -> {
+        parent is KtUnaryExpression && parent.getOperationReference() == this -> {
             return parent.getBaseExpression()!!
         }
-        parent is JetUserType -> {
+        parent is KtUserType -> {
             val qualifier = parent.getQualifier()
             if (qualifier != null) {
                 return qualifier.getReferenceExpression()!!
@@ -125,31 +125,31 @@ public fun JetSimpleNameExpression.getReceiverExpression(): JetExpression? {
     return null
 }
 
-public fun JetElement.getQualifiedExpressionForSelector(): JetQualifiedExpression? {
+public fun KtElement.getQualifiedExpressionForSelector(): KtQualifiedExpression? {
     val parent = getParent()
-    return if (parent is JetQualifiedExpression && parent.getSelectorExpression() == this) parent else null
+    return if (parent is KtQualifiedExpression && parent.getSelectorExpression() == this) parent else null
 }
 
-public fun JetExpression.getQualifiedExpressionForSelectorOrThis(): JetExpression {
+public fun KtExpression.getQualifiedExpressionForSelectorOrThis(): KtExpression {
     return getQualifiedExpressionForSelector() ?: this
 }
 
-public fun JetExpression.getQualifiedExpressionForReceiver(): JetQualifiedExpression? {
+public fun KtExpression.getQualifiedExpressionForReceiver(): KtQualifiedExpression? {
     val parent = getParent()
-    return if (parent is JetQualifiedExpression && parent.getReceiverExpression() == this) parent else null
+    return if (parent is KtQualifiedExpression && parent.getReceiverExpression() == this) parent else null
 }
 
-public fun JetExpression.getQualifiedExpressionForReceiverOrThis(): JetExpression {
+public fun KtExpression.getQualifiedExpressionForReceiverOrThis(): KtExpression {
     return getQualifiedExpressionForReceiver() ?: this
 }
 
-public fun JetExpression.isDotReceiver(): Boolean =
-        (getParent() as? JetDotQualifiedExpression)?.getReceiverExpression() == this
+public fun KtExpression.isDotReceiver(): Boolean =
+        (getParent() as? KtDotQualifiedExpression)?.getReceiverExpression() == this
 
-public fun JetElement.getCalleeHighlightingRange(): TextRange {
-    val annotationEntry: JetAnnotationEntry =
-            PsiTreeUtil.getParentOfType<JetAnnotationEntry>(
-                    this, javaClass<JetAnnotationEntry>(), /* strict = */false, javaClass<JetValueArgumentList>()
+public fun KtElement.getCalleeHighlightingRange(): TextRange {
+    val annotationEntry: KtAnnotationEntry =
+            PsiTreeUtil.getParentOfType<KtAnnotationEntry>(
+                    this, javaClass<KtAnnotationEntry>(), /* strict = */false, javaClass<KtValueArgumentList>()
             ) ?: return getTextRange()
 
     val startOffset = annotationEntry.getAtSymbol()?.getTextRange()?.getStartOffset()
@@ -160,13 +160,13 @@ public fun JetElement.getCalleeHighlightingRange(): TextRange {
 
 // ---------- Block expression -------------------------------------------------------------------------------------------------------------
 
-public fun JetElement.blockExpressionsOrSingle(): Sequence<JetElement> =
-        if (this is JetBlockExpression) getStatements().asSequence() else sequenceOf(this)
+public fun KtElement.blockExpressionsOrSingle(): Sequence<KtElement> =
+        if (this is KtBlockExpression) getStatements().asSequence() else sequenceOf(this)
 
-public fun JetExpression.lastBlockStatementOrThis(): JetExpression
-        = (this as? JetBlockExpression)?.getStatements()?.lastOrNull() ?: this
+public fun KtExpression.lastBlockStatementOrThis(): KtExpression
+        = (this as? KtBlockExpression)?.getStatements()?.lastOrNull() ?: this
 
-public fun JetBlockExpression.contentRange(): PsiChildRange {
+public fun KtBlockExpression.contentRange(): PsiChildRange {
     val first = (getLBrace()?.getNextSibling() ?: getFirstChild())
             ?.siblings(withItself = false)
             ?.firstOrNull { it !is PsiWhiteSpace }
@@ -180,24 +180,24 @@ public fun JetBlockExpression.contentRange(): PsiChildRange {
 
 // ----------- Inheritance -----------------------------------------------------------------------------------------------------------------
 
-public fun JetClass.isInheritable(): Boolean {
-    return isInterface() || hasModifier(JetTokens.OPEN_KEYWORD) || hasModifier(JetTokens.ABSTRACT_KEYWORD)
+public fun KtClass.isInheritable(): Boolean {
+    return isInterface() || hasModifier(KtTokens.OPEN_KEYWORD) || hasModifier(KtTokens.ABSTRACT_KEYWORD)
 }
 
-public fun JetDeclaration.isOverridable(): Boolean {
+public fun KtDeclaration.isOverridable(): Boolean {
     val parent = getParent()
-    if (!(parent is JetClassBody || parent is JetParameterList)) return false
+    if (!(parent is KtClassBody || parent is KtParameterList)) return false
 
-    val klass = parent.getParent() as? JetClass ?: return false
+    val klass = parent.getParent() as? KtClass ?: return false
     if (!klass.isInheritable() && !klass.isEnum()) return false
 
-    if (hasModifier(JetTokens.FINAL_KEYWORD) || hasModifier(JetTokens.PRIVATE_KEYWORD)) return false
+    if (hasModifier(KtTokens.FINAL_KEYWORD) || hasModifier(KtTokens.PRIVATE_KEYWORD)) return false
 
     return klass.isInterface() ||
-           hasModifier(JetTokens.ABSTRACT_KEYWORD) || hasModifier(JetTokens.OPEN_KEYWORD) || hasModifier(JetTokens.OVERRIDE_KEYWORD)
+           hasModifier(KtTokens.ABSTRACT_KEYWORD) || hasModifier(KtTokens.OPEN_KEYWORD) || hasModifier(KtTokens.OVERRIDE_KEYWORD)
 }
 
-public fun JetClass.isAbstract(): Boolean = isInterface() || hasModifier(JetTokens.ABSTRACT_KEYWORD)
+public fun KtClass.isAbstract(): Boolean = isInterface() || hasModifier(KtTokens.ABSTRACT_KEYWORD)
 
 /**
  * Returns the list of unqualified names that are indexed as the superclass names of this class. For the names that might be imported
@@ -205,33 +205,33 @@ public fun JetClass.isAbstract(): Boolean = isInterface() || hasModifier(JetToke
  *
  * @return the list of possible superclass names
  */
-public fun StubBasedPsiElementBase<out KotlinClassOrObjectStub<out JetClassOrObject>>.getSuperNames(): List<String> {
+public fun StubBasedPsiElementBase<out KotlinClassOrObjectStub<out KtClassOrObject>>.getSuperNames(): List<String> {
     fun addSuperName(result: MutableList<String>, referencedName: String): Unit {
         result.add(referencedName)
 
         val file = getContainingFile()
-        if (file is JetFile) {
+        if (file is KtFile) {
             val directive = file.findImportByAlias(referencedName)
             if (directive != null) {
                 var reference = directive.getImportedReference()
-                while (reference is JetDotQualifiedExpression) {
+                while (reference is KtDotQualifiedExpression) {
                     reference = reference.getSelectorExpression()
                 }
-                if (reference is JetSimpleNameExpression) {
+                if (reference is KtSimpleNameExpression) {
                     result.add(reference.getReferencedName())
                 }
             }
         }
     }
 
-    assertTrue(this is JetClassOrObject)
+    assertTrue(this is KtClassOrObject)
 
     val stub = getStub()
     if (stub != null) {
         return stub.getSuperNames()
     }
 
-    val specifiers = (this as JetClassOrObject).getDelegationSpecifiers()
+    val specifiers = (this as KtClassOrObject).getDelegationSpecifiers()
     if (specifiers.isEmpty()) return Collections.emptyList<String>()
 
     val result = ArrayList<String>()
@@ -251,39 +251,39 @@ public fun StubBasedPsiElementBase<out KotlinClassOrObjectStub<out JetClassOrObj
 // ------------ Annotations ----------------------------------------------------------------------------------------------------------------
 
 // Annotations on labeled expression lies on it's base expression
-public fun JetExpression.getAnnotationEntries(): List<JetAnnotationEntry> {
+public fun KtExpression.getAnnotationEntries(): List<KtAnnotationEntry> {
     val parent = getParent()
     return when (parent) {
-        is JetAnnotatedExpression -> parent.getAnnotationEntries()
-        is JetLabeledExpression -> parent.getAnnotationEntries()
-        else -> emptyList<JetAnnotationEntry>()
+        is KtAnnotatedExpression -> parent.getAnnotationEntries()
+        is KtLabeledExpression -> parent.getAnnotationEntries()
+        else -> emptyList<KtAnnotationEntry>()
     }
 }
 
-public fun JetAnnotationsContainer.collectAnnotationEntriesFromStubOrPsi(): List<JetAnnotationEntry> {
+public fun KtAnnotationsContainer.collectAnnotationEntriesFromStubOrPsi(): List<KtAnnotationEntry> {
     return when (this) {
         is StubBasedPsiElementBase<*> -> getStub()?.collectAnnotationEntriesFromStubElement() ?: collectAnnotationEntriesFromPsi()
         else -> collectAnnotationEntriesFromPsi()
     }
 }
 
-private fun StubElement<*>.collectAnnotationEntriesFromStubElement(): List<JetAnnotationEntry> {
+private fun StubElement<*>.collectAnnotationEntriesFromStubElement(): List<KtAnnotationEntry> {
     return getChildrenStubs().flatMap {
         child ->
         when (child.getStubType()) {
-            JetNodeTypes.ANNOTATION_ENTRY -> listOf(child.getPsi() as JetAnnotationEntry)
-            JetNodeTypes.ANNOTATION -> (child.getPsi() as JetAnnotation).getEntries()
-            else -> emptyList<JetAnnotationEntry>()
+            KtNodeTypes.ANNOTATION_ENTRY -> listOf(child.getPsi() as KtAnnotationEntry)
+            KtNodeTypes.ANNOTATION -> (child.getPsi() as KtAnnotation).getEntries()
+            else -> emptyList<KtAnnotationEntry>()
         }
     }
 }
 
-private fun JetAnnotationsContainer.collectAnnotationEntriesFromPsi(): List<JetAnnotationEntry> {
+private fun KtAnnotationsContainer.collectAnnotationEntriesFromPsi(): List<KtAnnotationEntry> {
     return getChildren().flatMap { child ->
         when (child) {
-            is JetAnnotationEntry -> listOf(child)
-            is JetAnnotation -> child.getEntries()
-            else -> emptyList<JetAnnotationEntry>()
+            is KtAnnotationEntry -> listOf(child)
+            is KtAnnotation -> child.getEntries()
+            else -> emptyList<KtAnnotationEntry>()
         }
     }
 }
@@ -292,9 +292,9 @@ private fun JetAnnotationsContainer.collectAnnotationEntriesFromPsi(): List<JetA
 
 // Calls `block` on each descendant of T type
 // Note, that calls happen in order of DFS-exit, so deeper nodes are applied earlier
-public inline fun <reified T : JetElement> forEachDescendantOfTypeVisitor(noinline block: (T) -> Unit): JetVisitorVoid {
-    return object : JetTreeVisitorVoid() {
-        override fun visitJetElement(element: JetElement) {
+public inline fun <reified T : KtElement> forEachDescendantOfTypeVisitor(noinline block: (T) -> Unit): KtVisitorVoid {
+    return object : KtTreeVisitorVoid() {
+        override fun visitJetElement(element: KtElement) {
             super.visitJetElement(element)
             if (element is T) {
                 block(element)
@@ -303,107 +303,107 @@ public inline fun <reified T : JetElement> forEachDescendantOfTypeVisitor(noinli
     }
 }
 
-public inline fun <reified T : JetElement, R> flatMapDescendantsOfTypeVisitor(accumulator: MutableCollection<R>, noinline map: (T) -> Collection<R>): JetVisitorVoid {
+public inline fun <reified T : KtElement, R> flatMapDescendantsOfTypeVisitor(accumulator: MutableCollection<R>, noinline map: (T) -> Collection<R>): KtVisitorVoid {
     return forEachDescendantOfTypeVisitor<T> { accumulator.addAll(map(it)) }
 }
 
 // ----------- Other -----------------------------------------------------------------------------------------------------------------------
 
-public fun JetClassOrObject.effectiveDeclarations(): List<JetDeclaration> {
+public fun KtClassOrObject.effectiveDeclarations(): List<KtDeclaration> {
     return when(this) {
-        is JetClass -> getDeclarations() + getPrimaryConstructorParameters().filter { p -> p.hasValOrVar() }
+        is KtClass -> getDeclarations() + getPrimaryConstructorParameters().filter { p -> p.hasValOrVar() }
         else -> getDeclarations()
     }
 }
 
-public fun JetDeclaration.isExtensionDeclaration(): Boolean {
-    val callable: JetCallableDeclaration? = when (this) {
-        is JetNamedFunction, is JetProperty -> this as JetCallableDeclaration
-        is JetPropertyAccessor -> getNonStrictParentOfType<JetProperty>()
+public fun KtDeclaration.isExtensionDeclaration(): Boolean {
+    val callable: KtCallableDeclaration? = when (this) {
+        is KtNamedFunction, is KtProperty -> this as KtCallableDeclaration
+        is KtPropertyAccessor -> getNonStrictParentOfType<KtProperty>()
         else -> null
     }
 
     return callable?.getReceiverTypeReference() != null
 }
 
-public fun JetClassOrObject.isObjectLiteral(): Boolean = this is JetObjectDeclaration && isObjectLiteral()
+public fun KtClassOrObject.isObjectLiteral(): Boolean = this is KtObjectDeclaration && isObjectLiteral()
 
 //TODO: strange method, and not only Kotlin specific (also Java)
 public fun PsiElement.parameterIndex(): Int {
     val parent = getParent()
     return when {
-        this is JetParameter && parent is JetParameterList -> parent.getParameters().indexOf(this)
+        this is KtParameter && parent is KtParameterList -> parent.getParameters().indexOf(this)
         this is PsiParameter && parent is PsiParameterList -> parent.getParameterIndex(this)
         else -> -1
     }
 }
 
-public fun JetModifierListOwner.isPrivate(): Boolean = hasModifier(JetTokens.PRIVATE_KEYWORD)
+public fun KtModifierListOwner.isPrivate(): Boolean = hasModifier(KtTokens.PRIVATE_KEYWORD)
 
-public fun JetSimpleNameExpression.isImportDirectiveExpression(): Boolean {
+public fun KtSimpleNameExpression.isImportDirectiveExpression(): Boolean {
     val parent = getParent()
-    return parent is JetImportDirective || parent?.getParent() is JetImportDirective
+    return parent is KtImportDirective || parent?.getParent() is KtImportDirective
 }
 
-public fun JetSimpleNameExpression.isPackageDirectiveExpression(): Boolean {
+public fun KtSimpleNameExpression.isPackageDirectiveExpression(): Boolean {
     val parent = getParent()
-    return parent is JetPackageDirective || parent?.getParent() is JetPackageDirective
+    return parent is KtPackageDirective || parent?.getParent() is KtPackageDirective
 }
 
-public fun JetExpression.isFunctionLiteralOutsideParentheses(): Boolean {
+public fun KtExpression.isFunctionLiteralOutsideParentheses(): Boolean {
     val parent = getParent()
     return when (parent) {
-        is JetFunctionLiteralArgument -> true
-        is JetLabeledExpression -> parent.isFunctionLiteralOutsideParentheses()
+        is KtFunctionLiteralArgument -> true
+        is KtLabeledExpression -> parent.isFunctionLiteralOutsideParentheses()
         else -> false
     }
 }
 
-public fun JetExpression.getAssignmentByLHS(): JetBinaryExpression? {
-    val parent = getParent() as? JetBinaryExpression ?: return null
-    return if (JetPsiUtil.isAssignment(parent) && parent.getLeft() == this) parent else null
+public fun KtExpression.getAssignmentByLHS(): KtBinaryExpression? {
+    val parent = getParent() as? KtBinaryExpression ?: return null
+    return if (KtPsiUtil.isAssignment(parent) && parent.getLeft() == this) parent else null
 }
 
-public fun JetStringTemplateExpression.getContentRange(): TextRange {
+public fun KtStringTemplateExpression.getContentRange(): TextRange {
     val start = getNode().getFirstChildNode().getTextLength()
     val lastChild = getNode().getLastChildNode()
     val length = getTextLength()
-    return TextRange(start, if (lastChild.getElementType() == JetTokens.CLOSING_QUOTE) length - lastChild.getTextLength() else length)
+    return TextRange(start, if (lastChild.getElementType() == KtTokens.CLOSING_QUOTE) length - lastChild.getTextLength() else length)
 }
 
-public fun JetStringTemplateExpression.isSingleQuoted(): Boolean
+public fun KtStringTemplateExpression.isSingleQuoted(): Boolean
         = getNode().getFirstChildNode().getTextLength() == 1
 
-public fun JetNamedDeclaration.getValueParameters(): List<JetParameter> {
+public fun KtNamedDeclaration.getValueParameters(): List<KtParameter> {
     return getValueParameterList()?.getParameters() ?: Collections.emptyList()
 }
 
-public fun JetNamedDeclaration.getValueParameterList(): JetParameterList? {
+public fun KtNamedDeclaration.getValueParameterList(): KtParameterList? {
     return when (this) {
-        is JetCallableDeclaration -> getValueParameterList()
-        is JetClass -> getPrimaryConstructorParameterList()
+        is KtCallableDeclaration -> getValueParameterList()
+        is KtClass -> getPrimaryConstructorParameterList()
         else -> null
     }
 }
 
-public fun JetFunctionLiteralArgument.getFunctionLiteralArgumentName(bindingContext: BindingContext): Name? {
-    val callExpression = getParent() as JetCallExpression
+public fun KtFunctionLiteralArgument.getFunctionLiteralArgumentName(bindingContext: BindingContext): Name? {
+    val callExpression = getParent() as KtCallExpression
     val resolvedCall = callExpression.getResolvedCall(bindingContext)
     return (resolvedCall?.getArgumentMapping(this) as? ArgumentMatch)?.valueParameter?.getName()
 }
 
-public fun JetExpression.asAssignment(): JetBinaryExpression? =
-        if (JetPsiUtil.isAssignment(this)) this as JetBinaryExpression else null
+public fun KtExpression.asAssignment(): KtBinaryExpression? =
+        if (KtPsiUtil.isAssignment(this)) this as KtBinaryExpression else null
 
-public fun JetDeclaration.visibilityModifier(): PsiElement? {
+public fun KtDeclaration.visibilityModifier(): PsiElement? {
     val modifierList = modifierList ?: return null
-    return JetTokens.VISIBILITY_MODIFIERS.types
+    return KtTokens.VISIBILITY_MODIFIERS.types
                    .asSequence()
-                   .map { modifierList.getModifier(it as JetModifierKeywordToken) }
+                   .map { modifierList.getModifier(it as KtModifierKeywordToken) }
                    .firstOrNull { it != null }
 }
 
-public fun JetDeclaration.visibilityModifierType(): JetModifierKeywordToken?
-        = visibilityModifier()?.node?.elementType as JetModifierKeywordToken?
+public fun KtDeclaration.visibilityModifierType(): KtModifierKeywordToken?
+        = visibilityModifier()?.node?.elementType as KtModifierKeywordToken?
 
-public fun JetStringTemplateExpression.isPlain() = entries.all { it is JetLiteralStringTemplateEntry }
\ No newline at end of file
+public fun KtStringTemplateExpression.isPlain() = entries.all { it is KtLiteralStringTemplateEntry }
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/StubInterfaces.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/StubInterfaces.kt
index 4840377a248..2972239b1c5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/StubInterfaces.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/StubInterfaces.kt
@@ -21,53 +21,53 @@ import com.intellij.psi.stubs.NamedStub
 import org.jetbrains.kotlin.name.FqName
 import com.intellij.psi.stubs.StubElement
 import com.intellij.psi.stubs.PsiFileStub
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.psi.*
 
-public interface KotlinFileStub : PsiFileStub<JetFile> {
+public interface KotlinFileStub : PsiFileStub<KtFile> {
     public fun getPackageFqName(): FqName
     public fun isScript(): Boolean
     public fun findImportsByAlias(alias: String): List<KotlinImportDirectiveStub>
 }
 
-public interface KotlinPlaceHolderStub<T : JetElement> : StubElement<T>
+public interface KotlinPlaceHolderStub<T : KtElement> : StubElement<T>
 
 public interface KotlinStubWithFqName<T : PsiNamedElement> : NamedStub<T> {
     public fun getFqName(): FqName?
 }
 
-public interface KotlinClassOrObjectStub<T : JetClassOrObject> : KotlinStubWithFqName<T> {
+public interface KotlinClassOrObjectStub<T : KtClassOrObject> : KotlinStubWithFqName<T> {
     public fun isLocal(): Boolean
     public fun getSuperNames(): List<String>
     public fun isTopLevel(): Boolean
 }
 
-public interface KotlinClassStub : KotlinClassOrObjectStub<JetClass> {
+public interface KotlinClassStub : KotlinClassOrObjectStub<KtClass> {
     public fun isInterface(): Boolean
     public fun isEnumEntry(): Boolean
 }
 
-public interface KotlinObjectStub : KotlinClassOrObjectStub<JetObjectDeclaration> {
+public interface KotlinObjectStub : KotlinClassOrObjectStub<KtObjectDeclaration> {
     public fun isCompanion(): Boolean
     public fun isObjectLiteral(): Boolean
 }
 
-public interface KotlinAnnotationEntryStub : StubElement<JetAnnotationEntry> {
+public interface KotlinAnnotationEntryStub : StubElement<KtAnnotationEntry> {
     public fun getShortName(): String
     public fun hasValueArguments(): Boolean
 }
 
-public interface KotlinAnnotationUseSiteTargetStub : StubElement<JetAnnotationUseSiteTarget> {
+public interface KotlinAnnotationUseSiteTargetStub : StubElement<KtAnnotationUseSiteTarget> {
     public fun getUseSiteTarget(): String
 }
 
-public interface KotlinFunctionStub : KotlinCallableStubBase<JetNamedFunction> {
+public interface KotlinFunctionStub : KotlinCallableStubBase<KtNamedFunction> {
     public fun hasBlockBody(): Boolean
     public fun hasBody(): Boolean
     public fun hasTypeParameterListBeforeFunctionName(): Boolean
 }
 
-public interface KotlinImportDirectiveStub : StubElement<JetImportDirective> {
+public interface KotlinImportDirectiveStub : StubElement<KtImportDirective> {
     public fun isAbsoluteInRootPackage(): Boolean
     public fun isAllUnder(): Boolean
     public fun getImportedFqName(): FqName?
@@ -75,31 +75,31 @@ public interface KotlinImportDirectiveStub : StubElement<JetImportDirective> {
     public fun isValid(): Boolean
 }
 
-public interface KotlinModifierListStub : StubElement<JetModifierList> {
-    public fun hasModifier(modifierToken: JetModifierKeywordToken): Boolean
+public interface KotlinModifierListStub : StubElement<KtModifierList> {
+    public fun hasModifier(modifierToken: KtModifierKeywordToken): Boolean
 }
 
-public interface KotlinNameReferenceExpressionStub : StubElement<JetNameReferenceExpression> {
+public interface KotlinNameReferenceExpressionStub : StubElement<KtNameReferenceExpression> {
     public fun getReferencedName(): String
 }
 
-public interface KotlinEnumEntrySuperclassReferenceExpressionStub : StubElement<JetEnumEntrySuperclassReferenceExpression> {
+public interface KotlinEnumEntrySuperclassReferenceExpressionStub : StubElement<KtEnumEntrySuperclassReferenceExpression> {
     public fun getReferencedName(): String
 }
 
-public interface KotlinParameterStub : KotlinStubWithFqName<JetParameter> {
+public interface KotlinParameterStub : KotlinStubWithFqName<KtParameter> {
     public fun isMutable(): Boolean
     public fun hasValOrVar(): Boolean
     public fun hasDefaultValue(): Boolean
 }
 
-public interface KotlinPropertyAccessorStub : StubElement<JetPropertyAccessor> {
+public interface KotlinPropertyAccessorStub : StubElement<KtPropertyAccessor> {
     public fun isGetter(): Boolean
     public fun hasBody(): Boolean
     public fun hasBlockBody(): Boolean
 }
 
-public interface KotlinPropertyStub : KotlinCallableStubBase<JetProperty> {
+public interface KotlinPropertyStub : KotlinCallableStubBase<KtProperty> {
     public fun isVar(): Boolean
     public fun hasDelegate(): Boolean
     public fun hasDelegateExpression(): Boolean
@@ -107,20 +107,20 @@ public interface KotlinPropertyStub : KotlinCallableStubBase<JetProperty> {
     public fun hasReturnTypeRef(): Boolean
 }
 
-public interface KotlinCallableStubBase<TDeclaration: JetCallableDeclaration> : KotlinStubWithFqName<TDeclaration> {
+public interface KotlinCallableStubBase<TDeclaration: KtCallableDeclaration> : KotlinStubWithFqName<TDeclaration> {
     public fun isTopLevel(): Boolean
     public fun isExtension(): Boolean
 }
 
-public interface KotlinTypeParameterStub : KotlinStubWithFqName<JetTypeParameter> {
+public interface KotlinTypeParameterStub : KotlinStubWithFqName<KtTypeParameter> {
     public fun isInVariance(): Boolean
     public fun isOutVariance(): Boolean
 }
 
-public interface KotlinTypeProjectionStub : StubElement<JetTypeProjection> {
-    public fun getProjectionKind(): JetProjectionKind
+public interface KotlinTypeProjectionStub : StubElement<KtTypeProjection> {
+    public fun getProjectionKind(): KtProjectionKind
 }
 
-public interface KotlinUserTypeStub : StubElement<JetUserType> {
+public interface KotlinUserTypeStub : StubElement<KtUserType> {
     public fun isAbsoluteInRootPackage(): Boolean
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetStubElementTypes.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetStubElementTypes.java
deleted file mode 100644
index 637cddd8d1d..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetStubElementTypes.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.psi.stubs.elements;
-
-import com.intellij.psi.tree.TokenSet;
-import org.jetbrains.kotlin.psi.*;
-
-import static org.jetbrains.kotlin.JetNodeTypes.SELF_TYPE;
-
-public interface JetStubElementTypes {
-    JetFileElementType FILE = new JetFileElementType();
-
-    JetClassElementType CLASS = new JetClassElementType("CLASS");
-    JetFunctionElementType FUNCTION = new JetFunctionElementType("FUN");
-    JetPropertyElementType PROPERTY = new JetPropertyElementType("PROPERTY");
-    JetPropertyAccessorElementType PROPERTY_ACCESSOR = new JetPropertyAccessorElementType("PROPERTY_ACCESSOR");
-
-    JetClassElementType ENUM_ENTRY = new JetClassElementType("ENUM_ENTRY");
-    JetObjectElementType OBJECT_DECLARATION = new JetObjectElementType("OBJECT_DECLARATION");
-    JetPlaceHolderStubElementType<JetClassInitializer> ANONYMOUS_INITIALIZER =
-            new JetPlaceHolderStubElementType<JetClassInitializer>("ANONYMOUS_INITIALIZER", JetClassInitializer.class);
-    JetPlaceHolderStubElementType<JetSecondaryConstructor> SECONDARY_CONSTRUCTOR =
-            new JetPlaceHolderStubElementType<JetSecondaryConstructor>("SECONDARY_CONSTRUCTOR", JetSecondaryConstructor.class);
-    JetPlaceHolderStubElementType<JetPrimaryConstructor> PRIMARY_CONSTRUCTOR =
-            new JetPlaceHolderStubElementType<JetPrimaryConstructor>("PRIMARY_CONSTRUCTOR", JetPrimaryConstructor.class);
-
-    JetParameterElementType VALUE_PARAMETER = new JetParameterElementType("VALUE_PARAMETER");
-    JetPlaceHolderStubElementType<JetParameterList> VALUE_PARAMETER_LIST =
-            new JetPlaceHolderStubElementType<JetParameterList>("VALUE_PARAMETER_LIST", JetParameterList.class);
-
-    JetTypeParameterElementType TYPE_PARAMETER = new JetTypeParameterElementType("TYPE_PARAMETER");
-    JetPlaceHolderStubElementType<JetTypeParameterList> TYPE_PARAMETER_LIST =
-            new JetPlaceHolderStubElementType<JetTypeParameterList>("TYPE_PARAMETER_LIST", JetTypeParameterList.class);
-
-    JetAnnotationEntryElementType ANNOTATION_ENTRY = new JetAnnotationEntryElementType("ANNOTATION_ENTRY");
-    JetPlaceHolderStubElementType<JetAnnotation> ANNOTATION =
-            new JetPlaceHolderStubElementType<JetAnnotation>("ANNOTATION", JetAnnotation.class);
-
-    JetAnnotationUseSiteTargetElementType ANNOTATION_TARGET = new JetAnnotationUseSiteTargetElementType("ANNOTATION_TARGET");
-
-    JetPlaceHolderStubElementType<JetClassBody> CLASS_BODY =
-            new JetPlaceHolderStubElementType<JetClassBody>("CLASS_BODY", JetClassBody.class);
-
-    JetPlaceHolderStubElementType<JetImportList> IMPORT_LIST =
-            new JetPlaceHolderStubElementType<JetImportList>("IMPORT_LIST", JetImportList.class);
-
-    JetPlaceHolderStubElementType<JetFileAnnotationList> FILE_ANNOTATION_LIST =
-            new JetPlaceHolderStubElementType<JetFileAnnotationList>("FILE_ANNOTATION_LIST", JetFileAnnotationList.class);
-
-    JetImportDirectiveElementType IMPORT_DIRECTIVE = new JetImportDirectiveElementType("IMPORT_DIRECTIVE");
-
-    JetPlaceHolderStubElementType<JetPackageDirective> PACKAGE_DIRECTIVE =
-            new JetPlaceHolderStubElementType<JetPackageDirective>("PACKAGE_DIRECTIVE", JetPackageDirective.class);
-
-    JetModifierListElementType<JetDeclarationModifierList> MODIFIER_LIST =
-            new JetModifierListElementType<JetDeclarationModifierList>("MODIFIER_LIST", JetDeclarationModifierList.class);
-
-    JetPlaceHolderStubElementType<JetTypeConstraintList> TYPE_CONSTRAINT_LIST =
-            new JetPlaceHolderStubElementType<JetTypeConstraintList>("TYPE_CONSTRAINT_LIST", JetTypeConstraintList.class);
-
-    JetPlaceHolderStubElementType<JetTypeConstraint> TYPE_CONSTRAINT =
-            new JetPlaceHolderStubElementType<JetTypeConstraint>("TYPE_CONSTRAINT", JetTypeConstraint.class);
-
-    JetPlaceHolderStubElementType<JetNullableType> NULLABLE_TYPE =
-            new JetPlaceHolderStubElementType<JetNullableType>("NULLABLE_TYPE", JetNullableType.class);
-
-    JetPlaceHolderStubElementType<JetTypeReference> TYPE_REFERENCE =
-            new JetPlaceHolderStubElementType<JetTypeReference>("TYPE_REFERENCE", JetTypeReference.class);
-
-    JetUserTypeElementType USER_TYPE = new JetUserTypeElementType("USER_TYPE");
-    JetPlaceHolderStubElementType<JetDynamicType> DYNAMIC_TYPE =
-            new JetPlaceHolderStubElementType<JetDynamicType>("DYNAMIC_TYPE", JetDynamicType.class);
-
-    JetPlaceHolderStubElementType<JetFunctionType> FUNCTION_TYPE =
-            new JetPlaceHolderStubElementType<JetFunctionType>("FUNCTION_TYPE", JetFunctionType.class);
-
-    JetTypeProjectionElementType TYPE_PROJECTION = new JetTypeProjectionElementType("TYPE_PROJECTION");
-
-    JetPlaceHolderStubElementType<JetFunctionTypeReceiver> FUNCTION_TYPE_RECEIVER =
-            new JetPlaceHolderStubElementType<JetFunctionTypeReceiver>("FUNCTION_TYPE_RECEIVER", JetFunctionTypeReceiver.class);
-
-    JetNameReferenceExpressionElementType REFERENCE_EXPRESSION = new JetNameReferenceExpressionElementType("REFERENCE_EXPRESSION");
-    JetDotQualifiedExpressionElementType DOT_QUALIFIED_EXPRESSION = new JetDotQualifiedExpressionElementType("DOT_QUALIFIED_EXPRESSION");
-    JetEnumEntrySuperClassReferenceExpressionElementType
-            ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION = new JetEnumEntrySuperClassReferenceExpressionElementType("ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION");
-    JetPlaceHolderStubElementType<JetTypeArgumentList> TYPE_ARGUMENT_LIST =
-            new JetPlaceHolderStubElementType<JetTypeArgumentList>("TYPE_ARGUMENT_LIST", JetTypeArgumentList.class);
-
-    JetPlaceHolderStubElementType<JetDelegationSpecifierList> DELEGATION_SPECIFIER_LIST =
-            new JetPlaceHolderStubElementType<JetDelegationSpecifierList>("DELEGATION_SPECIFIER_LIST", JetDelegationSpecifierList.class);
-
-    JetPlaceHolderStubElementType<JetInitializerList> INITIALIZER_LIST =
-            new JetPlaceHolderStubElementType<JetInitializerList>("INITIALIZER_LIST", JetInitializerList.class);
-
-    JetPlaceHolderStubElementType<JetDelegatorByExpressionSpecifier> DELEGATOR_BY =
-            new JetPlaceHolderStubElementType<JetDelegatorByExpressionSpecifier>("DELEGATOR_BY", JetDelegatorByExpressionSpecifier.class);
-
-    JetPlaceHolderStubElementType<JetDelegatorToSuperCall> DELEGATOR_SUPER_CALL =
-            new JetPlaceHolderStubElementType<JetDelegatorToSuperCall>("DELEGATOR_SUPER_CALL", JetDelegatorToSuperCall.class);
-    JetPlaceHolderStubElementType<JetDelegatorToSuperClass> DELEGATOR_SUPER_CLASS =
-            new JetPlaceHolderStubElementType<JetDelegatorToSuperClass>("DELEGATOR_SUPER_CLASS", JetDelegatorToSuperClass.class);
-    JetPlaceHolderStubElementType<JetConstructorCalleeExpression> CONSTRUCTOR_CALLEE =
-            new JetPlaceHolderStubElementType<JetConstructorCalleeExpression>("CONSTRUCTOR_CALLEE", JetConstructorCalleeExpression.class);
-
-    TokenSet DECLARATION_TYPES =
-            TokenSet.create(CLASS, OBJECT_DECLARATION, FUNCTION, PROPERTY, ANONYMOUS_INITIALIZER, SECONDARY_CONSTRUCTOR, ENUM_ENTRY);
-
-    TokenSet DELEGATION_SPECIFIER_TYPES = TokenSet.create(DELEGATOR_BY, DELEGATOR_SUPER_CALL, DELEGATOR_SUPER_CLASS);
-
-    TokenSet TYPE_ELEMENT_TYPES = TokenSet.create(USER_TYPE, NULLABLE_TYPE, FUNCTION_TYPE, DYNAMIC_TYPE, SELF_TYPE);
-
-    TokenSet INSIDE_DIRECTIVE_EXPRESSIONS = TokenSet.create(REFERENCE_EXPRESSION, DOT_QUALIFIED_EXPRESSION);
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetAnnotationEntryElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtAnnotationEntryElementType.java
similarity index 80%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetAnnotationEntryElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtAnnotationEntryElementType.java
index 35ce4b1ee71..dc17dd24546 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetAnnotationEntryElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtAnnotationEntryElementType.java
@@ -23,23 +23,23 @@ import com.intellij.psi.stubs.StubOutputStream;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetAnnotationEntry;
-import org.jetbrains.kotlin.psi.JetPsiUtil;
+import org.jetbrains.kotlin.psi.KtAnnotationEntry;
+import org.jetbrains.kotlin.psi.KtPsiUtil;
 import org.jetbrains.kotlin.psi.stubs.KotlinAnnotationEntryStub;
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinAnnotationEntryStubImpl;
 import org.jetbrains.kotlin.name.Name;
 
 import java.io.IOException;
 
-public class JetAnnotationEntryElementType extends JetStubElementType<KotlinAnnotationEntryStub, JetAnnotationEntry> {
+public class KtAnnotationEntryElementType extends KtStubElementType<KotlinAnnotationEntryStub, KtAnnotationEntry> {
 
-    public JetAnnotationEntryElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetAnnotationEntry.class, KotlinAnnotationEntryStub.class);
+    public KtAnnotationEntryElementType(@NotNull @NonNls String debugName) {
+        super(debugName, KtAnnotationEntry.class, KotlinAnnotationEntryStub.class);
     }
 
     @Override
-    public KotlinAnnotationEntryStub createStub(@NotNull JetAnnotationEntry psi, StubElement parentStub) {
-        Name shortName = JetPsiUtil.getShortName(psi);
+    public KotlinAnnotationEntryStub createStub(@NotNull KtAnnotationEntry psi, StubElement parentStub) {
+        Name shortName = KtPsiUtil.getShortName(psi);
         String resultName = shortName != null ? shortName.asString() : psi.getText();
         boolean hasValueArguments = psi.getValueArgumentList() != null;
         return new KotlinAnnotationEntryStubImpl(parentStub, StringRef.fromString(resultName), hasValueArguments);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetAnnotationUseSiteTargetElementType.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtAnnotationUseSiteTargetElementType.kt
similarity index 78%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetAnnotationUseSiteTargetElementType.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtAnnotationUseSiteTargetElementType.kt
index 4cfd33022c1..9e5118fff87 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetAnnotationUseSiteTargetElementType.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtAnnotationUseSiteTargetElementType.kt
@@ -21,15 +21,15 @@ import com.intellij.psi.stubs.StubElement
 import com.intellij.psi.stubs.StubInputStream
 import com.intellij.psi.stubs.StubOutputStream
 import com.intellij.util.io.StringRef
-import org.jetbrains.kotlin.psi.JetAnnotationUseSiteTarget
+import org.jetbrains.kotlin.psi.KtAnnotationUseSiteTarget
 import org.jetbrains.kotlin.psi.stubs.KotlinAnnotationUseSiteTargetStub
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinAnnotationUseSiteTargetStubImpl
 
-public class JetAnnotationUseSiteTargetElementType(debugName: String) : JetStubElementType<KotlinAnnotationUseSiteTargetStub, JetAnnotationUseSiteTarget>(
-        debugName, javaClass<JetAnnotationUseSiteTarget>(), javaClass<KotlinAnnotationUseSiteTargetStub>()
+public class KtAnnotationUseSiteTargetElementType(debugName: String) : KtStubElementType<KotlinAnnotationUseSiteTargetStub, KtAnnotationUseSiteTarget>(
+        debugName, javaClass<KtAnnotationUseSiteTarget>(), javaClass<KotlinAnnotationUseSiteTargetStub>()
 ) {
 
-    override fun createStub(psi: JetAnnotationUseSiteTarget, parentStub: StubElement<PsiElement>): KotlinAnnotationUseSiteTargetStub {
+    override fun createStub(psi: KtAnnotationUseSiteTarget, parentStub: StubElement<PsiElement>): KotlinAnnotationUseSiteTargetStub {
         val useSiteTarget = psi.getAnnotationUseSiteTarget().name()
         return KotlinAnnotationUseSiteTargetStubImpl(parentStub, StringRef.fromString(useSiteTarget)!!)
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetClassElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtClassElementType.java
similarity index 79%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetClassElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtClassElementType.java
index 4e36789eb5d..2a6c21f3680 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetClassElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtClassElementType.java
@@ -25,8 +25,8 @@ import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetClass;
-import org.jetbrains.kotlin.psi.JetEnumEntry;
+import org.jetbrains.kotlin.psi.KtClass;
+import org.jetbrains.kotlin.psi.KtEnumEntry;
 import org.jetbrains.kotlin.psi.psiUtil.JetPsiUtilKt;
 import org.jetbrains.kotlin.psi.stubs.KotlinClassStub;
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinClassStubImpl;
@@ -36,27 +36,27 @@ import org.jetbrains.kotlin.resolve.lazy.ResolveSessionUtils;
 import java.io.IOException;
 import java.util.List;
 
-public class JetClassElementType extends JetStubElementType<KotlinClassStub, JetClass> {
-    public JetClassElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetClass.class, KotlinClassStub.class);
+public class KtClassElementType extends KtStubElementType<KotlinClassStub, KtClass> {
+    public KtClassElementType(@NotNull @NonNls String debugName) {
+        super(debugName, KtClass.class, KotlinClassStub.class);
     }
 
     @NotNull
     @Override
-    public JetClass createPsi(@NotNull KotlinClassStub stub) {
-        return !stub.isEnumEntry() ? new JetClass(stub) : new JetEnumEntry(stub);
+    public KtClass createPsi(@NotNull KotlinClassStub stub) {
+        return !stub.isEnumEntry() ? new KtClass(stub) : new KtEnumEntry(stub);
     }
 
     @NotNull
     @Override
-    public JetClass createPsiFromAst(@NotNull ASTNode node) {
-        return node.getElementType() != JetStubElementTypes.ENUM_ENTRY ? new JetClass(node) : new JetEnumEntry(node);
+    public KtClass createPsiFromAst(@NotNull ASTNode node) {
+        return node.getElementType() != KtStubElementTypes.ENUM_ENTRY ? new KtClass(node) : new KtEnumEntry(node);
     }
 
     @Override
-    public KotlinClassStub createStub(@NotNull JetClass psi, StubElement parentStub) {
+    public KotlinClassStub createStub(@NotNull KtClass psi, StubElement parentStub) {
         FqName fqName = ResolveSessionUtils.safeFqNameForLazyResolve(psi);
-        boolean isEnumEntry = psi instanceof JetEnumEntry;
+        boolean isEnumEntry = psi instanceof KtEnumEntry;
         List<String> superNames = JetPsiUtilKt.getSuperNames(psi);
         return new KotlinClassStubImpl(
                 getStubType(isEnumEntry), parentStub, StringRef.fromString(fqName != null ? fqName.asString() : null),
@@ -106,7 +106,7 @@ public class JetClassElementType extends JetStubElementType<KotlinClassStub, Jet
         StubIndexService.getInstance().indexClass(stub, sink);
     }
 
-    public static JetClassElementType getStubType(boolean isEnumEntry) {
-        return isEnumEntry ? JetStubElementTypes.ENUM_ENTRY : JetStubElementTypes.CLASS;
+    public static KtClassElementType getStubType(boolean isEnumEntry) {
+        return isEnumEntry ? KtStubElementTypes.ENUM_ENTRY : KtStubElementTypes.CLASS;
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetDotQualifiedExpressionElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtDotQualifiedExpressionElementType.java
similarity index 62%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetDotQualifiedExpressionElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtDotQualifiedExpressionElementType.java
index 2628f8d6ef3..5cad987eb4b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetDotQualifiedExpressionElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtDotQualifiedExpressionElementType.java
@@ -20,17 +20,17 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetDotQualifiedExpression;
-import org.jetbrains.kotlin.psi.JetImportDirective;
-import org.jetbrains.kotlin.psi.JetPackageDirective;
+import org.jetbrains.kotlin.psi.KtDotQualifiedExpression;
+import org.jetbrains.kotlin.psi.KtImportDirective;
+import org.jetbrains.kotlin.psi.KtPackageDirective;
 
-public class JetDotQualifiedExpressionElementType extends JetPlaceHolderStubElementType<JetDotQualifiedExpression> {
-    public JetDotQualifiedExpressionElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetDotQualifiedExpression.class);
+public class KtDotQualifiedExpressionElementType extends KtPlaceHolderStubElementType<KtDotQualifiedExpression> {
+    public KtDotQualifiedExpressionElementType(@NotNull @NonNls String debugName) {
+        super(debugName, KtDotQualifiedExpression.class);
     }
 
     @Override
     public boolean shouldCreateStub(ASTNode node) {
-        return PsiTreeUtil.getParentOfType(node.getPsi(), JetImportDirective.class, JetPackageDirective.class) != null;
+        return PsiTreeUtil.getParentOfType(node.getPsi(), KtImportDirective.class, KtPackageDirective.class) != null;
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetEnumEntrySuperClassReferenceExpressionElementType.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtEnumEntrySuperClassReferenceExpressionElementType.kt
similarity index 77%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetEnumEntrySuperClassReferenceExpressionElementType.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtEnumEntrySuperClassReferenceExpressionElementType.kt
index f0c14195c4f..14113938f8c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetEnumEntrySuperClassReferenceExpressionElementType.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtEnumEntrySuperClassReferenceExpressionElementType.kt
@@ -21,18 +21,18 @@ import com.intellij.psi.stubs.StubInputStream
 import com.intellij.psi.stubs.StubOutputStream
 import com.intellij.util.io.StringRef
 import org.jetbrains.annotations.NonNls
-import org.jetbrains.kotlin.psi.JetEnumEntrySuperclassReferenceExpression
+import org.jetbrains.kotlin.psi.KtEnumEntrySuperclassReferenceExpression
 import org.jetbrains.kotlin.psi.stubs.KotlinEnumEntrySuperclassReferenceExpressionStub
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinEnumEntrySuperclassReferenceExpressionStubImpl
 
-public class JetEnumEntrySuperClassReferenceExpressionElementType(@NonNls debugName: String)
-    : JetStubElementType<KotlinEnumEntrySuperclassReferenceExpressionStub, JetEnumEntrySuperclassReferenceExpression>(
+public class KtEnumEntrySuperClassReferenceExpressionElementType(@NonNls debugName: String)
+    : KtStubElementType<KotlinEnumEntrySuperclassReferenceExpressionStub, KtEnumEntrySuperclassReferenceExpression>(
         debugName,
-        javaClass<JetEnumEntrySuperclassReferenceExpression>(),
+        javaClass<KtEnumEntrySuperclassReferenceExpression>(),
         javaClass<KotlinEnumEntrySuperclassReferenceExpressionStub>()
     ) {
 
-    override fun createStub(psi: JetEnumEntrySuperclassReferenceExpression, parentStub: StubElement<*>): KotlinEnumEntrySuperclassReferenceExpressionStub {
+    override fun createStub(psi: KtEnumEntrySuperclassReferenceExpression, parentStub: StubElement<*>): KotlinEnumEntrySuperclassReferenceExpressionStub {
         return KotlinEnumEntrySuperclassReferenceExpressionStubImpl(parentStub, StringRef.fromString(psi.getReferencedName())!!)
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFileElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtFileElementType.java
similarity index 93%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFileElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtFileElementType.java
index d57370c5bdf..1a0ac27b5e1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFileElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtFileElementType.java
@@ -33,22 +33,22 @@ import org.jetbrains.kotlin.psi.stubs.KotlinFileStub;
 
 import java.io.IOException;
 
-public class JetFileElementType extends IStubFileElementType<KotlinFileStub> {
+public class KtFileElementType extends IStubFileElementType<KotlinFileStub> {
     public static final int STUB_VERSION = 62;
 
     private static final String NAME = "kotlin.FILE";
 
-    public JetFileElementType() {
+    public KtFileElementType() {
         super(NAME, KotlinLanguage.INSTANCE);
     }
 
-    protected JetFileElementType(@NonNls String debugName) {
+    protected KtFileElementType(@NonNls String debugName) {
         super(debugName, KotlinLanguage.INSTANCE);
     }
 
     @Override
     public StubBuilder getBuilder() {
-        return new JetFileStubBuilder();
+        return new KtFileStubBuilder();
     }
 
     @Override
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFileStubBuilder.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtFileStubBuilder.java
similarity index 77%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFileStubBuilder.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtFileStubBuilder.java
index 8e711d288b9..5992006722d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFileStubBuilder.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtFileStubBuilder.java
@@ -20,17 +20,16 @@ import com.intellij.psi.PsiFile;
 import com.intellij.psi.stubs.DefaultStubBuilder;
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.stubs.impl.KotlinFileStubImpl;
+import org.jetbrains.kotlin.psi.KtFile;
 
-public class JetFileStubBuilder extends DefaultStubBuilder {
+public class KtFileStubBuilder extends DefaultStubBuilder {
     @NotNull
     @Override
     protected StubElement createStubForFile(@NotNull PsiFile file) {
-        if (!(file instanceof JetFile)) {
+        if (!(file instanceof KtFile)) {
             return super.createStubForFile(file);
         }
 
-        return StubIndexService.getInstance().createFileStub((JetFile) file);
+        return StubIndexService.getInstance().createFileStub((KtFile) file);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFunctionElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtFunctionElementType.java
similarity index 86%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFunctionElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtFunctionElementType.java
index 4a3c17a6af9..dddfd9603ec 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFunctionElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtFunctionElementType.java
@@ -24,23 +24,23 @@ import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
 import org.jetbrains.kotlin.psi.stubs.KotlinFunctionStub;
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinFunctionStubImpl;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSessionUtils;
 
 import java.io.IOException;
 
-public class JetFunctionElementType extends JetStubElementType<KotlinFunctionStub, JetNamedFunction> {
+public class KtFunctionElementType extends KtStubElementType<KotlinFunctionStub, KtNamedFunction> {
 
-    public JetFunctionElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetNamedFunction.class, KotlinFunctionStub.class);
+    public KtFunctionElementType(@NotNull @NonNls String debugName) {
+        super(debugName, KtNamedFunction.class, KotlinFunctionStub.class);
     }
 
     @Override
-    public KotlinFunctionStub createStub(@NotNull JetNamedFunction psi, @NotNull StubElement parentStub) {
-        boolean isTopLevel = psi.getParent() instanceof JetFile;
+    public KotlinFunctionStub createStub(@NotNull KtNamedFunction psi, @NotNull StubElement parentStub) {
+        boolean isTopLevel = psi.getParent() instanceof KtFile;
         boolean isExtension = psi.getReceiverTypeReference() != null;
         FqName fqName = ResolveSessionUtils.safeFqNameForLazyResolve(psi);
         boolean hasBlockBody = psi.hasBlockBody();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetImportDirectiveElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtImportDirectiveElementType.java
similarity index 85%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetImportDirectiveElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtImportDirectiveElementType.java
index 53898d168e6..8667dc86867 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetImportDirectiveElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtImportDirectiveElementType.java
@@ -23,19 +23,19 @@ import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetImportDirective;
+import org.jetbrains.kotlin.psi.KtImportDirective;
 import org.jetbrains.kotlin.psi.stubs.KotlinImportDirectiveStub;
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinImportDirectiveStubImpl;
 
 import java.io.IOException;
 
-public class JetImportDirectiveElementType extends JetStubElementType<KotlinImportDirectiveStub, JetImportDirective> {
-    public JetImportDirectiveElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetImportDirective.class, KotlinImportDirectiveStub.class);
+public class KtImportDirectiveElementType extends KtStubElementType<KotlinImportDirectiveStub, KtImportDirective> {
+    public KtImportDirectiveElementType(@NotNull @NonNls String debugName) {
+        super(debugName, KtImportDirective.class, KotlinImportDirectiveStub.class);
     }
 
     @Override
-    public KotlinImportDirectiveStub createStub(@NotNull JetImportDirective psi, StubElement parentStub) {
+    public KotlinImportDirectiveStub createStub(@NotNull KtImportDirective psi, StubElement parentStub) {
         FqName importedFqName = psi.getImportedFqName();
         StringRef fqName = StringRef.fromString(importedFqName == null ? null : importedFqName.asString());
         StringRef aliasName = StringRef.fromString(psi.getAliasName());
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetModifierListElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtModifierListElementType.java
similarity index 87%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetModifierListElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtModifierListElementType.java
index 9bf67beeafe..7c5eb64e0aa 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetModifierListElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtModifierListElementType.java
@@ -21,7 +21,7 @@ import com.intellij.psi.stubs.StubInputStream;
 import com.intellij.psi.stubs.StubOutputStream;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetModifierList;
+import org.jetbrains.kotlin.psi.KtModifierList;
 import org.jetbrains.kotlin.psi.stubs.KotlinModifierListStub;
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinModifierListStubImpl;
 
@@ -29,8 +29,8 @@ import java.io.IOException;
 
 import static org.jetbrains.kotlin.psi.stubs.impl.ModifierMaskUtils.computeMaskFromModifierList;
 
-public class JetModifierListElementType<T extends JetModifierList> extends JetStubElementType<KotlinModifierListStub, T> {
-    public JetModifierListElementType(@NotNull @NonNls String debugName, @NotNull Class<T> psiClass) {
+public class KtModifierListElementType<T extends KtModifierList> extends KtStubElementType<KotlinModifierListStub, T> {
+    public KtModifierListElementType(@NotNull @NonNls String debugName, @NotNull Class<T> psiClass) {
         super(debugName, psiClass, KotlinModifierListStub.class);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetNameReferenceExpressionElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtNameReferenceExpressionElementType.java
similarity index 80%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetNameReferenceExpressionElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtNameReferenceExpressionElementType.java
index b50f938232b..3b82c005eed 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetNameReferenceExpressionElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtNameReferenceExpressionElementType.java
@@ -22,19 +22,19 @@ import com.intellij.psi.stubs.StubOutputStream;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetNameReferenceExpression;
+import org.jetbrains.kotlin.psi.KtNameReferenceExpression;
 import org.jetbrains.kotlin.psi.stubs.KotlinNameReferenceExpressionStub;
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinNameReferenceExpressionStubImpl;
 
 import java.io.IOException;
 
-public class JetNameReferenceExpressionElementType extends JetStubElementType<KotlinNameReferenceExpressionStub, JetNameReferenceExpression> {
-    public JetNameReferenceExpressionElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetNameReferenceExpression.class, KotlinNameReferenceExpressionStub.class);
+public class KtNameReferenceExpressionElementType extends KtStubElementType<KotlinNameReferenceExpressionStub, KtNameReferenceExpression> {
+    public KtNameReferenceExpressionElementType(@NotNull @NonNls String debugName) {
+        super(debugName, KtNameReferenceExpression.class, KotlinNameReferenceExpressionStub.class);
     }
 
     @Override
-    public KotlinNameReferenceExpressionStub createStub(@NotNull JetNameReferenceExpression psi, StubElement parentStub) {
+    public KotlinNameReferenceExpressionStub createStub(@NotNull KtNameReferenceExpression psi, StubElement parentStub) {
         return new KotlinNameReferenceExpressionStubImpl(parentStub, StringRef.fromString(psi.getReferencedName()));
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetObjectElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtObjectElementType.java
similarity index 89%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetObjectElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtObjectElementType.java
index a8315c0d5cf..6e8e6e920f7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetObjectElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtObjectElementType.java
@@ -24,7 +24,7 @@ import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetObjectDeclaration;
+import org.jetbrains.kotlin.psi.KtObjectDeclaration;
 import org.jetbrains.kotlin.psi.psiUtil.JetPsiUtilKt;
 import org.jetbrains.kotlin.psi.stubs.KotlinObjectStub;
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinObjectStubImpl;
@@ -34,13 +34,13 @@ import org.jetbrains.kotlin.resolve.lazy.ResolveSessionUtils;
 import java.io.IOException;
 import java.util.List;
 
-public class JetObjectElementType extends JetStubElementType<KotlinObjectStub, JetObjectDeclaration> {
-    public JetObjectElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetObjectDeclaration.class, KotlinObjectStub.class);
+public class KtObjectElementType extends KtStubElementType<KotlinObjectStub, KtObjectDeclaration> {
+    public KtObjectElementType(@NotNull @NonNls String debugName) {
+        super(debugName, KtObjectDeclaration.class, KotlinObjectStub.class);
     }
 
     @Override
-    public KotlinObjectStub createStub(@NotNull JetObjectDeclaration psi, StubElement parentStub) {
+    public KotlinObjectStub createStub(@NotNull KtObjectDeclaration psi, StubElement parentStub) {
         String name = psi.getName();
         FqName fqName = ResolveSessionUtils.safeFqNameForLazyResolve(psi);
         List<String> superNames = JetPsiUtilKt.getSuperNames(psi);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetParameterElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtParameterElementType.java
similarity index 86%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetParameterElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtParameterElementType.java
index 59080fc50d1..0d3be3752e6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetParameterElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtParameterElementType.java
@@ -22,20 +22,20 @@ import com.intellij.psi.stubs.StubOutputStream;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetParameter;
+import org.jetbrains.kotlin.psi.KtParameter;
 import org.jetbrains.kotlin.psi.stubs.KotlinParameterStub;
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinParameterStubImpl;
 import org.jetbrains.kotlin.name.FqName;
 
 import java.io.IOException;
 
-public class JetParameterElementType extends JetStubElementType<KotlinParameterStub, JetParameter> {
-    public JetParameterElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetParameter.class, KotlinParameterStub.class);
+public class KtParameterElementType extends KtStubElementType<KotlinParameterStub, KtParameter> {
+    public KtParameterElementType(@NotNull @NonNls String debugName) {
+        super(debugName, KtParameter.class, KotlinParameterStub.class);
     }
 
     @Override
-    public KotlinParameterStub createStub(@NotNull JetParameter psi, StubElement parentStub) {
+    public KotlinParameterStub createStub(@NotNull KtParameter psi, StubElement parentStub) {
         FqName fqName = psi.getFqName();
         StringRef fqNameRef = StringRef.fromString(fqName != null ? fqName.asString() : null);
         return new KotlinParameterStubImpl(parentStub, fqNameRef, StringRef.fromString(psi.getName()),
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetPlaceHolderStubElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtPlaceHolderStubElementType.java
similarity index 80%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetPlaceHolderStubElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtPlaceHolderStubElementType.java
index cfb805528c5..b79734d61ac 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetPlaceHolderStubElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtPlaceHolderStubElementType.java
@@ -21,15 +21,16 @@ import com.intellij.psi.stubs.StubInputStream;
 import com.intellij.psi.stubs.StubOutputStream;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetElementImplStub;
+import org.jetbrains.kotlin.psi.KtElementImplStub;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinPlaceHolderStubImpl;
 
 import java.io.IOException;
 
-public class JetPlaceHolderStubElementType<T extends JetElementImplStub<? extends StubElement<?>>> extends JetStubElementType<KotlinPlaceHolderStub<T>, T> {
+public class KtPlaceHolderStubElementType<T extends KtElementImplStub<? extends StubElement<?>>> extends
+                                                                                                 KtStubElementType<KotlinPlaceHolderStub<T>, T> {
 
-    public JetPlaceHolderStubElementType(@NotNull @NonNls String debugName, @NotNull Class<T> psiClass) {
+    public KtPlaceHolderStubElementType(@NotNull @NonNls String debugName, @NotNull Class<T> psiClass) {
         super(debugName, psiClass, KotlinPlaceHolderStub.class);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetPropertyAccessorElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtPropertyAccessorElementType.java
similarity index 80%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetPropertyAccessorElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtPropertyAccessorElementType.java
index fe8ce87f79a..ed33a41509f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetPropertyAccessorElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtPropertyAccessorElementType.java
@@ -21,19 +21,19 @@ import com.intellij.psi.stubs.StubInputStream;
 import com.intellij.psi.stubs.StubOutputStream;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetPropertyAccessor;
+import org.jetbrains.kotlin.psi.KtPropertyAccessor;
 import org.jetbrains.kotlin.psi.stubs.KotlinPropertyAccessorStub;
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinPropertyAccessorStubImpl;
 
 import java.io.IOException;
 
-public class JetPropertyAccessorElementType extends JetStubElementType<KotlinPropertyAccessorStub, JetPropertyAccessor> {
-    public JetPropertyAccessorElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetPropertyAccessor.class, KotlinPropertyAccessorStub.class);
+public class KtPropertyAccessorElementType extends KtStubElementType<KotlinPropertyAccessorStub, KtPropertyAccessor> {
+    public KtPropertyAccessorElementType(@NotNull @NonNls String debugName) {
+        super(debugName, KtPropertyAccessor.class, KotlinPropertyAccessorStub.class);
     }
 
     @Override
-    public KotlinPropertyAccessorStub createStub(@NotNull JetPropertyAccessor psi, StubElement parentStub) {
+    public KotlinPropertyAccessorStub createStub(@NotNull KtPropertyAccessor psi, StubElement parentStub) {
         return new KotlinPropertyAccessorStubImpl(parentStub, psi.isGetter(), psi.hasBody(), psi.hasBlockBody());
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetPropertyElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtPropertyElementType.java
similarity index 90%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetPropertyElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtPropertyElementType.java
index 458396d2933..fbad39d44a2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetPropertyElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtPropertyElementType.java
@@ -24,20 +24,20 @@ import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetProperty;
+import org.jetbrains.kotlin.psi.KtProperty;
 import org.jetbrains.kotlin.psi.stubs.KotlinPropertyStub;
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinPropertyStubImpl;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSessionUtils;
 
 import java.io.IOException;
 
-public class JetPropertyElementType extends JetStubElementType<KotlinPropertyStub, JetProperty> {
-    public JetPropertyElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetProperty.class, KotlinPropertyStub.class);
+public class KtPropertyElementType extends KtStubElementType<KotlinPropertyStub, KtProperty> {
+    public KtPropertyElementType(@NotNull @NonNls String debugName) {
+        super(debugName, KtProperty.class, KotlinPropertyStub.class);
     }
 
     @Override
-    public KotlinPropertyStub createStub(@NotNull JetProperty psi, StubElement parentStub) {
+    public KotlinPropertyStub createStub(@NotNull KtProperty psi, StubElement parentStub) {
         assert !psi.isLocal() :
                 String.format("Should not store local property: %s, parent %s",
                               psi.getText(), psi.getParent() != null ? psi.getParent().getText() : "<no parent>");
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetStubElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtStubElementType.java
similarity index 84%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetStubElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtStubElementType.java
index 67b272c9531..2ebb997bfe5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetStubElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtStubElementType.java
@@ -28,15 +28,15 @@ import com.intellij.util.ReflectionUtil;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetElementImplStub;
-import org.jetbrains.kotlin.psi.JetFunction;
-import org.jetbrains.kotlin.psi.JetProperty;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtElementImplStub;
+import org.jetbrains.kotlin.psi.KtFunction;
+import org.jetbrains.kotlin.psi.KtProperty;
 
 import java.lang.reflect.Array;
 import java.lang.reflect.Constructor;
 
-public abstract class JetStubElementType<StubT extends StubElement, PsiT extends JetElementImplStub<?>> extends IStubElementType<StubT, PsiT> {
+public abstract class KtStubElementType<StubT extends StubElement, PsiT extends KtElementImplStub<?>> extends IStubElementType<StubT, PsiT> {
 
     @NotNull
     private final Constructor<PsiT> byNodeConstructor;
@@ -47,7 +47,7 @@ public abstract class JetStubElementType<StubT extends StubElement, PsiT extends
     @NotNull
     private final ArrayFactory<PsiT> arrayFactory;
 
-    public JetStubElementType(@NotNull @NonNls String debugName, @NotNull final Class<PsiT> psiClass, @NotNull Class<?> stubClass) {
+    public KtStubElementType(@NotNull @NonNls String debugName, @NotNull final Class<PsiT> psiClass, @NotNull Class<?> stubClass) {
         super(debugName, KotlinLanguage.INSTANCE);
         try {
             byNodeConstructor = psiClass.getConstructor(ASTNode.class);
@@ -91,14 +91,14 @@ public abstract class JetStubElementType<StubT extends StubElement, PsiT extends
     @Override
     public boolean shouldCreateStub(ASTNode node) {
         PsiElement psi = node.getPsi();
-        if (psi instanceof JetClassOrObject) {
+        if (psi instanceof KtClassOrObject) {
             return true;
         }
-        if (psi instanceof JetFunction) {
-            return !((JetFunction) psi).isLocal();
+        if (psi instanceof KtFunction) {
+            return !((KtFunction) psi).isLocal();
         }
-        if (psi instanceof JetProperty) {
-            return !((JetProperty) psi).isLocal();
+        if (psi instanceof KtProperty) {
+            return !((KtProperty) psi).isLocal();
         }
         return createStubDependingOnParent(node);
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtStubElementTypes.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtStubElementTypes.java
new file mode 100644
index 00000000000..93ac5c40b0d
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtStubElementTypes.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.psi.stubs.elements;
+
+import com.intellij.psi.tree.TokenSet;
+import org.jetbrains.kotlin.psi.*;
+
+import static org.jetbrains.kotlin.KtNodeTypes.SELF_TYPE;
+
+public interface KtStubElementTypes {
+    KtFileElementType FILE = new KtFileElementType();
+
+    KtClassElementType CLASS = new KtClassElementType("CLASS");
+    KtFunctionElementType FUNCTION = new KtFunctionElementType("FUN");
+    KtPropertyElementType PROPERTY = new KtPropertyElementType("PROPERTY");
+    KtPropertyAccessorElementType PROPERTY_ACCESSOR = new KtPropertyAccessorElementType("PROPERTY_ACCESSOR");
+
+    KtClassElementType ENUM_ENTRY = new KtClassElementType("ENUM_ENTRY");
+    KtObjectElementType OBJECT_DECLARATION = new KtObjectElementType("OBJECT_DECLARATION");
+    KtPlaceHolderStubElementType<KtClassInitializer> ANONYMOUS_INITIALIZER =
+            new KtPlaceHolderStubElementType<KtClassInitializer>("ANONYMOUS_INITIALIZER", KtClassInitializer.class);
+    KtPlaceHolderStubElementType<KtSecondaryConstructor> SECONDARY_CONSTRUCTOR =
+            new KtPlaceHolderStubElementType<KtSecondaryConstructor>("SECONDARY_CONSTRUCTOR", KtSecondaryConstructor.class);
+    KtPlaceHolderStubElementType<KtPrimaryConstructor> PRIMARY_CONSTRUCTOR =
+            new KtPlaceHolderStubElementType<KtPrimaryConstructor>("PRIMARY_CONSTRUCTOR", KtPrimaryConstructor.class);
+
+    KtParameterElementType VALUE_PARAMETER = new KtParameterElementType("VALUE_PARAMETER");
+    KtPlaceHolderStubElementType<KtParameterList> VALUE_PARAMETER_LIST =
+            new KtPlaceHolderStubElementType<KtParameterList>("VALUE_PARAMETER_LIST", KtParameterList.class);
+
+    KtTypeParameterElementType TYPE_PARAMETER = new KtTypeParameterElementType("TYPE_PARAMETER");
+    KtPlaceHolderStubElementType<KtTypeParameterList> TYPE_PARAMETER_LIST =
+            new KtPlaceHolderStubElementType<KtTypeParameterList>("TYPE_PARAMETER_LIST", KtTypeParameterList.class);
+
+    KtAnnotationEntryElementType ANNOTATION_ENTRY = new KtAnnotationEntryElementType("ANNOTATION_ENTRY");
+    KtPlaceHolderStubElementType<KtAnnotation> ANNOTATION =
+            new KtPlaceHolderStubElementType<KtAnnotation>("ANNOTATION", KtAnnotation.class);
+
+    KtAnnotationUseSiteTargetElementType ANNOTATION_TARGET = new KtAnnotationUseSiteTargetElementType("ANNOTATION_TARGET");
+
+    KtPlaceHolderStubElementType<KtClassBody> CLASS_BODY =
+            new KtPlaceHolderStubElementType<KtClassBody>("CLASS_BODY", KtClassBody.class);
+
+    KtPlaceHolderStubElementType<KtImportList> IMPORT_LIST =
+            new KtPlaceHolderStubElementType<KtImportList>("IMPORT_LIST", KtImportList.class);
+
+    KtPlaceHolderStubElementType<KtFileAnnotationList> FILE_ANNOTATION_LIST =
+            new KtPlaceHolderStubElementType<KtFileAnnotationList>("FILE_ANNOTATION_LIST", KtFileAnnotationList.class);
+
+    KtImportDirectiveElementType IMPORT_DIRECTIVE = new KtImportDirectiveElementType("IMPORT_DIRECTIVE");
+
+    KtPlaceHolderStubElementType<KtPackageDirective> PACKAGE_DIRECTIVE =
+            new KtPlaceHolderStubElementType<KtPackageDirective>("PACKAGE_DIRECTIVE", KtPackageDirective.class);
+
+    KtModifierListElementType<KtDeclarationModifierList> MODIFIER_LIST =
+            new KtModifierListElementType<KtDeclarationModifierList>("MODIFIER_LIST", KtDeclarationModifierList.class);
+
+    KtPlaceHolderStubElementType<KtTypeConstraintList> TYPE_CONSTRAINT_LIST =
+            new KtPlaceHolderStubElementType<KtTypeConstraintList>("TYPE_CONSTRAINT_LIST", KtTypeConstraintList.class);
+
+    KtPlaceHolderStubElementType<KtTypeConstraint> TYPE_CONSTRAINT =
+            new KtPlaceHolderStubElementType<KtTypeConstraint>("TYPE_CONSTRAINT", KtTypeConstraint.class);
+
+    KtPlaceHolderStubElementType<KtNullableType> NULLABLE_TYPE =
+            new KtPlaceHolderStubElementType<KtNullableType>("NULLABLE_TYPE", KtNullableType.class);
+
+    KtPlaceHolderStubElementType<KtTypeReference> TYPE_REFERENCE =
+            new KtPlaceHolderStubElementType<KtTypeReference>("TYPE_REFERENCE", KtTypeReference.class);
+
+    KtUserTypeElementType USER_TYPE = new KtUserTypeElementType("USER_TYPE");
+    KtPlaceHolderStubElementType<KtDynamicType> DYNAMIC_TYPE =
+            new KtPlaceHolderStubElementType<KtDynamicType>("DYNAMIC_TYPE", KtDynamicType.class);
+
+    KtPlaceHolderStubElementType<KtFunctionType> FUNCTION_TYPE =
+            new KtPlaceHolderStubElementType<KtFunctionType>("FUNCTION_TYPE", KtFunctionType.class);
+
+    KtTypeProjectionElementType TYPE_PROJECTION = new KtTypeProjectionElementType("TYPE_PROJECTION");
+
+    KtPlaceHolderStubElementType<KtFunctionTypeReceiver> FUNCTION_TYPE_RECEIVER =
+            new KtPlaceHolderStubElementType<KtFunctionTypeReceiver>("FUNCTION_TYPE_RECEIVER", KtFunctionTypeReceiver.class);
+
+    KtNameReferenceExpressionElementType REFERENCE_EXPRESSION = new KtNameReferenceExpressionElementType("REFERENCE_EXPRESSION");
+    KtDotQualifiedExpressionElementType DOT_QUALIFIED_EXPRESSION = new KtDotQualifiedExpressionElementType("DOT_QUALIFIED_EXPRESSION");
+    KtEnumEntrySuperClassReferenceExpressionElementType
+            ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION = new KtEnumEntrySuperClassReferenceExpressionElementType("ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION");
+    KtPlaceHolderStubElementType<KtTypeArgumentList> TYPE_ARGUMENT_LIST =
+            new KtPlaceHolderStubElementType<KtTypeArgumentList>("TYPE_ARGUMENT_LIST", KtTypeArgumentList.class);
+
+    KtPlaceHolderStubElementType<KtDelegationSpecifierList> DELEGATION_SPECIFIER_LIST =
+            new KtPlaceHolderStubElementType<KtDelegationSpecifierList>("DELEGATION_SPECIFIER_LIST", KtDelegationSpecifierList.class);
+
+    KtPlaceHolderStubElementType<KtInitializerList> INITIALIZER_LIST =
+            new KtPlaceHolderStubElementType<KtInitializerList>("INITIALIZER_LIST", KtInitializerList.class);
+
+    KtPlaceHolderStubElementType<KtDelegatorByExpressionSpecifier> DELEGATOR_BY =
+            new KtPlaceHolderStubElementType<KtDelegatorByExpressionSpecifier>("DELEGATOR_BY", KtDelegatorByExpressionSpecifier.class);
+
+    KtPlaceHolderStubElementType<KtDelegatorToSuperCall> DELEGATOR_SUPER_CALL =
+            new KtPlaceHolderStubElementType<KtDelegatorToSuperCall>("DELEGATOR_SUPER_CALL", KtDelegatorToSuperCall.class);
+    KtPlaceHolderStubElementType<KtDelegatorToSuperClass> DELEGATOR_SUPER_CLASS =
+            new KtPlaceHolderStubElementType<KtDelegatorToSuperClass>("DELEGATOR_SUPER_CLASS", KtDelegatorToSuperClass.class);
+    KtPlaceHolderStubElementType<KtConstructorCalleeExpression> CONSTRUCTOR_CALLEE =
+            new KtPlaceHolderStubElementType<KtConstructorCalleeExpression>("CONSTRUCTOR_CALLEE", KtConstructorCalleeExpression.class);
+
+    TokenSet DECLARATION_TYPES =
+            TokenSet.create(CLASS, OBJECT_DECLARATION, FUNCTION, PROPERTY, ANONYMOUS_INITIALIZER, SECONDARY_CONSTRUCTOR, ENUM_ENTRY);
+
+    TokenSet DELEGATION_SPECIFIER_TYPES = TokenSet.create(DELEGATOR_BY, DELEGATOR_SUPER_CALL, DELEGATOR_SUPER_CLASS);
+
+    TokenSet TYPE_ELEMENT_TYPES = TokenSet.create(USER_TYPE, NULLABLE_TYPE, FUNCTION_TYPE, DYNAMIC_TYPE, SELF_TYPE);
+
+    TokenSet INSIDE_DIRECTIVE_EXPRESSIONS = TokenSet.create(REFERENCE_EXPRESSION, DOT_QUALIFIED_EXPRESSION);
+}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetTypeParameterElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtTypeParameterElementType.java
similarity index 83%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetTypeParameterElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtTypeParameterElementType.java
index 13a1bc2728e..715cde90282 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetTypeParameterElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtTypeParameterElementType.java
@@ -22,20 +22,20 @@ import com.intellij.psi.stubs.StubOutputStream;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetTypeParameter;
+import org.jetbrains.kotlin.psi.KtTypeParameter;
 import org.jetbrains.kotlin.psi.stubs.KotlinTypeParameterStub;
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinTypeParameterStubImpl;
 import org.jetbrains.kotlin.types.Variance;
 
 import java.io.IOException;
 
-public class JetTypeParameterElementType extends JetStubElementType<KotlinTypeParameterStub, JetTypeParameter> {
-    public JetTypeParameterElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetTypeParameter.class, KotlinTypeParameterStub.class);
+public class KtTypeParameterElementType extends KtStubElementType<KotlinTypeParameterStub, KtTypeParameter> {
+    public KtTypeParameterElementType(@NotNull @NonNls String debugName) {
+        super(debugName, KtTypeParameter.class, KotlinTypeParameterStub.class);
     }
 
     @Override
-    public KotlinTypeParameterStub createStub(@NotNull JetTypeParameter psi, StubElement parentStub) {
+    public KotlinTypeParameterStub createStub(@NotNull KtTypeParameter psi, StubElement parentStub) {
         return new KotlinTypeParameterStubImpl(parentStub, StringRef.fromString(psi.getName()),
                                                psi.getVariance() == Variance.IN_VARIANCE, psi.getVariance() == Variance.OUT_VARIANCE);
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetTypeProjectionElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtTypeProjectionElementType.java
similarity index 79%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetTypeProjectionElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtTypeProjectionElementType.java
index 45f44142199..7bc7389cd93 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetTypeProjectionElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtTypeProjectionElementType.java
@@ -21,19 +21,19 @@ import com.intellij.psi.stubs.StubInputStream;
 import com.intellij.psi.stubs.StubOutputStream;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetTypeProjection;
+import org.jetbrains.kotlin.psi.KtTypeProjection;
 import org.jetbrains.kotlin.psi.stubs.KotlinTypeProjectionStub;
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinTypeProjectionStubImpl;
 
 import java.io.IOException;
 
-public class JetTypeProjectionElementType extends JetStubElementType<KotlinTypeProjectionStub, JetTypeProjection> {
-    public JetTypeProjectionElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetTypeProjection.class, KotlinTypeProjectionStub.class);
+public class KtTypeProjectionElementType extends KtStubElementType<KotlinTypeProjectionStub, KtTypeProjection> {
+    public KtTypeProjectionElementType(@NotNull @NonNls String debugName) {
+        super(debugName, KtTypeProjection.class, KotlinTypeProjectionStub.class);
     }
 
     @Override
-    public KotlinTypeProjectionStub createStub(@NotNull JetTypeProjection psi, StubElement parentStub) {
+    public KotlinTypeProjectionStub createStub(@NotNull KtTypeProjection psi, StubElement parentStub) {
         return new KotlinTypeProjectionStubImpl(parentStub, psi.getProjectionKind().ordinal());
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetUserTypeElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtUserTypeElementType.java
similarity index 81%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetUserTypeElementType.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtUserTypeElementType.java
index 67ca75ceeda..f3b8ac09439 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetUserTypeElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtUserTypeElementType.java
@@ -21,19 +21,19 @@ import com.intellij.psi.stubs.StubInputStream;
 import com.intellij.psi.stubs.StubOutputStream;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetUserType;
+import org.jetbrains.kotlin.psi.KtUserType;
 import org.jetbrains.kotlin.psi.stubs.KotlinUserTypeStub;
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinUserTypeStubImpl;
 
 import java.io.IOException;
 
-public class JetUserTypeElementType extends JetStubElementType<KotlinUserTypeStub, JetUserType> {
-    public JetUserTypeElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetUserType.class, KotlinUserTypeStub.class);
+public class KtUserTypeElementType extends KtStubElementType<KotlinUserTypeStub, KtUserType> {
+    public KtUserTypeElementType(@NotNull @NonNls String debugName) {
+        super(debugName, KtUserType.class, KotlinUserTypeStub.class);
     }
 
     @Override
-    public KotlinUserTypeStub createStub(@NotNull JetUserType psi, StubElement parentStub) {
+    public KotlinUserTypeStub createStub(@NotNull KtUserType psi, StubElement parentStub) {
         return new KotlinUserTypeStubImpl(parentStub, psi.isAbsoluteInRootPackage());
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/StubIndexService.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/StubIndexService.kt
index 20ffda95aa0..c4212145576 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/StubIndexService.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/StubIndexService.kt
@@ -20,7 +20,7 @@ import com.intellij.openapi.components.ServiceManager
 import com.intellij.psi.stubs.IndexSink
 import com.intellij.psi.stubs.StubInputStream
 import com.intellij.psi.stubs.StubOutputStream
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.stubs.*
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinFileStubImpl
 import java.io.IOException
@@ -44,7 +44,7 @@ public open class StubIndexService protected constructor() {
     public open fun indexAnnotation(stub: KotlinAnnotationEntryStub, sink: IndexSink) {
     }
 
-    public open fun createFileStub(file: JetFile): KotlinFileStub {
+    public open fun createFileStub(file: KtFile): KotlinFileStub {
         return KotlinFileStubImpl(file, file.packageFqNameByTree.asString(), file.isScriptByTree)
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinAnnotationEntryStubImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinAnnotationEntryStubImpl.kt
index 50d73dc3150..9c98886214f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinAnnotationEntryStubImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinAnnotationEntryStubImpl.kt
@@ -18,16 +18,16 @@ package org.jetbrains.kotlin.psi.stubs.impl
 
 import com.intellij.psi.stubs.StubElement
 import com.intellij.util.io.StringRef
-import org.jetbrains.kotlin.psi.JetAnnotationEntry
+import org.jetbrains.kotlin.psi.KtAnnotationEntry
 import org.jetbrains.kotlin.psi.stubs.KotlinAnnotationEntryStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import com.intellij.psi.PsiElement
 
 public class KotlinAnnotationEntryStubImpl(
         parent: StubElement<out PsiElement>?,
         private val shortName: StringRef,
         private val hasValueArguments: Boolean
-) : KotlinStubBaseImpl<JetAnnotationEntry>(parent, JetStubElementTypes.ANNOTATION_ENTRY), KotlinAnnotationEntryStub {
+) : KotlinStubBaseImpl<KtAnnotationEntry>(parent, KtStubElementTypes.ANNOTATION_ENTRY), KotlinAnnotationEntryStub {
 
     override fun getShortName() = shortName.getString()
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinAnnotationUseSiteStubImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinAnnotationUseSiteStubImpl.kt
index 2c8ccd9bbc8..3abc574e90a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinAnnotationUseSiteStubImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinAnnotationUseSiteStubImpl.kt
@@ -19,14 +19,14 @@ package org.jetbrains.kotlin.psi.stubs.impl
 import com.intellij.psi.PsiElement
 import com.intellij.psi.stubs.StubElement
 import com.intellij.util.io.StringRef
-import org.jetbrains.kotlin.psi.JetAnnotationUseSiteTarget
+import org.jetbrains.kotlin.psi.KtAnnotationUseSiteTarget
 import org.jetbrains.kotlin.psi.stubs.KotlinAnnotationUseSiteTargetStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 
 public class KotlinAnnotationUseSiteTargetStubImpl(
         parent: StubElement<out PsiElement>?,
         private val target: StringRef
-) : KotlinStubBaseImpl<JetAnnotationUseSiteTarget>(parent, JetStubElementTypes.ANNOTATION_TARGET), KotlinAnnotationUseSiteTargetStub {
+) : KotlinStubBaseImpl<KtAnnotationUseSiteTarget>(parent, KtStubElementTypes.ANNOTATION_TARGET), KotlinAnnotationUseSiteTargetStub {
 
     override fun getUseSiteTarget() = target.string
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinClassStubImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinClassStubImpl.kt
index f062e9092b1..8363077ce41 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinClassStubImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinClassStubImpl.kt
@@ -18,16 +18,16 @@ package org.jetbrains.kotlin.psi.stubs.impl
 
 import com.intellij.psi.stubs.StubElement
 import com.intellij.util.io.StringRef
-import org.jetbrains.kotlin.psi.JetClass
+import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.stubs.KotlinClassStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetClassElementType
+import org.jetbrains.kotlin.psi.stubs.elements.KtClassElementType
 import org.jetbrains.kotlin.name.FqName
 
 import java.util.ArrayList
 import com.intellij.psi.PsiElement
 
 public class KotlinClassStubImpl(
-        type: JetClassElementType,
+        type: KtClassElementType,
         parent: StubElement<out PsiElement>?,
         private val qualifiedName: StringRef?,
         private val name: StringRef?,
@@ -36,7 +36,7 @@ public class KotlinClassStubImpl(
         private val isEnumEntry: Boolean,
         private val isLocal: Boolean,
         private val isTopLevel: Boolean
-) : KotlinStubBaseImpl<JetClass>(parent, type), KotlinClassStub {
+) : KotlinStubBaseImpl<KtClass>(parent, type), KotlinClassStub {
 
     override fun getFqName(): FqName? {
         val stringRef = StringRef.toString(qualifiedName)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinEnumEntrySuperclassReferenceExpressionStubImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinEnumEntrySuperclassReferenceExpressionStubImpl.kt
index 4d8ea607355..892c2887cf7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinEnumEntrySuperclassReferenceExpressionStubImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinEnumEntrySuperclassReferenceExpressionStubImpl.kt
@@ -19,12 +19,12 @@ package org.jetbrains.kotlin.psi.stubs.impl
 import com.intellij.psi.PsiElement
 import com.intellij.psi.stubs.StubElement
 import com.intellij.util.io.StringRef
-import org.jetbrains.kotlin.psi.JetEnumEntrySuperclassReferenceExpression
+import org.jetbrains.kotlin.psi.KtEnumEntrySuperclassReferenceExpression
 import org.jetbrains.kotlin.psi.stubs.KotlinEnumEntrySuperclassReferenceExpressionStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 
 public class KotlinEnumEntrySuperclassReferenceExpressionStubImpl(parent: StubElement<*>, private val referencedName: StringRef)
-    : KotlinStubBaseImpl<JetEnumEntrySuperclassReferenceExpression>(parent, JetStubElementTypes.ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION), KotlinEnumEntrySuperclassReferenceExpressionStub {
+    : KotlinStubBaseImpl<KtEnumEntrySuperclassReferenceExpression>(parent, KtStubElementTypes.ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION), KotlinEnumEntrySuperclassReferenceExpressionStub {
 
     override fun getReferencedName() = referencedName.getString()
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinFileStubImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinFileStubImpl.kt
index 58f3c9c611f..0d722b13697 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinFileStubImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinFileStubImpl.kt
@@ -24,24 +24,24 @@ import com.intellij.psi.tree.IStubFileElementType
 import com.intellij.util.io.StringRef
 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.psi.stubs.KotlinFileStub
 import org.jetbrains.kotlin.psi.stubs.KotlinImportDirectiveStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 
 // SCRIPT: PsiJetFileStubImpl knows about scripting
 public open class KotlinFileStubImpl(
-        jetFile: JetFile?,
+        jetFile: KtFile?,
         private val packageName: StringRef,
         private val isScript: Boolean
-) : PsiFileStubImpl<JetFile>(jetFile), KotlinFileStub, PsiClassHolderFileStub<JetFile> {
+) : PsiFileStubImpl<KtFile>(jetFile), KotlinFileStub, PsiClassHolderFileStub<KtFile> {
 
-    public constructor(jetFile: JetFile?, packageName: String, isScript: Boolean)
+    public constructor(jetFile: KtFile?, packageName: String, isScript: Boolean)
         : this(jetFile, StringRef.fromString(packageName)!!, isScript)
 
     override fun getPackageFqName(): FqName = FqName(StringRef.toString(packageName)!!)
     override fun isScript(): Boolean = isScript
-    override fun getType(): IStubFileElementType<KotlinFileStub> = JetStubElementTypes.FILE
+    override fun getType(): IStubFileElementType<KotlinFileStub> = KtStubElementTypes.FILE
 
     override fun toString(): String = "PsiJetFileStubImpl[" + "package=" + getPackageFqName().asString() + "]"
 
@@ -50,7 +50,7 @@ public open class KotlinFileStubImpl(
     }
 
     override fun findImportsByAlias(alias: String): List<KotlinImportDirectiveStub> {
-        val importList = childrenStubs.firstOrNull { it.stubType == JetStubElementTypes.IMPORT_LIST } ?: return emptyList()
+        val importList = childrenStubs.firstOrNull { it.stubType == KtStubElementTypes.IMPORT_LIST } ?: return emptyList()
         return importList.childrenStubs.filterIsInstance<KotlinImportDirectiveStub>().filter { it.getAliasName() == alias }
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinFunctionStubImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinFunctionStubImpl.kt
index 8397a57afb8..0fdce18e699 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinFunctionStubImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinFunctionStubImpl.kt
@@ -18,9 +18,9 @@ package org.jetbrains.kotlin.psi.stubs.impl
 
 import com.intellij.psi.stubs.StubElement
 import com.intellij.util.io.StringRef
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.stubs.KotlinFunctionStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import org.jetbrains.kotlin.name.FqName
 import com.intellij.psi.PsiElement
 
@@ -33,7 +33,7 @@ public class KotlinFunctionStubImpl(
         private val hasBlockBody: Boolean,
         private val hasBody: Boolean,
         private val hasTypeParameterListBeforeFunctionName: Boolean
-) : KotlinStubBaseImpl<JetNamedFunction>(parent, JetStubElementTypes.FUNCTION), KotlinFunctionStub {
+) : KotlinStubBaseImpl<KtNamedFunction>(parent, KtStubElementTypes.FUNCTION), KotlinFunctionStub {
     init {
         if (isTopLevel && fqName == null) {
             throw IllegalArgumentException("fqName shouldn't be null for top level functions")
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinImportDirectiveStubImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinImportDirectiveStubImpl.kt
index 95a4de195f0..e4376476dd4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinImportDirectiveStubImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinImportDirectiveStubImpl.kt
@@ -20,9 +20,9 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.stubs.StubElement
 import com.intellij.util.io.StringRef
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetImportDirective
+import org.jetbrains.kotlin.psi.KtImportDirective
 import org.jetbrains.kotlin.psi.stubs.KotlinImportDirectiveStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 
 public class KotlinImportDirectiveStubImpl(
         parent: StubElement<PsiElement>,
@@ -30,7 +30,7 @@ public class KotlinImportDirectiveStubImpl(
         private val isAllUnder: Boolean,
         private val importedFqName: StringRef?,
         private val aliasName: StringRef?,
-        private val isValid: Boolean) : KotlinStubBaseImpl<JetImportDirective>(parent, JetStubElementTypes.IMPORT_DIRECTIVE), KotlinImportDirectiveStub {
+        private val isValid: Boolean) : KotlinStubBaseImpl<KtImportDirective>(parent, KtStubElementTypes.IMPORT_DIRECTIVE), KotlinImportDirectiveStub {
 
     override fun isAbsoluteInRootPackage(): Boolean = isAbsoluteInRootPackage
     override fun isAllUnder(): Boolean = isAllUnder
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinModifierListStubImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinModifierListStubImpl.java
index e989e62e31c..043d2af8dc8 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinModifierListStubImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinModifierListStubImpl.java
@@ -18,16 +18,16 @@ package org.jetbrains.kotlin.psi.stubs.impl;
 
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetModifierList;
+import org.jetbrains.kotlin.psi.KtModifierList;
 import org.jetbrains.kotlin.psi.stubs.KotlinModifierListStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetModifierListElementType;
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
+import org.jetbrains.kotlin.psi.stubs.elements.KtModifierListElementType;
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken;
 
-public class KotlinModifierListStubImpl extends KotlinStubBaseImpl<JetModifierList> implements KotlinModifierListStub {
+public class KotlinModifierListStubImpl extends KotlinStubBaseImpl<KtModifierList> implements KotlinModifierListStub {
 
     private final int mask;
 
-    public KotlinModifierListStubImpl(StubElement parent, int mask, @NotNull JetModifierListElementType<?> elementType) {
+    public KotlinModifierListStubImpl(StubElement parent, int mask, @NotNull KtModifierListElementType<?> elementType) {
         super(parent, elementType);
         this.mask = mask;
     }
@@ -37,7 +37,7 @@ public class KotlinModifierListStubImpl extends KotlinStubBaseImpl<JetModifierLi
     }
 
     @Override
-    public boolean hasModifier(@NotNull JetModifierKeywordToken modifierToken) {
+    public boolean hasModifier(@NotNull KtModifierKeywordToken modifierToken) {
         return ModifierMaskUtils.maskHasModifier(mask, modifierToken);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinNameReferenceExpressionStubImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinNameReferenceExpressionStubImpl.java
index 3e693e57191..5ce1d670f29 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinNameReferenceExpressionStubImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinNameReferenceExpressionStubImpl.java
@@ -19,17 +19,17 @@ package org.jetbrains.kotlin.psi.stubs.impl;
 import com.intellij.psi.stubs.StubElement;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetNameReferenceExpression;
+import org.jetbrains.kotlin.psi.KtNameReferenceExpression;
 import org.jetbrains.kotlin.psi.stubs.KotlinNameReferenceExpressionStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
-public class KotlinNameReferenceExpressionStubImpl extends KotlinStubBaseImpl<JetNameReferenceExpression> implements
+public class KotlinNameReferenceExpressionStubImpl extends KotlinStubBaseImpl<KtNameReferenceExpression> implements
                                                                                                        KotlinNameReferenceExpressionStub {
     @NotNull
     private final StringRef referencedName;
 
     public KotlinNameReferenceExpressionStubImpl(StubElement parent, @NotNull StringRef referencedName) {
-        super(parent, JetStubElementTypes.REFERENCE_EXPRESSION);
+        super(parent, KtStubElementTypes.REFERENCE_EXPRESSION);
         this.referencedName = referencedName;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinObjectStubImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinObjectStubImpl.kt
index f108d6cb076..bbb15ee1898 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinObjectStubImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinObjectStubImpl.kt
@@ -18,9 +18,9 @@ package org.jetbrains.kotlin.psi.stubs.impl
 
 import com.intellij.psi.stubs.StubElement
 import com.intellij.util.io.StringRef
-import org.jetbrains.kotlin.psi.JetObjectDeclaration
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
 import org.jetbrains.kotlin.psi.stubs.KotlinObjectStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import org.jetbrains.kotlin.name.FqName
 
 import com.intellij.psi.PsiElement
@@ -34,7 +34,7 @@ public class KotlinObjectStubImpl(
         private val isDefault: Boolean,
         private val isLocal: Boolean,
         private val isObjectLiteral: Boolean
-) : KotlinStubBaseImpl<JetObjectDeclaration>(parent, JetStubElementTypes.OBJECT_DECLARATION), KotlinObjectStub {
+) : KotlinStubBaseImpl<KtObjectDeclaration>(parent, KtStubElementTypes.OBJECT_DECLARATION), KotlinObjectStub {
     override fun getFqName() = fqName
     override fun getName() = StringRef.toString(name)
     override fun getSuperNames() = superNames map { it.toString() }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinParameterStubImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinParameterStubImpl.kt
index b5fec854540..e3f7a3c7be3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinParameterStubImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinParameterStubImpl.kt
@@ -18,9 +18,9 @@ package org.jetbrains.kotlin.psi.stubs.impl
 
 import com.intellij.psi.stubs.StubElement
 import com.intellij.util.io.StringRef
-import org.jetbrains.kotlin.psi.JetParameter
+import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.psi.stubs.KotlinParameterStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import org.jetbrains.kotlin.name.FqName
 import com.intellij.psi.PsiElement
 
@@ -31,7 +31,7 @@ public class KotlinParameterStubImpl(
         private val isMutable: Boolean,
         private val hasValOrVar: Boolean,
         private val hasDefaultValue: Boolean
-) : KotlinStubBaseImpl<JetParameter>(parent, JetStubElementTypes.VALUE_PARAMETER), KotlinParameterStub {
+) : KotlinStubBaseImpl<KtParameter>(parent, KtStubElementTypes.VALUE_PARAMETER), KotlinParameterStub {
     override fun getName(): String? {
         return StringRef.toString(name)
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinPlaceHolderStubImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinPlaceHolderStubImpl.java
index cb71a292097..2b712a5d4f1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinPlaceHolderStubImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinPlaceHolderStubImpl.java
@@ -18,10 +18,10 @@ package org.jetbrains.kotlin.psi.stubs.impl;
 
 import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.psi.stubs.StubElement;
-import org.jetbrains.kotlin.psi.JetElementImplStub;
+import org.jetbrains.kotlin.psi.KtElementImplStub;
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
 
-public class KotlinPlaceHolderStubImpl<T extends JetElementImplStub<? extends StubElement<?>>> extends KotlinStubBaseImpl<T>
+public class KotlinPlaceHolderStubImpl<T extends KtElementImplStub<? extends StubElement<?>>> extends KotlinStubBaseImpl<T>
         implements KotlinPlaceHolderStub<T> {
     public KotlinPlaceHolderStubImpl(StubElement parent, IStubElementType elementType) {
         //noinspection unchecked
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinPropertyAccessorStubImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinPropertyAccessorStubImpl.java
index 66b428fd5ea..d27b329337e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinPropertyAccessorStubImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinPropertyAccessorStubImpl.java
@@ -17,17 +17,17 @@
 package org.jetbrains.kotlin.psi.stubs.impl;
 
 import com.intellij.psi.stubs.StubElement;
-import org.jetbrains.kotlin.psi.JetPropertyAccessor;
+import org.jetbrains.kotlin.psi.KtPropertyAccessor;
 import org.jetbrains.kotlin.psi.stubs.KotlinPropertyAccessorStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
-public class KotlinPropertyAccessorStubImpl extends KotlinStubBaseImpl<JetPropertyAccessor> implements KotlinPropertyAccessorStub {
+public class KotlinPropertyAccessorStubImpl extends KotlinStubBaseImpl<KtPropertyAccessor> implements KotlinPropertyAccessorStub {
     private final boolean isGetter;
     private final boolean hasBody;
     private final boolean hasBlockBody;
 
     public KotlinPropertyAccessorStubImpl(StubElement parent, boolean isGetter, boolean hasBody, boolean hasBlockBody) {
-        super(parent, JetStubElementTypes.PROPERTY_ACCESSOR);
+        super(parent, KtStubElementTypes.PROPERTY_ACCESSOR);
         this.isGetter = isGetter;
         this.hasBody = hasBody;
         this.hasBlockBody = hasBlockBody;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinPropertyStubImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinPropertyStubImpl.kt
index 2697f902f0d..2d5ffbf0dda 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinPropertyStubImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinPropertyStubImpl.kt
@@ -18,9 +18,9 @@ package org.jetbrains.kotlin.psi.stubs.impl
 
 import com.intellij.psi.stubs.StubElement
 import com.intellij.util.io.StringRef
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.stubs.KotlinPropertyStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import org.jetbrains.kotlin.name.FqName
 import com.intellij.psi.PsiElement
 
@@ -35,7 +35,7 @@ public class KotlinPropertyStubImpl(
         private val isExtension: Boolean,
         private val hasReturnTypeRef: Boolean,
         private val fqName: FqName?
-) : KotlinStubBaseImpl<JetProperty>(parent, JetStubElementTypes.PROPERTY), KotlinPropertyStub {
+) : KotlinStubBaseImpl<KtProperty>(parent, KtStubElementTypes.PROPERTY), KotlinPropertyStub {
 
     init {
         if (isTopLevel && fqName == null) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinStubBaseImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinStubBaseImpl.kt
index b6bb59aea83..9722e4b71dc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinStubBaseImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinStubBaseImpl.kt
@@ -21,14 +21,14 @@ import com.intellij.psi.stubs.IStubElementType
 import com.intellij.psi.stubs.NamedStub
 import com.intellij.psi.stubs.StubBase
 import com.intellij.psi.stubs.StubElement
-import org.jetbrains.kotlin.psi.JetElementImplStub
+import org.jetbrains.kotlin.psi.KtElementImplStub
 import org.jetbrains.kotlin.psi.stubs.KotlinCallableStubBase
 import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub
 import org.jetbrains.kotlin.psi.stubs.KotlinStubWithFqName
 import java.lang.reflect.Method
 import java.util.ArrayList
 
-public open class KotlinStubBaseImpl<T : JetElementImplStub<*>>(parent: StubElement<*>?, elementType: IStubElementType<*, *>) : StubBase<T>(parent, elementType) {
+public open class KotlinStubBaseImpl<T : KtElementImplStub<*>>(parent: StubElement<*>?, elementType: IStubElementType<*, *>) : StubBase<T>(parent, elementType) {
 
     override fun toString(): String {
         val stubInterface = this.javaClass.getInterfaces().filter { it.getName().contains("Stub") }.single()
@@ -75,7 +75,7 @@ public open class KotlinStubBaseImpl<T : JetElementImplStub<*>>(parent: StubElem
     }
 
     companion object {
-        private val LOGGER: Logger = Logger.getInstance(javaClass<KotlinStubBaseImpl<JetElementImplStub<*>>>())
+        private val LOGGER: Logger = Logger.getInstance(javaClass<KotlinStubBaseImpl<KtElementImplStub<*>>>())
 
         private val BASE_STUB_INTERFACES = listOf(javaClass<KotlinStubWithFqName<*>>(), javaClass<KotlinClassOrObjectStub<*>>(), javaClass<NamedStub<*>>(), javaClass<KotlinCallableStubBase<*>>())
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinTypeParameterStubImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinTypeParameterStubImpl.kt
index f36ba60b36a..b5aca2edb76 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinTypeParameterStubImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinTypeParameterStubImpl.kt
@@ -18,9 +18,9 @@ package org.jetbrains.kotlin.psi.stubs.impl
 
 import com.intellij.psi.stubs.StubElement
 import com.intellij.util.io.StringRef
-import org.jetbrains.kotlin.psi.JetTypeParameter
+import org.jetbrains.kotlin.psi.KtTypeParameter
 import org.jetbrains.kotlin.psi.stubs.KotlinTypeParameterStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import com.intellij.psi.PsiElement
 
 public class KotlinTypeParameterStubImpl(
@@ -28,7 +28,7 @@ public class KotlinTypeParameterStubImpl(
         private val name: StringRef?,
         private val isInVariance: Boolean,
         private val isOutVariance: Boolean
-) : KotlinStubBaseImpl<JetTypeParameter>(parent, JetStubElementTypes.TYPE_PARAMETER), KotlinTypeParameterStub {
+) : KotlinStubBaseImpl<KtTypeParameter>(parent, KtStubElementTypes.TYPE_PARAMETER), KotlinTypeParameterStub {
     override fun isInVariance() = isInVariance
     override fun isOutVariance() = isOutVariance
     override fun getName() = StringRef.toString(name)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinTypeProjectionStubImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinTypeProjectionStubImpl.java
index 1f8ce9c7453..1209627975b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinTypeProjectionStubImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinTypeProjectionStubImpl.java
@@ -18,23 +18,23 @@ package org.jetbrains.kotlin.psi.stubs.impl;
 
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetProjectionKind;
-import org.jetbrains.kotlin.psi.JetTypeProjection;
+import org.jetbrains.kotlin.psi.KtProjectionKind;
+import org.jetbrains.kotlin.psi.KtTypeProjection;
 import org.jetbrains.kotlin.psi.stubs.KotlinTypeProjectionStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
-public class KotlinTypeProjectionStubImpl extends KotlinStubBaseImpl<JetTypeProjection> implements KotlinTypeProjectionStub {
+public class KotlinTypeProjectionStubImpl extends KotlinStubBaseImpl<KtTypeProjection> implements KotlinTypeProjectionStub {
 
     private final int projectionKindOrdinal;
 
     public KotlinTypeProjectionStubImpl(StubElement parent, int projectionKindOrdinal) {
-        super(parent, JetStubElementTypes.TYPE_PROJECTION);
+        super(parent, KtStubElementTypes.TYPE_PROJECTION);
         this.projectionKindOrdinal = projectionKindOrdinal;
     }
 
     @NotNull
     @Override
-    public JetProjectionKind getProjectionKind() {
-        return JetProjectionKind.values()[projectionKindOrdinal];
+    public KtProjectionKind getProjectionKind() {
+        return KtProjectionKind.values()[projectionKindOrdinal];
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinUserTypeStubImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinUserTypeStubImpl.kt
index 009c15d8ec8..b3889bbc8e3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinUserTypeStubImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinUserTypeStubImpl.kt
@@ -17,14 +17,14 @@
 package org.jetbrains.kotlin.psi.stubs.impl
 
 import com.intellij.psi.stubs.StubElement
-import org.jetbrains.kotlin.psi.JetUserType
+import org.jetbrains.kotlin.psi.KtUserType
 import org.jetbrains.kotlin.psi.stubs.KotlinUserTypeStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import com.intellij.psi.PsiElement
 
 public class KotlinUserTypeStubImpl(
         parent: StubElement<out PsiElement>?,
         private val isAbsoluteInRootPackage: Boolean
-) : KotlinStubBaseImpl<JetUserType>(parent, JetStubElementTypes.USER_TYPE), KotlinUserTypeStub {
+) : KotlinStubBaseImpl<KtUserType>(parent, KtStubElementTypes.USER_TYPE), KotlinUserTypeStub {
     override fun isAbsoluteInRootPackage() = isAbsoluteInRootPackage
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/ModifierMaskUtils.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/ModifierMaskUtils.kt
index 725bf7382e7..42c4f33fa86 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/ModifierMaskUtils.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/ModifierMaskUtils.kt
@@ -16,10 +16,10 @@
 
 package org.jetbrains.kotlin.psi.stubs.impl
 
-import org.jetbrains.kotlin.psi.JetModifierList
+import org.jetbrains.kotlin.psi.KtModifierList
 
-import org.jetbrains.kotlin.lexer.JetTokens.MODIFIER_KEYWORDS_ARRAY
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens.MODIFIER_KEYWORDS_ARRAY
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 
 public object ModifierMaskUtils {
     init {
@@ -27,10 +27,10 @@ public object ModifierMaskUtils {
     }
 
     @JvmStatic
-    public fun computeMaskFromModifierList(modifierList: JetModifierList): Int = computeMask { modifierList.hasModifier(it) }
+    public fun computeMaskFromModifierList(modifierList: KtModifierList): Int = computeMask { modifierList.hasModifier(it) }
 
     @JvmStatic
-    public fun computeMask(hasModifier: (JetModifierKeywordToken) -> Boolean): Int {
+    public fun computeMask(hasModifier: (KtModifierKeywordToken) -> Boolean): Int {
         var mask = 0
         for ((index, modifierKeywordToken) in MODIFIER_KEYWORDS_ARRAY.withIndex()) {
             if (hasModifier(modifierKeywordToken)) {
@@ -41,7 +41,7 @@ public object ModifierMaskUtils {
     }
 
     @JvmStatic
-    public fun maskHasModifier(mask: Int, modifierToken: JetModifierKeywordToken): Boolean {
+    public fun maskHasModifier(mask: Int, modifierToken: KtModifierKeywordToken): Boolean {
         val index = MODIFIER_KEYWORDS_ARRAY.indexOf(modifierToken)
         assert(index >= 0) { "All JetModifierKeywordTokens should be present in MODIFIER_KEYWORDS_ARRAY" }
         return (mask and (1 shl index)) != 0
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AllUnderImportsScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AllUnderImportsScope.kt
index f3cbd4759f7..6dde8e3f7b6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AllUnderImportsScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AllUnderImportsScope.kt
@@ -20,11 +20,11 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-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.jetbrains.kotlin.utils.Printer
 
-class AllUnderImportsScope(descriptor: DeclarationDescriptor) : JetScope {
+class AllUnderImportsScope(descriptor: DeclarationDescriptor) : KtScope {
     private val scopes = if (descriptor is ClassDescriptor) {
         listOf(descriptor.staticScope, descriptor.unsubstitutedInnerClassesScope)
     }
@@ -51,19 +51,19 @@ class AllUnderImportsScope(descriptor: DeclarationDescriptor) : JetScope {
         return scopes.flatMap { it.getFunctions(name, location) }
     }
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor> {
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor> {
         return scopes.flatMap { it.getSyntheticExtensionProperties(receiverTypes, name, location) }
     }
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
         return scopes.flatMap { it.getSyntheticExtensionFunctions(receiverTypes, name, location) }
     }
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor> {
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>): Collection<PropertyDescriptor> {
         return scopes.flatMap { it.getSyntheticExtensionProperties(receiverTypes) }
     }
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>): Collection<FunctionDescriptor> {
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>): Collection<FunctionDescriptor> {
         return scopes.flatMap { it.getSyntheticExtensionFunctions(receiverTypes) }
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnalyzerScriptParameter.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnalyzerScriptParameter.java
index 4bbb55ce049..a2c798d8b14 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnalyzerScriptParameter.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnalyzerScriptParameter.java
@@ -18,15 +18,15 @@ package org.jetbrains.kotlin.resolve;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public class AnalyzerScriptParameter {
     @NotNull
     private final Name name;
     @NotNull
-    private final JetType type;
+    private final KtType type;
 
-    public AnalyzerScriptParameter(@NotNull Name name, @NotNull JetType type) {
+    public AnalyzerScriptParameter(@NotNull Name name, @NotNull KtType type) {
         this.name = name;
         this.type = type;
     }
@@ -37,7 +37,7 @@ public class AnalyzerScriptParameter {
     }
 
     @NotNull
-    public JetType getType() {
+    public KtType getType() {
         return type;
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnalyzingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnalyzingUtils.java
index cb76e2cf68b..e67f8c931e2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnalyzingUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnalyzingUtils.java
@@ -23,8 +23,8 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink;
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils;
-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.psi.debugText.DebugTextUtilKt;
 
 import java.util.ArrayList;
@@ -32,7 +32,7 @@ import java.util.List;
 
 public class AnalyzingUtils {
 
-    public abstract static class PsiErrorElementVisitor extends JetTreeVisitorVoid {
+    public abstract static class PsiErrorElementVisitor extends KtTreeVisitorVoid {
         @Override
         public abstract void visitErrorElement(PsiErrorElement element);
     }
@@ -68,8 +68,8 @@ public class AnalyzingUtils {
 
     public static String formDebugNameForBindingTrace(@NotNull String debugName, @Nullable Object resolutionSubjectForMessage) {
         StringBuilder debugInfo = new StringBuilder(debugName);
-        if (resolutionSubjectForMessage instanceof JetElement) {
-            JetElement element = (JetElement) resolutionSubjectForMessage;
+        if (resolutionSubjectForMessage instanceof KtElement) {
+            KtElement element = (KtElement) resolutionSubjectForMessage;
             debugInfo.append(" ").append(DebugTextUtilKt.getDebugText(element));
             debugInfo.append(" in ").append(element.getContainingFile().getName());
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt
index 2df7becdea5..c5660bb5174 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getAnnotationEntries
 import org.jetbrains.kotlin.resolve.constants.ArrayValue
 import org.jetbrains.kotlin.resolve.constants.EnumValue
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.isRepeatableAnnotation
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget.*
@@ -34,26 +34,26 @@ import org.jetbrains.kotlin.resolve.inline.InlineUtil
 
 public class AnnotationChecker(private val additionalCheckers: Iterable<AdditionalAnnotationChecker>) {
 
-    public fun check(annotated: JetAnnotated, trace: BindingTrace, descriptor: DeclarationDescriptor? = null) {
+    public fun check(annotated: KtAnnotated, trace: BindingTrace, descriptor: DeclarationDescriptor? = null) {
         val actualTargets = getActualTargetList(annotated, descriptor)
         checkEntries(annotated.annotationEntries, actualTargets, trace)
-        if (annotated is JetCallableDeclaration) {
+        if (annotated is KtCallableDeclaration) {
             annotated.typeReference?.let { check(it, trace) }
             annotated.receiverTypeReference?.let { check(it, trace) }
         }
-        if (annotated is JetTypeParameterListOwner && annotated is JetCallableDeclaration) {
+        if (annotated is KtTypeParameterListOwner && annotated is KtCallableDeclaration) {
             // TODO: support type parameter annotations for type parameters on classes and properties
             annotated.typeParameters.forEach { check(it, trace) }
         }
-        if (annotated is JetTypeReference) {
+        if (annotated is KtTypeReference) {
             annotated.typeElement?.typeArgumentsAsTypes?.filterNotNull()?.forEach { check(it, trace) }
         }
-        if (annotated is JetDeclarationWithBody) {
+        if (annotated is KtDeclarationWithBody) {
             // JetFunction or JetPropertyAccessor
             for (parameter in annotated.valueParameters) {
                 if (!parameter.hasValOrVar()) {
                     check(parameter, trace)
-                    if (annotated is JetFunctionLiteral) {
+                    if (annotated is KtFunctionLiteral) {
                         parameter.typeReference?.let { check(it, trace) }
                     }
                 }
@@ -61,17 +61,17 @@ public class AnnotationChecker(private val additionalCheckers: Iterable<Addition
         }
     }
 
-    public fun checkExpression(expression: JetExpression, trace: BindingTrace) {
+    public fun checkExpression(expression: KtExpression, trace: BindingTrace) {
         checkEntries(expression.getAnnotationEntries(), getActualTargetList(expression, null), trace)
-        if (expression is JetFunctionLiteralExpression) {
+        if (expression is KtFunctionLiteralExpression) {
             for (parameter in expression.valueParameters) {
                 parameter.typeReference?.let { check(it, trace) }
             }
         }
     }
 
-    private fun checkEntries(entries: List<JetAnnotationEntry>, actualTargets: TargetList, trace: BindingTrace) {
-        val entryTypesWithAnnotations = hashMapOf<JetType, MutableList<AnnotationUseSiteTarget?>>()
+    private fun checkEntries(entries: List<KtAnnotationEntry>, actualTargets: TargetList, trace: BindingTrace) {
+        val entryTypesWithAnnotations = hashMapOf<KtType, MutableList<AnnotationUseSiteTarget?>>()
 
         for (entry in entries) {
             checkAnnotationEntry(entry, actualTargets, trace)
@@ -92,7 +92,7 @@ public class AnnotationChecker(private val additionalCheckers: Iterable<Addition
         additionalCheckers.forEach { it.checkEntries(entries, actualTargets.defaultTargets, trace) }
     }
 
-    private fun checkAnnotationEntry(entry: JetAnnotationEntry, actualTargets: TargetList, trace: BindingTrace) {
+    private fun checkAnnotationEntry(entry: KtAnnotationEntry, actualTargets: TargetList, trace: BindingTrace) {
         val applicableTargets = applicableTargetSet(entry, trace)
         val useSiteTarget = entry.useSiteTarget?.getAnnotationUseSiteTarget()
 
@@ -103,12 +103,12 @@ public class AnnotationChecker(private val additionalCheckers: Iterable<Addition
         fun checkUselessFunctionLiteralAnnotation() {
             // TODO: tests on different JetAnnotatedExpression (?!)
             if (KotlinTarget.FUNCTION !in applicableTargets) return
-            val annotatedExpression = entry.parent as? JetAnnotatedExpression ?: return
+            val annotatedExpression = entry.parent as? KtAnnotatedExpression ?: return
             val descriptor = trace.get(BindingContext.ANNOTATION, entry) ?: return
             val retention = descriptor.type.constructor.declarationDescriptor?.getAnnotationRetention()
             if (retention == KotlinRetention.SOURCE) return
 
-            val functionLiteralExpression = annotatedExpression.baseExpression as? JetFunctionLiteralExpression ?: return
+            val functionLiteralExpression = annotatedExpression.baseExpression as? KtFunctionLiteralExpression ?: return
             if (InlineUtil.isInlinedArgument(functionLiteralExpression.functionLiteral, trace.bindingContext, false)) {
                 trace.report(Errors.NON_SOURCE_ANNOTATION_ON_INLINED_FUNCTION_LITERAL.on(entry))
             }
@@ -134,7 +134,7 @@ public class AnnotationChecker(private val additionalCheckers: Iterable<Addition
     }
 
     companion object {
-        private fun applicableTargetSet(entry: JetAnnotationEntry, trace: BindingTrace): Set<KotlinTarget> {
+        private fun applicableTargetSet(entry: KtAnnotationEntry, trace: BindingTrace): Set<KotlinTarget> {
             val descriptor = trace.get(BindingContext.ANNOTATION, entry) ?: return KotlinTarget.DEFAULT_TARGET_SET
             // For descriptor with error type, all targets are considered as possible
             if (descriptor.type.isError) return KotlinTarget.ALL_TARGET_SET
@@ -158,51 +158,51 @@ public class AnnotationChecker(private val additionalCheckers: Iterable<Addition
             }.filterNotNull().toSet()
         }
 
-        public fun getDeclarationSiteActualTargetList(annotated: JetElement, descriptor: ClassDescriptor?): List<KotlinTarget> {
+        public fun getDeclarationSiteActualTargetList(annotated: KtElement, descriptor: ClassDescriptor?): List<KotlinTarget> {
             return getActualTargetList(annotated, descriptor).defaultTargets
         }
 
-        private fun getActualTargetList(annotated: JetElement, descriptor: DeclarationDescriptor?): TargetList {
+        private fun getActualTargetList(annotated: KtElement, descriptor: DeclarationDescriptor?): TargetList {
             return when (annotated) {
-                is JetClassOrObject ->
+                is KtClassOrObject ->
                     (descriptor as? ClassDescriptor)?.let { TargetList(KotlinTarget.classActualTargets(it)) } ?: TargetLists.T_CLASSIFIER
-                is JetMultiDeclarationEntry -> TargetLists.T_LOCAL_VARIABLE
-                is JetProperty -> {
+                is KtMultiDeclarationEntry -> TargetLists.T_LOCAL_VARIABLE
+                is KtProperty -> {
                     if (annotated.isLocal)
                         TargetLists.T_LOCAL_VARIABLE
-                    else if (annotated.parent is JetClassOrObject || annotated.parent is JetClassBody)
+                    else if (annotated.parent is KtClassOrObject || annotated.parent is KtClassBody)
                         TargetLists.T_MEMBER_PROPERTY
                     else
                         TargetLists.T_TOP_LEVEL_PROPERTY
                 }
-                is JetParameter -> {
+                is KtParameter -> {
                     if (annotated.hasValOrVar())
                         TargetLists.T_VALUE_PARAMETER_WITH_VAL
                     else
                         TargetLists.T_VALUE_PARAMETER_WITHOUT_VAL
                 }
-                is JetConstructor<*> -> TargetLists.T_CONSTRUCTOR
-                is JetFunction -> {
+                is KtConstructor<*> -> TargetLists.T_CONSTRUCTOR
+                is KtFunction -> {
                     if (DescriptorUtils.isFunctionExpression(descriptor))
                         TargetLists.T_FUNCTION_EXPRESSION
                     else if (annotated.isLocal)
                         TargetLists.T_LOCAL_FUNCTION
-                    else if (annotated.parent is JetClassOrObject || annotated.parent is JetClassBody)
+                    else if (annotated.parent is KtClassOrObject || annotated.parent is KtClassBody)
                         TargetLists.T_MEMBER_FUNCTION
                     else
                         TargetLists.T_TOP_LEVEL_FUNCTION
                 }
-                is JetPropertyAccessor -> if (annotated.isGetter) TargetLists.T_PROPERTY_GETTER else TargetLists.T_PROPERTY_SETTER
-                is JetTypeReference -> TargetLists.T_TYPE_REFERENCE
-                is JetFile -> TargetLists.T_FILE
-                is JetTypeParameter -> TargetLists.T_TYPE_PARAMETER
-                is JetTypeProjection ->
-                    if (annotated.projectionKind == JetProjectionKind.STAR) TargetLists.T_STAR_PROJECTION else TargetLists.T_TYPE_PROJECTION
-                is JetClassInitializer -> TargetLists.T_INITIALIZER
-                is JetMultiDeclaration -> TargetLists.T_MULTI_DECLARATION
-                is JetFunctionLiteralExpression -> TargetLists.T_FUNCTION_LITERAL
-                is JetObjectLiteralExpression -> TargetLists.T_OBJECT_LITERAL
-                is JetExpression -> TargetLists.T_EXPRESSION
+                is KtPropertyAccessor -> if (annotated.isGetter) TargetLists.T_PROPERTY_GETTER else TargetLists.T_PROPERTY_SETTER
+                is KtTypeReference -> TargetLists.T_TYPE_REFERENCE
+                is KtFile -> TargetLists.T_FILE
+                is KtTypeParameter -> TargetLists.T_TYPE_PARAMETER
+                is KtTypeProjection ->
+                    if (annotated.projectionKind == KtProjectionKind.STAR) TargetLists.T_STAR_PROJECTION else TargetLists.T_TYPE_PROJECTION
+                is KtClassInitializer -> TargetLists.T_INITIALIZER
+                is KtMultiDeclaration -> TargetLists.T_MULTI_DECLARATION
+                is KtFunctionLiteralExpression -> TargetLists.T_FUNCTION_LITERAL
+                is KtObjectLiteralExpression -> TargetLists.T_OBJECT_LITERAL
+                is KtExpression -> TargetLists.T_EXPRESSION
                 else -> TargetLists.EMPTY
             }
         }
@@ -306,5 +306,5 @@ public class AnnotationChecker(private val additionalCheckers: Iterable<Addition
 }
 
 public interface AdditionalAnnotationChecker {
-    public fun checkEntries(entries: List<JetAnnotationEntry>, actualTargets: List<KotlinTarget>, trace: BindingTrace)
+    public fun checkEntries(entries: List<KtAnnotationEntry>, actualTargets: List<KotlinTarget>, trace: BindingTrace)
 }
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java
index 1de3597ed50..f58f2aa48b0 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java
@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.storage.StorageManager;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import javax.inject.Inject;
 import java.util.ArrayList;
@@ -71,7 +71,7 @@ public class AnnotationResolver {
     @NotNull
     public Annotations resolveAnnotationsWithoutArguments(
             @NotNull LexicalScope scope,
-            @Nullable JetModifierList modifierList,
+            @Nullable KtModifierList modifierList,
             @NotNull BindingTrace trace
     ) {
         return resolveAnnotations(scope, modifierList, trace, false);
@@ -80,7 +80,7 @@ public class AnnotationResolver {
     @NotNull
     public Annotations resolveAnnotationsWithArguments(
             @NotNull LexicalScope scope,
-            @Nullable JetModifierList modifierList,
+            @Nullable KtModifierList modifierList,
             @NotNull BindingTrace trace
     ) {
         return resolveAnnotations(scope, modifierList, trace, true);
@@ -89,7 +89,7 @@ public class AnnotationResolver {
     @NotNull
     public Annotations resolveAnnotationsWithoutArguments(
             @NotNull LexicalScope scope,
-            @NotNull List<JetAnnotationEntry> annotationEntries,
+            @NotNull List<KtAnnotationEntry> annotationEntries,
             @NotNull BindingTrace trace
     ) {
         return resolveAnnotationEntries(scope, annotationEntries, trace, false);
@@ -98,7 +98,7 @@ public class AnnotationResolver {
     @NotNull
     public Annotations resolveAnnotationsWithArguments(
             @NotNull LexicalScope scope,
-            @NotNull List<JetAnnotationEntry> annotationEntries,
+            @NotNull List<KtAnnotationEntry> annotationEntries,
             @NotNull BindingTrace trace
     ) {
         return resolveAnnotationEntries(scope, annotationEntries, trace, true);
@@ -106,7 +106,7 @@ public class AnnotationResolver {
 
     private Annotations resolveAnnotations(
             @NotNull LexicalScope scope,
-            @Nullable JetModifierList modifierList,
+            @Nullable KtModifierList modifierList,
             @NotNull BindingTrace trace,
             boolean shouldResolveArguments
     ) {
@@ -119,14 +119,14 @@ public class AnnotationResolver {
 
     private Annotations resolveAnnotationEntries(
             @NotNull LexicalScope scope,
-            @NotNull List<JetAnnotationEntry> annotationEntryElements,
+            @NotNull List<KtAnnotationEntry> annotationEntryElements,
             @NotNull BindingTrace trace,
             boolean shouldResolveArguments
     ) {
         if (annotationEntryElements.isEmpty()) return Annotations.Companion.getEMPTY();
         List<AnnotationWithTarget> result = new ArrayList<AnnotationWithTarget>(0);
 
-        for (JetAnnotationEntry entryElement : annotationEntryElements) {
+        for (KtAnnotationEntry entryElement : annotationEntryElements) {
             AnnotationDescriptor descriptor = trace.get(BindingContext.ANNOTATION, entryElement);
             if (descriptor == null) {
                 descriptor = new LazyAnnotationDescriptor(new LazyAnnotationsContextImpl(this, storageManager, trace, scope), entryElement);
@@ -135,7 +135,7 @@ public class AnnotationResolver {
                 ForceResolveUtil.forceResolveAllContents(descriptor);
             }
 
-            JetAnnotationUseSiteTarget target = entryElement.getUseSiteTarget();
+            KtAnnotationUseSiteTarget target = entryElement.getUseSiteTarget();
             if (target != null) {
                 result.add(new AnnotationWithTarget(descriptor, target.getAnnotationUseSiteTarget()));
             }
@@ -147,13 +147,13 @@ public class AnnotationResolver {
     }
 
     @NotNull
-    public JetType resolveAnnotationType(@NotNull LexicalScope scope, @NotNull JetAnnotationEntry entryElement, @NotNull BindingTrace trace) {
-        JetTypeReference typeReference = entryElement.getTypeReference();
+    public KtType resolveAnnotationType(@NotNull LexicalScope scope, @NotNull KtAnnotationEntry entryElement, @NotNull BindingTrace trace) {
+        KtTypeReference typeReference = entryElement.getTypeReference();
         if (typeReference == null) {
             return ErrorUtils.createErrorType("No type reference: " + entryElement.getText());
         }
 
-        JetType type = typeResolver.resolveType(scope, typeReference, trace, true);
+        KtType type = typeResolver.resolveType(scope, typeReference, trace, true);
         if (!(type.getConstructor().getDeclarationDescriptor() instanceof ClassDescriptor)) {
             return ErrorUtils.createErrorType("Not an annotation: " + type);
         }
@@ -161,7 +161,7 @@ public class AnnotationResolver {
     }
 
     public static void checkAnnotationType(
-            @NotNull JetAnnotationEntry entryElement,
+            @NotNull KtAnnotationEntry entryElement,
             @NotNull BindingTrace trace,
             @NotNull OverloadResolutionResults<FunctionDescriptor> results
     ) {
@@ -183,7 +183,7 @@ public class AnnotationResolver {
 
     @NotNull
     public OverloadResolutionResults<FunctionDescriptor> resolveAnnotationCall(
-            JetAnnotationEntry annotationEntry,
+            KtAnnotationEntry annotationEntry,
             LexicalScope scope,
             BindingTrace trace
     ) {
@@ -196,11 +196,11 @@ public class AnnotationResolver {
         );
     }
 
-    public static void reportUnsupportedAnnotationForTypeParameter(@NotNull JetTypeParameter jetTypeParameter, @NotNull BindingTrace trace) {
-        JetModifierList modifierList = jetTypeParameter.getModifierList();
+    public static void reportUnsupportedAnnotationForTypeParameter(@NotNull KtTypeParameter jetTypeParameter, @NotNull BindingTrace trace) {
+        KtModifierList modifierList = jetTypeParameter.getModifierList();
         if (modifierList == null) return;
 
-        for (JetAnnotationEntry annotationEntry : modifierList.getAnnotationEntries()) {
+        for (KtAnnotationEntry annotationEntry : modifierList.getAnnotationEntries()) {
             trace.report(Errors.UNSUPPORTED.on(annotationEntry, "Annotations for type parameters are not supported yet"));
         }
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUseSiteTargetChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUseSiteTargetChecker.kt
index 3356396e2f5..8d5c6facb55 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUseSiteTargetChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUseSiteTargetChecker.kt
@@ -23,10 +23,10 @@ import org.jetbrains.kotlin.psi.*
 
 public object AnnotationUseSiteTargetChecker {
 
-    public fun check(annotated: JetAnnotated, descriptor: DeclarationDescriptor, trace: BindingTrace) {
+    public fun check(annotated: KtAnnotated, descriptor: DeclarationDescriptor, trace: BindingTrace) {
         trace.checkDeclaration(annotated, descriptor)
 
-        if (annotated is JetFunction) {
+        if (annotated is KtFunction) {
             for (parameter in annotated.valueParameters) {
                 val parameterDescriptor = trace.bindingContext[BindingContext.VALUE_PARAMETER, parameter] ?: continue
                 trace.checkDeclaration(parameter, parameterDescriptor)
@@ -57,7 +57,7 @@ public object AnnotationUseSiteTargetChecker {
         }
     }
 
-    private fun BindingTrace.checkDeclaration(annotated: JetAnnotated, descriptor: DeclarationDescriptor) {
+    private fun BindingTrace.checkDeclaration(annotated: KtAnnotated, descriptor: DeclarationDescriptor) {
         for (annotation in annotated.annotationEntries) {
             val target = annotation.useSiteTarget?.getAnnotationUseSiteTarget() ?: continue
 
@@ -67,7 +67,7 @@ public object AnnotationUseSiteTargetChecker {
                 AnnotationUseSiteTarget.PROPERTY_GETTER -> checkIfProperty(annotated, annotation)
                 AnnotationUseSiteTarget.PROPERTY_SETTER -> checkIfMutableProperty(annotated, annotation)
                 AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER -> {
-                    if (annotated !is JetParameter) {
+                    if (annotated !is KtParameter) {
                         report(INAPPLICABLE_PARAM_TARGET.on(annotation))
                     }
                     else {
@@ -88,35 +88,35 @@ public object AnnotationUseSiteTargetChecker {
     }
 
     private fun BindingTrace.checkFieldTargetApplicability(
-            annotated: JetAnnotated,
-            annotation: JetAnnotationEntry,
+            annotated: KtAnnotated,
+            annotation: KtAnnotationEntry,
             descriptor: DeclarationDescriptor
     ) {
         if (!checkIfProperty(annotated, annotation)) return
 
-        if (annotated is JetProperty && descriptor is PropertyDescriptor) {
+        if (annotated is KtProperty && descriptor is PropertyDescriptor) {
             if (!annotated.hasDelegate() && !(bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, descriptor) ?: false)) {
                 report(INAPPLICABLE_FIELD_TARGET_NO_BACKING_FIELD.on(annotation))
             }
         }
     }
 
-    private fun BindingTrace.checkIfMutableProperty(annotated: JetAnnotated, annotation: JetAnnotationEntry) {
+    private fun BindingTrace.checkIfMutableProperty(annotated: KtAnnotated, annotation: KtAnnotationEntry) {
         if (!checkIfProperty(annotated, annotation)) return
 
-        val isMutable = if (annotated is JetProperty)
+        val isMutable = if (annotated is KtProperty)
             annotated.isVar
-        else if (annotated is JetParameter)
+        else if (annotated is KtParameter)
             annotated.isMutable
         else false
 
         if (!isMutable) report(INAPPLICABLE_TARGET_PROPERTY_IMMUTABLE.on(annotation))
     }
 
-    private fun BindingTrace.checkIfProperty(annotated: JetAnnotated, annotation: JetAnnotationEntry): Boolean {
-        val isProperty = if (annotated is JetProperty)
+    private fun BindingTrace.checkIfProperty(annotated: KtAnnotated, annotation: KtAnnotationEntry): Boolean {
+        val isProperty = if (annotated is KtProperty)
             !annotated.isLocal
-        else if (annotated is JetParameter)
+        else if (annotated is KtParameter)
             annotated.hasValOrVar()
         else false
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt
index c7901b31ab4..30377006271 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt
@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java
index 7ccbcdd5fb9..de37571c90a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java
@@ -33,11 +33,11 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
-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.resolve.scopes.receivers.Qualifier;
 import org.jetbrains.kotlin.types.DeferredType;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.expressions.CaptureKind;
 import org.jetbrains.kotlin.types.expressions.JetTypeInfo;
 import org.jetbrains.kotlin.types.expressions.PreliminaryDeclarationVisitor;
@@ -77,7 +77,7 @@ public interface BindingContext {
 
         @Nullable
         @Override
-        public JetType getType(@NotNull JetExpression expression) {
+        public KtType getType(@NotNull KtExpression expression) {
             return null;
         }
 
@@ -87,71 +87,71 @@ public interface BindingContext {
         }
     };
 
-    WritableSlice<JetAnnotationEntry, AnnotationDescriptor> ANNOTATION = Slices.createSimpleSlice();
+    WritableSlice<KtAnnotationEntry, AnnotationDescriptor> ANNOTATION = Slices.createSimpleSlice();
 
-    WritableSlice<JetExpression, CompileTimeConstant<?>> COMPILE_TIME_VALUE = Slices.createSimpleSlice();
+    WritableSlice<KtExpression, CompileTimeConstant<?>> COMPILE_TIME_VALUE = Slices.createSimpleSlice();
 
-    WritableSlice<JetTypeReference, JetType> TYPE = Slices.createSimpleSlice();
-    WritableSlice<JetExpression, JetTypeInfo> EXPRESSION_TYPE_INFO = new BasicWritableSlice<JetExpression, JetTypeInfo>(DO_NOTHING);
-    WritableSlice<JetExpression, JetType> EXPECTED_EXPRESSION_TYPE = new BasicWritableSlice<JetExpression, JetType>(DO_NOTHING);
-    WritableSlice<JetFunction, JetType> EXPECTED_RETURN_TYPE = new BasicWritableSlice<JetFunction, JetType>(DO_NOTHING);
-    WritableSlice<JetExpression, DataFlowInfo> DATAFLOW_INFO_AFTER_CONDITION = Slices.createSimpleSlice();
+    WritableSlice<KtTypeReference, KtType> TYPE = Slices.createSimpleSlice();
+    WritableSlice<KtExpression, JetTypeInfo> EXPRESSION_TYPE_INFO = new BasicWritableSlice<KtExpression, JetTypeInfo>(DO_NOTHING);
+    WritableSlice<KtExpression, KtType> EXPECTED_EXPRESSION_TYPE = new BasicWritableSlice<KtExpression, KtType>(DO_NOTHING);
+    WritableSlice<KtFunction, KtType> EXPECTED_RETURN_TYPE = new BasicWritableSlice<KtFunction, KtType>(DO_NOTHING);
+    WritableSlice<KtExpression, DataFlowInfo> DATAFLOW_INFO_AFTER_CONDITION = Slices.createSimpleSlice();
 
     /**
      * A qualifier corresponds to a receiver expression (if any). For 'A.B' qualifier is recorded for 'A'.
      */
-    WritableSlice<JetExpression, Qualifier> QUALIFIER = new BasicWritableSlice<JetExpression, Qualifier>(DO_NOTHING);
+    WritableSlice<KtExpression, Qualifier> QUALIFIER = new BasicWritableSlice<KtExpression, Qualifier>(DO_NOTHING);
 
-    WritableSlice<JetReferenceExpression, DeclarationDescriptor> REFERENCE_TARGET =
-            new BasicWritableSlice<JetReferenceExpression, DeclarationDescriptor>(DO_NOTHING);
+    WritableSlice<KtReferenceExpression, DeclarationDescriptor> REFERENCE_TARGET =
+            new BasicWritableSlice<KtReferenceExpression, DeclarationDescriptor>(DO_NOTHING);
     // if 'A' really means 'A.Companion' then this slice stores class descriptor for A, REFERENCE_TARGET stores descriptor Companion in this case
-    WritableSlice<JetReferenceExpression, ClassDescriptor> SHORT_REFERENCE_TO_COMPANION_OBJECT =
-            new BasicWritableSlice<JetReferenceExpression, ClassDescriptor>(DO_NOTHING);
+    WritableSlice<KtReferenceExpression, ClassDescriptor> SHORT_REFERENCE_TO_COMPANION_OBJECT =
+            new BasicWritableSlice<KtReferenceExpression, ClassDescriptor>(DO_NOTHING);
 
     WritableSlice<Call, ResolvedCall<?>> RESOLVED_CALL = new BasicWritableSlice<Call, ResolvedCall<?>>(DO_NOTHING);
     WritableSlice<ResolvedCall<?>, TailRecursionKind> TAIL_RECURSION_CALL = Slices.createSimpleSlice();
-    WritableSlice<JetElement, ConstraintSystemCompleter> CONSTRAINT_SYSTEM_COMPLETER = new BasicWritableSlice<JetElement, ConstraintSystemCompleter>(DO_NOTHING);
-    WritableSlice<JetElement, Call> CALL = new BasicWritableSlice<JetElement, Call>(DO_NOTHING);
+    WritableSlice<KtElement, ConstraintSystemCompleter> CONSTRAINT_SYSTEM_COMPLETER = new BasicWritableSlice<KtElement, ConstraintSystemCompleter>(DO_NOTHING);
+    WritableSlice<KtElement, Call> CALL = new BasicWritableSlice<KtElement, Call>(DO_NOTHING);
 
-    WritableSlice<JetExpression, Collection<? extends DeclarationDescriptor>> AMBIGUOUS_REFERENCE_TARGET =
-            new BasicWritableSlice<JetExpression, Collection<? extends DeclarationDescriptor>>(DO_NOTHING);
+    WritableSlice<KtExpression, Collection<? extends DeclarationDescriptor>> AMBIGUOUS_REFERENCE_TARGET =
+            new BasicWritableSlice<KtExpression, Collection<? extends DeclarationDescriptor>>(DO_NOTHING);
 
-    WritableSlice<JetExpression, ResolvedCall<FunctionDescriptor>> LOOP_RANGE_ITERATOR_RESOLVED_CALL = Slices.createSimpleSlice();
+    WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> LOOP_RANGE_ITERATOR_RESOLVED_CALL = Slices.createSimpleSlice();
 
-    WritableSlice<JetExpression, ResolvedCall<FunctionDescriptor>> LOOP_RANGE_HAS_NEXT_RESOLVED_CALL = Slices.createSimpleSlice();
-    WritableSlice<JetExpression, ResolvedCall<FunctionDescriptor>> LOOP_RANGE_NEXT_RESOLVED_CALL = Slices.createSimpleSlice();
+    WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> LOOP_RANGE_HAS_NEXT_RESOLVED_CALL = Slices.createSimpleSlice();
+    WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> LOOP_RANGE_NEXT_RESOLVED_CALL = Slices.createSimpleSlice();
 
     WritableSlice<PropertyAccessorDescriptor, ResolvedCall<FunctionDescriptor>> DELEGATED_PROPERTY_RESOLVED_CALL = Slices.createSimpleSlice();
     WritableSlice<PropertyAccessorDescriptor, Call> DELEGATED_PROPERTY_CALL = Slices.createSimpleSlice();
 
     WritableSlice<PropertyDescriptor, ResolvedCall<FunctionDescriptor>> DELEGATED_PROPERTY_PD_RESOLVED_CALL = Slices.createSimpleSlice();
 
-    WritableSlice<JetMultiDeclarationEntry, ResolvedCall<FunctionDescriptor>> COMPONENT_RESOLVED_CALL = Slices.createSimpleSlice();
+    WritableSlice<KtMultiDeclarationEntry, ResolvedCall<FunctionDescriptor>> COMPONENT_RESOLVED_CALL = Slices.createSimpleSlice();
 
-    WritableSlice<JetExpression, ResolvedCall<FunctionDescriptor>> INDEXED_LVALUE_GET = Slices.createSimpleSlice();
-    WritableSlice<JetExpression, ResolvedCall<FunctionDescriptor>> INDEXED_LVALUE_SET = Slices.createSimpleSlice();
+    WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> INDEXED_LVALUE_GET = Slices.createSimpleSlice();
+    WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> INDEXED_LVALUE_SET = Slices.createSimpleSlice();
 
-    WritableSlice<JetExpression, JetType> SMARTCAST = Slices.createSimpleSlice();
+    WritableSlice<KtExpression, KtType> SMARTCAST = Slices.createSimpleSlice();
 
-    WritableSlice<JetWhenExpression, Boolean> EXHAUSTIVE_WHEN = Slices.createSimpleSlice();
+    WritableSlice<KtWhenExpression, Boolean> EXHAUSTIVE_WHEN = Slices.createSimpleSlice();
 
-    @Deprecated WritableSlice<JetExpression, JetScope> RESOLUTION_SCOPE = Slices.createSimpleSlice();
-    WritableSlice<JetElement, LexicalScope> LEXICAL_SCOPE = Slices.createSimpleSlice();
+    @Deprecated WritableSlice<KtExpression, KtScope> RESOLUTION_SCOPE = Slices.createSimpleSlice();
+    WritableSlice<KtElement, LexicalScope> LEXICAL_SCOPE = Slices.createSimpleSlice();
 
-    WritableSlice<ScriptDescriptor, JetScope> SCRIPT_SCOPE = Slices.createSimpleSlice();
+    WritableSlice<ScriptDescriptor, KtScope> SCRIPT_SCOPE = Slices.createSimpleSlice();
 
-    WritableSlice<JetExpression, Boolean> VARIABLE_REASSIGNMENT = Slices.createSimpleSetSlice();
+    WritableSlice<KtExpression, Boolean> VARIABLE_REASSIGNMENT = Slices.createSimpleSetSlice();
     WritableSlice<ValueParameterDescriptor, Boolean> AUTO_CREATED_IT = Slices.createSimpleSetSlice();
 
     /**
      * Has type of current expression has been already resolved
      */
-    WritableSlice<JetExpression, Boolean> PROCESSED = Slices.createSimpleSetSlice();
-    WritableSlice<JetElement, Boolean> USED_AS_EXPRESSION = Slices.createSimpleSetSlice();
-    WritableSlice<JetElement, Boolean> UNREACHABLE_CODE = Slices.createSimpleSetSlice();
+    WritableSlice<KtExpression, Boolean> PROCESSED = Slices.createSimpleSetSlice();
+    WritableSlice<KtElement, Boolean> USED_AS_EXPRESSION = Slices.createSimpleSetSlice();
+    WritableSlice<KtElement, Boolean> UNREACHABLE_CODE = Slices.createSimpleSetSlice();
 
     WritableSlice<VariableDescriptor, CaptureKind> CAPTURED_IN_CLOSURE = new BasicWritableSlice<VariableDescriptor, CaptureKind>(DO_NOTHING);
-    WritableSlice<JetDeclaration, PreliminaryDeclarationVisitor> PRELIMINARY_VISITOR = new BasicWritableSlice<JetDeclaration, PreliminaryDeclarationVisitor>(DO_NOTHING);
+    WritableSlice<KtDeclaration, PreliminaryDeclarationVisitor> PRELIMINARY_VISITOR = new BasicWritableSlice<KtDeclaration, PreliminaryDeclarationVisitor>(DO_NOTHING);
 
     WritableSlice<CallableMemberDescriptor, Boolean> NEED_SYNTHETIC_ACCESSOR = new BasicWritableSlice<CallableMemberDescriptor, Boolean>(DO_NOTHING);
 
@@ -170,8 +170,8 @@ public interface BindingContext {
             }
             backingFieldRequired = valueNotFound ? false : backingFieldRequired;
             PsiElement declarationPsiElement = DescriptorToSourceUtils.descriptorToDeclaration(propertyDescriptor);
-            if (declarationPsiElement instanceof JetParameter) {
-                JetParameter jetParameter = (JetParameter) declarationPsiElement;
+            if (declarationPsiElement instanceof KtParameter) {
+                KtParameter jetParameter = (KtParameter) declarationPsiElement;
                 return jetParameter.hasValOrVar() ||
                        backingFieldRequired; // this part is unused because we do not allow access to constructor parameters in member bodies
             }
@@ -189,9 +189,9 @@ public interface BindingContext {
     };
     WritableSlice<PropertyDescriptor, Boolean> IS_UNINITIALIZED = Slices.createSimpleSetSlice();
 
-    WritableSlice<JetFunctionLiteralExpression, Boolean> BLOCK = new Slices.SetSlice<JetFunctionLiteralExpression>(DO_NOTHING) {
+    WritableSlice<KtFunctionLiteralExpression, Boolean> BLOCK = new Slices.SetSlice<KtFunctionLiteralExpression>(DO_NOTHING) {
         @Override
-        public Boolean computeValue(SlicedMap map, JetFunctionLiteralExpression expression, Boolean isBlock, boolean valueNotFound) {
+        public Boolean computeValue(SlicedMap map, KtFunctionLiteralExpression expression, Boolean isBlock, boolean valueNotFound) {
             isBlock = valueNotFound ? false : isBlock;
             return isBlock && !expression.getFunctionLiteral().hasParameterSpecification();
         }
@@ -199,7 +199,7 @@ public interface BindingContext {
 
     WritableSlice<PsiElement, ClassDescriptor> CLASS = Slices.createSimpleSlice();
     WritableSlice<PsiElement, ScriptDescriptor> SCRIPT = Slices.createSimpleSlice();
-    WritableSlice<JetTypeParameter, TypeParameterDescriptor> TYPE_PARAMETER = Slices.createSimpleSlice();
+    WritableSlice<KtTypeParameter, TypeParameterDescriptor> TYPE_PARAMETER = Slices.createSimpleSlice();
     /**
      * @see BindingContextUtils#recordFunctionDeclarationToDescriptor(BindingTrace, PsiElement, SimpleFunctionDescriptor)}
      */
@@ -208,8 +208,8 @@ public interface BindingContext {
     WritableSlice<ConstructorDescriptor, ResolvedCall<ConstructorDescriptor>> CONSTRUCTOR_RESOLVED_DELEGATION_CALL =
             Slices.createSimpleSlice();
     WritableSlice<PsiElement, VariableDescriptor> VARIABLE = Slices.createSimpleSlice();
-    WritableSlice<JetParameter, VariableDescriptor> VALUE_PARAMETER = Slices.createSimpleSlice();
-    WritableSlice<JetPropertyAccessor, PropertyAccessorDescriptor> PROPERTY_ACCESSOR = Slices.createSimpleSlice();
+    WritableSlice<KtParameter, VariableDescriptor> VALUE_PARAMETER = Slices.createSimpleSlice();
+    WritableSlice<KtPropertyAccessor, PropertyAccessorDescriptor> PROPERTY_ACCESSOR = Slices.createSimpleSlice();
     WritableSlice<PsiElement, PropertyDescriptor> PRIMARY_CONSTRUCTOR_PARAMETER = Slices.createSimpleSlice();
 
     WritableSlice[] DECLARATIONS_TO_DESCRIPTORS = new WritableSlice[] {
@@ -223,8 +223,8 @@ public interface BindingContext {
                     .setFurtherLookupSlices(DECLARATIONS_TO_DESCRIPTORS)
                     .build();
 
-    WritableSlice<JetReferenceExpression, PsiElement> LABEL_TARGET = Slices.createSimpleSlice();
-    WritableSlice<JetReferenceExpression, Collection<? extends PsiElement>> AMBIGUOUS_LABEL_TARGET = Slices.createSimpleSlice();
+    WritableSlice<KtReferenceExpression, PsiElement> LABEL_TARGET = Slices.createSimpleSlice();
+    WritableSlice<KtReferenceExpression, Collection<? extends PsiElement>> AMBIGUOUS_LABEL_TARGET = Slices.createSimpleSlice();
     WritableSlice<ValueParameterDescriptor, PropertyDescriptor> VALUE_PARAMETER_AS_PROPERTY = Slices.createSimpleSlice();
 
     WritableSlice<ValueParameterDescriptor, FunctionDescriptor> DATA_CLASS_COMPONENT_FUNCTION = Slices.createSimpleSlice();
@@ -232,8 +232,8 @@ public interface BindingContext {
 
     WritableSlice<FqNameUnsafe, ClassDescriptor> FQNAME_TO_CLASS_DESCRIPTOR =
             new BasicWritableSlice<FqNameUnsafe, ClassDescriptor>(DO_NOTHING, true);
-    WritableSlice<JetFile, PackageFragmentDescriptor> FILE_TO_PACKAGE_FRAGMENT = Slices.createSimpleSlice();
-    WritableSlice<FqName, Collection<JetFile>> PACKAGE_TO_FILES = Slices.createSimpleSlice();
+    WritableSlice<KtFile, PackageFragmentDescriptor> FILE_TO_PACKAGE_FRAGMENT = Slices.createSimpleSlice();
+    WritableSlice<FqName, Collection<KtFile>> PACKAGE_TO_FILES = Slices.createSimpleSlice();
 
     @SuppressWarnings("UnusedDeclaration")
     @Deprecated // This field is needed only for the side effects of its initializer
@@ -256,7 +256,7 @@ public interface BindingContext {
     <K, V> ImmutableMap<K, V> getSliceContents(@NotNull ReadOnlySlice<K, V> slice);
 
     @Nullable
-    JetType getType(@NotNull JetExpression expression);
+    KtType getType(@NotNull KtExpression expression);
 
     void addOwnDataTo(@NotNull BindingTrace trace, boolean commitDiagnostics);
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java
index 1cbb31d308c..7bd3fc39b38 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.java
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.diagnostics.MutableDiagnosticsWithSuppression;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.kotlin.types.expressions.JetTypeInfo;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt;
@@ -49,16 +49,16 @@ public class BindingContextUtils {
     }
 
     @Nullable
-    public static VariableDescriptor extractVariableDescriptorIfAny(@NotNull BindingContext bindingContext, @Nullable JetElement element, boolean onlyReference) {
+    public static VariableDescriptor extractVariableDescriptorIfAny(@NotNull BindingContext bindingContext, @Nullable KtElement element, boolean onlyReference) {
         DeclarationDescriptor descriptor = null;
-        if (!onlyReference && (element instanceof JetVariableDeclaration || element instanceof JetParameter)) {
+        if (!onlyReference && (element instanceof KtVariableDeclaration || element instanceof KtParameter)) {
             descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element);
         }
-        else if (element instanceof JetSimpleNameExpression) {
-            descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) element);
+        else if (element instanceof KtSimpleNameExpression) {
+            descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, (KtSimpleNameExpression) element);
         }
-        else if (element instanceof JetQualifiedExpression) {
-            descriptor = extractVariableDescriptorIfAny(bindingContext, ((JetQualifiedExpression) element).getSelectorExpression(), onlyReference);
+        else if (element instanceof KtQualifiedExpression) {
+            descriptor = extractVariableDescriptorIfAny(bindingContext, ((KtQualifiedExpression) element).getSelectorExpression(), onlyReference);
         }
         if (descriptor instanceof VariableDescriptor) {
             return (VariableDescriptor) descriptor;
@@ -81,11 +81,11 @@ public class BindingContextUtils {
     }
 
     @NotNull
-    public static JetType getTypeNotNull(
+    public static KtType getTypeNotNull(
             @NotNull BindingContext bindingContext,
-            @NotNull JetExpression expression
+            @NotNull KtExpression expression
     ) {
-        JetType result = bindingContext.getType(expression);
+        KtType result = bindingContext.getType(expression);
         if (result == null) {
             throw new IllegalStateException("Type must be not null for " + expression);
         }
@@ -107,9 +107,9 @@ public class BindingContextUtils {
     }
 
     @NotNull
-    public static DeclarationDescriptor getEnclosingDescriptor(@NotNull BindingContext context, @NotNull JetElement element) {
-        JetNamedDeclaration declaration = PsiTreeUtil.getParentOfType(element, JetNamedDeclaration.class);
-        if (declaration instanceof JetFunctionLiteral) {
+    public static DeclarationDescriptor getEnclosingDescriptor(@NotNull BindingContext context, @NotNull KtElement element) {
+        KtNamedDeclaration declaration = PsiTreeUtil.getParentOfType(element, KtNamedDeclaration.class);
+        if (declaration instanceof KtFunctionLiteral) {
             return getEnclosingDescriptor(context, declaration);
         }
         DeclarationDescriptor descriptor = context.get(DECLARATION_TO_DESCRIPTOR, declaration);
@@ -117,14 +117,14 @@ public class BindingContextUtils {
         return descriptor;
     }
 
-    public static FunctionDescriptor getEnclosingFunctionDescriptor(@NotNull BindingContext context, @NotNull JetElement element) {
-        JetFunction function = PsiTreeUtil.getParentOfType(element, JetFunction.class);
+    public static FunctionDescriptor getEnclosingFunctionDescriptor(@NotNull BindingContext context, @NotNull KtElement element) {
+        KtFunction function = PsiTreeUtil.getParentOfType(element, KtFunction.class);
         return (FunctionDescriptor)context.get(DECLARATION_TO_DESCRIPTOR, function);
     }
 
     public static void reportAmbiguousLabel(
             @NotNull BindingTrace trace,
-            @NotNull JetSimpleNameExpression targetLabel,
+            @NotNull KtSimpleNameExpression targetLabel,
             @NotNull Collection<DeclarationDescriptor> declarationsByLabel
     ) {
         Collection<PsiElement> targets = Lists.newArrayList();
@@ -140,9 +140,9 @@ public class BindingContextUtils {
     }
 
     @Nullable
-    public static JetType updateRecordedType(
-            @Nullable JetType type,
-            @NotNull JetExpression expression,
+    public static KtType updateRecordedType(
+            @Nullable KtType type,
+            @NotNull KtExpression expression,
             @NotNull BindingTrace trace,
             boolean shouldBeMadeNullable
     ) {
@@ -155,7 +155,7 @@ public class BindingContextUtils {
     }
 
     @Nullable
-    public static JetTypeInfo getRecordedTypeInfo(@NotNull JetExpression expression, @NotNull BindingContext context) {
+    public static JetTypeInfo getRecordedTypeInfo(@NotNull KtExpression expression, @NotNull BindingContext context) {
         // noinspection ConstantConditions
         if (!context.get(BindingContext.PROCESSED, expression)) return null;
         // NB: should never return null if expression is already processed
@@ -164,14 +164,14 @@ public class BindingContextUtils {
     }
 
     public static boolean isExpressionWithValidReference(
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             @NotNull BindingContext context
     ) {
-        if (expression instanceof JetCallExpression) {
+        if (expression instanceof KtCallExpression) {
             ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(expression, context);
             return resolvedCall instanceof VariableAsFunctionResolvedCall;
         }
-        return expression instanceof JetReferenceExpression;
+        return expression instanceof KtReferenceExpression;
     }
 
     public static boolean isVarCapturedInClosure(BindingContext bindingContext, DeclarationDescriptor descriptor) {
@@ -188,7 +188,7 @@ public class BindingContextUtils {
         FunctionDescriptor containingFunctionDescriptor = DescriptorUtils.getParentOfType(startDescriptor, FunctionDescriptor.class, strict);
         PsiElement containingFunction =
                 containingFunctionDescriptor != null ? DescriptorToSourceUtils.getSourceFromDescriptor(containingFunctionDescriptor) : null;
-        while (containingFunction instanceof JetFunctionLiteral) {
+        while (containingFunction instanceof KtFunctionLiteral) {
             containingFunctionDescriptor = DescriptorUtils.getParentOfType(containingFunctionDescriptor, FunctionDescriptor.class);
             containingFunction = containingFunctionDescriptor != null ? DescriptorToSourceUtils
                     .getSourceFromDescriptor(containingFunctionDescriptor) : null;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.kt
index 48a0d3eea7f..ca74e7d73a8 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.kt
@@ -38,11 +38,11 @@ import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice
 
 public operator fun <K, V: Any> BindingContext.get(slice: ReadOnlySlice<K, V>, key: K): V? = get(slice, key)
 
-public fun JetReturnExpression.getTargetFunctionDescriptor(context: BindingContext): FunctionDescriptor? {
+public fun KtReturnExpression.getTargetFunctionDescriptor(context: BindingContext): FunctionDescriptor? {
     val targetLabel = getTargetLabel()
     if (targetLabel != null) return context[LABEL_TARGET, targetLabel]?.let { context[FUNCTION, it] }
 
-    val declarationDescriptor = context[DECLARATION_TO_DESCRIPTOR, getNonStrictParentOfType<JetDeclarationWithBody>()]
+    val declarationDescriptor = context[DECLARATION_TO_DESCRIPTOR, getNonStrictParentOfType<KtDeclarationWithBody>()]
     val containingFunctionDescriptor = DescriptorUtils.getParentOfType(declarationDescriptor, javaClass<FunctionDescriptor>(), false)
     if (containingFunctionDescriptor == null) return null
 
@@ -51,15 +51,15 @@ public fun JetReturnExpression.getTargetFunctionDescriptor(context: BindingConte
             .firstOrNull()
 }
 
-public fun JetReturnExpression.getTargetFunction(context: BindingContext): JetCallableDeclaration? {
-    return getTargetFunctionDescriptor(context)?.let { DescriptorToSourceUtils.descriptorToDeclaration(it) as? JetCallableDeclaration }
+public fun KtReturnExpression.getTargetFunction(context: BindingContext): KtCallableDeclaration? {
+    return getTargetFunctionDescriptor(context)?.let { DescriptorToSourceUtils.descriptorToDeclaration(it) as? KtCallableDeclaration }
 }
 
-public fun JetExpression.isUsedAsExpression(context: BindingContext): Boolean = context[BindingContext.USED_AS_EXPRESSION, this]!!
-public fun JetExpression.isUsedAsStatement(context: BindingContext): Boolean = !isUsedAsExpression(context)
+public fun KtExpression.isUsedAsExpression(context: BindingContext): Boolean = context[BindingContext.USED_AS_EXPRESSION, this]!!
+public fun KtExpression.isUsedAsStatement(context: BindingContext): Boolean = !isUsedAsExpression(context)
 
 
-public fun <C : ResolutionContext<C>> ResolutionContext<C>.recordDataFlowInfo(expression: JetExpression?) {
+public fun <C : ResolutionContext<C>> ResolutionContext<C>.recordDataFlowInfo(expression: KtExpression?) {
     if (expression == null) return
 
     val typeInfo = trace.get(BindingContext.EXPRESSION_TYPE_INFO, expression)
@@ -72,24 +72,24 @@ public fun <C : ResolutionContext<C>> ResolutionContext<C>.recordDataFlowInfo(ex
     }
 }
 
-public fun BindingTrace.recordScope(scope: LexicalScope, element: JetElement?) {
+public fun BindingTrace.recordScope(scope: LexicalScope, element: KtElement?) {
     if (element == null) return
 
     val scopeToRecord = scope.takeSnapshot()
     record(BindingContext.LEXICAL_SCOPE, element, scopeToRecord)
 
     // todo: remove it later
-    if (element is JetExpression) {
+    if (element is KtExpression) {
         record(BindingContext.RESOLUTION_SCOPE, element, scopeToRecord.asJetScope())
     }
 }
 
-public fun BindingContext.getDataFlowInfo(expression: JetExpression?): DataFlowInfo =
+public fun BindingContext.getDataFlowInfo(expression: KtExpression?): DataFlowInfo =
     expression?.let { this[BindingContext.EXPRESSION_TYPE_INFO, it]?.dataFlowInfo } ?: DataFlowInfo.EMPTY
 
-public fun JetExpression.isUnreachableCode(context: BindingContext): Boolean = context[BindingContext.UNREACHABLE_CODE, this]!!
+public fun KtExpression.isUnreachableCode(context: BindingContext): Boolean = context[BindingContext.UNREACHABLE_CODE, this]!!
 
-public fun JetExpression.getReferenceTargets(context: BindingContext): Collection<DeclarationDescriptor> {
-    val targetDescriptor = if (this is JetReferenceExpression) context[BindingContext.REFERENCE_TARGET, this] else null
+public fun KtExpression.getReferenceTargets(context: BindingContext): Collection<DeclarationDescriptor> {
+    val targetDescriptor = if (this is KtReferenceExpression) context[BindingContext.REFERENCE_TARGET, this] else null
     return targetDescriptor?.let { listOf(it) } ?: context[BindingContext.AMBIGUOUS_REFERENCE_TARGET, this].orEmpty()
 }
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingTrace.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingTrace.java
index 7c9792da92d..ce4578ea1ce 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingTrace.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingTrace.java
@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.resolve;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice;
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
 
@@ -47,11 +47,11 @@ public interface BindingTrace extends DiagnosticSink {
      * Expression type should be taken from EXPRESSION_TYPE_INFO slice
      */
     @Nullable
-    JetType getType(@NotNull JetExpression expression);
+    KtType getType(@NotNull KtExpression expression);
 
     /**
      * Expression type should be recorded into EXPRESSION_TYPE_INFO slice
      * (either updated old or a new one)
      */
-    void recordType(@NotNull JetExpression expression, @Nullable JetType type);
+    void recordType(@NotNull KtExpression expression, @Nullable KtType type);
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingTraceContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingTraceContext.java
index 38561ef870d..fbf2f049624 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingTraceContext.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingTraceContext.java
@@ -21,10 +21,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
 import org.jetbrains.kotlin.resolve.diagnostics.MutableDiagnosticsWithSuppression;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.expressions.JetTypeInfo;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt;
 import org.jetbrains.kotlin.util.slicedMap.*;
@@ -67,7 +67,7 @@ public class BindingTraceContext implements BindingTrace {
 
         @Nullable
         @Override
-        public JetType getType(@NotNull JetExpression expression) {
+        public KtType getType(@NotNull KtExpression expression) {
             return BindingTraceContext.this.getType(expression);
         }
 
@@ -131,13 +131,13 @@ public class BindingTraceContext implements BindingTrace {
 
     @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) {
         JetTypeInfo typeInfo = get(BindingContext.EXPRESSION_TYPE_INFO, expression);
         typeInfo = typeInfo != null ? typeInfo.replaceType(type) : TypeInfoFactoryKt.createTypeInfo(type);
         record(BindingContext.EXPRESSION_TYPE_INFO, expression, typeInfo);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java
index ac8b5998029..3559a895dba 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java
@@ -30,24 +30,24 @@ import java.util.Map;
 
 public interface BodiesResolveContext {
     @ReadOnly
-    Collection<JetFile> getFiles();
+    Collection<KtFile> getFiles();
 
     @Mutable
-    Map<JetClassOrObject, ClassDescriptorWithResolutionScopes> getDeclaredClasses();
+    Map<KtClassOrObject, ClassDescriptorWithResolutionScopes> getDeclaredClasses();
     @Mutable
-    Map<JetClassInitializer, ClassDescriptorWithResolutionScopes> getAnonymousInitializers();
+    Map<KtClassInitializer, ClassDescriptorWithResolutionScopes> getAnonymousInitializers();
     @Mutable
-    Map<JetSecondaryConstructor, ConstructorDescriptor> getSecondaryConstructors();
+    Map<KtSecondaryConstructor, ConstructorDescriptor> getSecondaryConstructors();
     @Mutable
-    Map<JetScript, ScriptDescriptor> getScripts();
+    Map<KtScript, ScriptDescriptor> getScripts();
 
     @Mutable
-    Map<JetProperty, PropertyDescriptor> getProperties();
+    Map<KtProperty, PropertyDescriptor> getProperties();
     @Mutable
-    Map<JetNamedFunction, SimpleFunctionDescriptor> getFunctions();
+    Map<KtNamedFunction, SimpleFunctionDescriptor> getFunctions();
 
     @Nullable
-    LexicalScope getDeclaringScope(@NotNull JetDeclaration declaration);
+    LexicalScope getDeclaringScope(@NotNull KtDeclaration declaration);
 
     @NotNull
     DataFlowInfo getOuterDataFlowInfo();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolveCache.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolveCache.kt
index 36151848e7b..e664322bd61 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolveCache.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolveCache.kt
@@ -16,13 +16,13 @@
 
 package org.jetbrains.kotlin.resolve
 
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtNamedFunction
 
 public interface BodyResolveCache {
-    public open fun resolveFunctionBody(function: JetNamedFunction): BindingContext
+    public open fun resolveFunctionBody(function: KtNamedFunction): BindingContext
 
     public object ThrowException : BodyResolveCache {
-        public override fun resolveFunctionBody(function: JetNamedFunction): BindingContext {
+        public override fun resolveFunctionBody(function: KtNamedFunction): BindingContext {
             throw UnsupportedOperationException()
         }
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
index f2f07bab29f..562b55781a4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor;
 import org.jetbrains.kotlin.diagnostics.Errors;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt;
 import org.jetbrains.kotlin.resolve.calls.CallResolver;
@@ -121,14 +121,14 @@ public class BodyResolver {
     }
 
     private void resolveSecondaryConstructors(@NotNull BodiesResolveContext c) {
-        for (Map.Entry<JetSecondaryConstructor, ConstructorDescriptor> entry : c.getSecondaryConstructors().entrySet()) {
+        for (Map.Entry<KtSecondaryConstructor, ConstructorDescriptor> entry : c.getSecondaryConstructors().entrySet()) {
             LexicalScope declaringScope = c.getDeclaringScope(entry.getKey());
             assert declaringScope != null : "Declaring scope should be registered before body resolve";
             resolveSecondaryConstructorBody(c.getOuterDataFlowInfo(), trace, entry.getKey(), entry.getValue(), declaringScope);
         }
         if (c.getSecondaryConstructors().isEmpty()) return;
         Set<ConstructorDescriptor> visitedConstructors = Sets.newHashSet();
-        for (Map.Entry<JetSecondaryConstructor, ConstructorDescriptor> entry : c.getSecondaryConstructors().entrySet()) {
+        for (Map.Entry<KtSecondaryConstructor, ConstructorDescriptor> entry : c.getSecondaryConstructors().entrySet()) {
             checkCyclicConstructorDelegationCall(entry.getValue(), visitedConstructors);
         }
     }
@@ -136,7 +136,7 @@ public class BodyResolver {
     public void resolveSecondaryConstructorBody(
             @NotNull final DataFlowInfo outerDataFlowInfo,
             @NotNull final BindingTrace trace,
-            @NotNull final JetSecondaryConstructor constructor,
+            @NotNull final KtSecondaryConstructor constructor,
             @NotNull final ConstructorDescriptor descriptor,
             @NotNull LexicalScope declaringScope
     ) {
@@ -159,7 +159,7 @@ public class BodyResolver {
             @NotNull DataFlowInfo outerDataFlowInfo,
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
-            @NotNull JetSecondaryConstructor constructor,
+            @NotNull KtSecondaryConstructor constructor,
             @NotNull ConstructorDescriptor descriptor,
             @NotNull CallChecker callChecker
     ) {
@@ -212,7 +212,7 @@ public class BodyResolver {
         do {
             PsiElement constructorToReport = DescriptorToSourceUtils.descriptorToDeclaration(currentConstructor);
             if (constructorToReport != null) {
-                JetConstructorDelegationCall call = ((JetSecondaryConstructor) constructorToReport).getDelegationCall();
+                KtConstructorDelegationCall call = ((KtSecondaryConstructor) constructorToReport).getDelegationCall();
                 assert call.getCalleeExpression() != null
                         : "Callee expression of delegation call should not be null on cycle as there should be explicit 'this' calls";
                 trace.report(CYCLIC_CONSTRUCTOR_DELEGATION_CALL.on(call.getCalleeExpression()));
@@ -238,8 +238,8 @@ public class BodyResolver {
 
     private void resolveDelegationSpecifierLists(@NotNull BodiesResolveContext c) {
         // TODO : Make sure the same thing is not initialized twice
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
-            JetClassOrObject classOrObject = entry.getKey();
+        for (Map.Entry<KtClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
+            KtClassOrObject classOrObject = entry.getKey();
             ClassDescriptorWithResolutionScopes descriptor = entry.getValue();
 
             resolveDelegationSpecifierList(c.getOuterDataFlowInfo(), classOrObject, descriptor,
@@ -251,7 +251,7 @@ public class BodyResolver {
 
     public void resolveDelegationSpecifierList(
             @NotNull final DataFlowInfo outerDataFlowInfo,
-            @NotNull JetClassOrObject jetClass,
+            @NotNull KtClassOrObject jetClass,
             @NotNull final ClassDescriptor descriptor,
             @Nullable final ConstructorDescriptor primaryConstructor,
             @NotNull LexicalScope scopeForSupertypeResolution,
@@ -262,20 +262,20 @@ public class BodyResolver {
                 : FunctionDescriptorUtil.getFunctionInnerScope(scopeForSupertypeResolution, primaryConstructor, trace);
         final ExpressionTypingServices typeInferrer = expressionTypingServices; // TODO : flow
 
-        final Map<JetTypeReference, JetType> supertypes = Maps.newLinkedHashMap();
+        final Map<KtTypeReference, KtType> supertypes = Maps.newLinkedHashMap();
         final ResolvedCall<?>[] primaryConstructorDelegationCall = new ResolvedCall[1];
-        JetVisitorVoid visitor = new JetVisitorVoid() {
-            private void recordSupertype(JetTypeReference typeReference, JetType supertype) {
+        KtVisitorVoid visitor = new KtVisitorVoid() {
+            private void recordSupertype(KtTypeReference typeReference, KtType supertype) {
                 if (supertype == null) return;
                 supertypes.put(typeReference, supertype);
             }
 
             @Override
-            public void visitDelegationByExpressionSpecifier(@NotNull JetDelegatorByExpressionSpecifier specifier) {
+            public void visitDelegationByExpressionSpecifier(@NotNull KtDelegatorByExpressionSpecifier specifier) {
                 if (descriptor.getKind() == ClassKind.INTERFACE) {
                     trace.report(DELEGATION_IN_INTERFACE.on(specifier));
                 }
-                JetType supertype = trace.getBindingContext().get(BindingContext.TYPE, specifier.getTypeReference());
+                KtType supertype = trace.getBindingContext().get(BindingContext.TYPE, specifier.getTypeReference());
                 recordSupertype(specifier.getTypeReference(), supertype);
                 if (supertype != null) {
                     DeclarationDescriptor declarationDescriptor = supertype.getConstructor().getDeclarationDescriptor();
@@ -286,10 +286,10 @@ public class BodyResolver {
                         }
                     }
                 }
-                JetExpression delegateExpression = specifier.getDelegateExpression();
+                KtExpression delegateExpression = specifier.getDelegateExpression();
                 if (delegateExpression != null) {
                     LexicalScope scope = scopeForConstructor == null ? scopeForMemberResolution : scopeForConstructor;
-                    JetType expectedType = supertype != null ? supertype : NO_EXPECTED_TYPE;
+                    KtType expectedType = supertype != null ? supertype : NO_EXPECTED_TYPE;
                     typeInferrer.getType(scope, delegateExpression, expectedType, outerDataFlowInfo, trace);
                 }
                 if (primaryConstructor == null) {
@@ -298,13 +298,13 @@ public class BodyResolver {
             }
 
             @Override
-            public void visitDelegationToSuperCallSpecifier(@NotNull JetDelegatorToSuperCall call) {
-                JetValueArgumentList valueArgumentList = call.getValueArgumentList();
+            public void visitDelegationToSuperCallSpecifier(@NotNull KtDelegatorToSuperCall call) {
+                KtValueArgumentList valueArgumentList = call.getValueArgumentList();
                 PsiElement elementToMark = valueArgumentList == null ? call : valueArgumentList;
                 if (descriptor.getKind() == ClassKind.INTERFACE) {
                     trace.report(SUPERTYPE_INITIALIZED_IN_INTERFACE.on(elementToMark));
                 }
-                JetTypeReference typeReference = call.getTypeReference();
+                KtTypeReference typeReference = call.getTypeReference();
                 if (typeReference == null) return;
                 if (primaryConstructor == null) {
                     if (descriptor.getKind() != ClassKind.INTERFACE) {
@@ -317,7 +317,7 @@ public class BodyResolver {
                         trace, scopeForConstructor,
                         CallMaker.makeCall(ReceiverValue.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, outerDataFlowInfo, false);
                 if (results.isSuccess()) {
-                    JetType supertype = results.getResultingDescriptor().getReturnType();
+                    KtType supertype = results.getResultingDescriptor().getReturnType();
                     recordSupertype(typeReference, supertype);
                     ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(supertype);
                     if (classDescriptor != null) {
@@ -340,9 +340,9 @@ public class BodyResolver {
             }
 
             @Override
-            public void visitDelegationToSuperClassSpecifier(@NotNull JetDelegatorToSuperClass specifier) {
-                JetTypeReference typeReference = specifier.getTypeReference();
-                JetType supertype = trace.getBindingContext().get(BindingContext.TYPE, typeReference);
+            public void visitDelegationToSuperClassSpecifier(@NotNull KtDelegatorToSuperClass specifier) {
+                KtTypeReference typeReference = specifier.getTypeReference();
+                KtType supertype = trace.getBindingContext().get(BindingContext.TYPE, typeReference);
                 recordSupertype(typeReference, supertype);
                 if (supertype == null) return;
                 ClassDescriptor superClass = TypeUtils.getClassDescriptor(supertype);
@@ -362,12 +362,12 @@ public class BodyResolver {
             }
 
             @Override
-            public void visitJetElement(@NotNull JetElement element) {
+            public void visitJetElement(@NotNull KtElement element) {
                 throw new UnsupportedOperationException(element.getText() + " : " + element);
             }
         };
 
-        for (JetDelegationSpecifier delegationSpecifier : jetClass.getDelegationSpecifiers()) {
+        for (KtDelegationSpecifier delegationSpecifier : jetClass.getDelegationSpecifiers()) {
             delegationSpecifier.accept(visitor);
         }
 
@@ -386,10 +386,10 @@ public class BodyResolver {
     @NotNull
     private static Set<TypeConstructor> getAllowedFinalSupertypes(
             @NotNull ClassDescriptor descriptor,
-            @NotNull JetClassOrObject jetClass
+            @NotNull KtClassOrObject jetClass
     ) {
         Set<TypeConstructor> parentEnumOrSealed;
-        if (jetClass instanceof JetEnumEntry) {
+        if (jetClass instanceof KtEnumEntry) {
             parentEnumOrSealed = Collections.singleton(((ClassDescriptor) descriptor.getContainingDeclaration()).getTypeConstructor());
         }
         else {
@@ -419,19 +419,19 @@ public class BodyResolver {
 
     private void checkSupertypeList(
             @NotNull ClassDescriptor supertypeOwner,
-            @NotNull Map<JetTypeReference, JetType> supertypes,
-            @NotNull JetClassOrObject jetClass
+            @NotNull Map<KtTypeReference, KtType> supertypes,
+            @NotNull KtClassOrObject jetClass
     ) {
         Set<TypeConstructor> allowedFinalSupertypes = getAllowedFinalSupertypes(supertypeOwner, jetClass);
         Set<TypeConstructor> typeConstructors = Sets.newHashSet();
         boolean classAppeared = false;
-        for (Map.Entry<JetTypeReference, JetType> entry : supertypes.entrySet()) {
-            JetTypeReference typeReference = entry.getKey();
-            JetType supertype = entry.getValue();
+        for (Map.Entry<KtTypeReference, KtType> entry : supertypes.entrySet()) {
+            KtTypeReference typeReference = entry.getKey();
+            KtType supertype = entry.getValue();
 
-            JetTypeElement typeElement = typeReference.getTypeElement();
-            if (typeElement instanceof JetFunctionType) {
-                for (JetParameter parameter : ((JetFunctionType) typeElement).getParameters()) {
+            KtTypeElement typeElement = typeReference.getTypeElement();
+            if (typeElement instanceof KtFunctionType) {
+                for (KtParameter parameter : ((KtFunctionType) typeElement).getParameters()) {
                     PsiElement nameIdentifier = parameter.getNameIdentifier();
 
                     if (nameIdentifier != null) {
@@ -460,7 +460,7 @@ public class BodyResolver {
                         trace.report(INTERFACE_WITH_SUPERCLASS.on(typeReference));
                         addSupertype = false;
                     }
-                    else if (jetClass.hasModifier(JetTokens.DATA_KEYWORD)) {
+                    else if (jetClass.hasModifier(KtTokens.DATA_KEYWORD)) {
                         trace.report(DATA_CLASS_CANNOT_HAVE_CLASS_SUPERTYPES.on(typeReference));
                         addSupertype = false;
                     }
@@ -506,8 +506,8 @@ public class BodyResolver {
     }
 
     private void resolveAnonymousInitializers(@NotNull BodiesResolveContext c) {
-        for (Map.Entry<JetClassInitializer, ClassDescriptorWithResolutionScopes> entry : c.getAnonymousInitializers().entrySet()) {
-            JetClassInitializer initializer = entry.getKey();
+        for (Map.Entry<KtClassInitializer, ClassDescriptorWithResolutionScopes> entry : c.getAnonymousInitializers().entrySet()) {
+            KtClassInitializer initializer = entry.getKey();
             ClassDescriptorWithResolutionScopes descriptor = entry.getValue();
             resolveAnonymousInitializer(c.getOuterDataFlowInfo(), initializer, descriptor);
         }
@@ -515,15 +515,15 @@ public class BodyResolver {
 
     public void resolveAnonymousInitializer(
             @NotNull DataFlowInfo outerDataFlowInfo,
-            @NotNull JetClassInitializer anonymousInitializer,
+            @NotNull KtClassInitializer anonymousInitializer,
             @NotNull ClassDescriptorWithResolutionScopes classDescriptor
     ) {
         LexicalScope scopeForInitializers = classDescriptor.getScopeForInitializerResolution();
         if (!classDescriptor.getConstructors().isEmpty()) {
-            JetExpression body = anonymousInitializer.getBody();
+            KtExpression body = anonymousInitializer.getBody();
             if (body != null) {
                 PreliminaryDeclarationVisitor.Companion.createForDeclaration(
-                        (JetDeclaration) anonymousInitializer.getParent().getParent(), trace);
+                        (KtDeclaration) anonymousInitializer.getParent().getParent(), trace);
                 expressionTypingServices.getType(scopeForInitializers, body, NO_EXPECTED_TYPE, outerDataFlowInfo, trace);
             }
             processModifiersOnInitializer(anonymousInitializer, scopeForInitializers);
@@ -534,18 +534,18 @@ public class BodyResolver {
         }
     }
 
-    private void processModifiersOnInitializer(@NotNull JetModifierListOwner owner, @NotNull LexicalScope scope) {
+    private void processModifiersOnInitializer(@NotNull KtModifierListOwner owner, @NotNull LexicalScope scope) {
         annotationChecker.check(owner, trace, null);
         ModifierCheckerCore.INSTANCE$.check(owner, trace, null);
-        JetModifierList modifierList = owner.getModifierList();
+        KtModifierList modifierList = owner.getModifierList();
         if (modifierList == null) return;
 
         annotationResolver.resolveAnnotationsWithArguments(scope, modifierList, trace);
     }
 
     private void resolvePrimaryConstructorParameters(@NotNull BodiesResolveContext c) {
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
-            JetClassOrObject klass = entry.getKey();
+        for (Map.Entry<KtClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
+            KtClassOrObject klass = entry.getKey();
             ClassDescriptorWithResolutionScopes classDescriptor = entry.getValue();
             ConstructorDescriptor unsubstitutedPrimaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
             if (unsubstitutedPrimaryConstructor != null) {
@@ -580,13 +580,13 @@ public class BodyResolver {
     private void resolveProperty(
             @NotNull BodiesResolveContext c,
             @Nullable LexicalScope parentScope,
-            @NotNull JetProperty property,
+            @NotNull KtProperty property,
             @NotNull PropertyDescriptor propertyDescriptor
     ) {
         computeDeferredType(propertyDescriptor.getReturnType());
 
         PreliminaryDeclarationVisitor.Companion.createForDeclaration(property, trace);
-        JetExpression initializer = property.getInitializer();
+        KtExpression initializer = property.getInitializer();
         LexicalScope propertyScope = getScopeForProperty(c, property);
         if (parentScope == null) {
             parentScope = propertyScope;
@@ -595,7 +595,7 @@ public class BodyResolver {
             resolvePropertyInitializer(c.getOuterDataFlowInfo(), property, propertyDescriptor, initializer, propertyScope);
         }
 
-        JetExpression delegateExpression = property.getDelegateExpression();
+        KtExpression delegateExpression = property.getDelegateExpression();
         if (delegateExpression != null) {
             assert initializer == null : "Initializer should be null for delegated property : " + property.getText();
             resolvePropertyDelegate(c.getOuterDataFlowInfo(), property, propertyDescriptor, delegateExpression, parentScope, propertyScope);
@@ -607,13 +607,13 @@ public class BodyResolver {
     private void resolvePropertyDeclarationBodies(@NotNull BodiesResolveContext c) {
 
         // Member properties
-        Set<JetProperty> processed = Sets.newHashSet();
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
-            if (!(entry.getKey() instanceof JetClass)) continue;
-            JetClass jetClass = (JetClass) entry.getKey();
+        Set<KtProperty> processed = Sets.newHashSet();
+        for (Map.Entry<KtClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
+            if (!(entry.getKey() instanceof KtClass)) continue;
+            KtClass ktClass = (KtClass) entry.getKey();
             ClassDescriptorWithResolutionScopes classDescriptor = entry.getValue();
 
-            for (JetProperty property : jetClass.getProperties()) {
+            for (KtProperty property : ktClass.getProperties()) {
                 PropertyDescriptor propertyDescriptor = c.getProperties().get(property);
                 assert propertyDescriptor != null;
 
@@ -623,8 +623,8 @@ public class BodyResolver {
         }
 
         // Top-level properties & properties of objects
-        for (Map.Entry<JetProperty, PropertyDescriptor> entry : c.getProperties().entrySet()) {
-            JetProperty property = entry.getKey();
+        for (Map.Entry<KtProperty, PropertyDescriptor> entry : c.getProperties().entrySet()) {
+            KtProperty property = entry.getKey();
             if (processed.contains(property)) continue;
 
             PropertyDescriptor propertyDescriptor = entry.getValue();
@@ -634,7 +634,7 @@ public class BodyResolver {
     }
 
     private LexicalScope makeScopeForPropertyAccessor(
-            @NotNull BodiesResolveContext c, @NotNull JetPropertyAccessor accessor, @NotNull PropertyDescriptor descriptor
+            @NotNull BodiesResolveContext c, @NotNull KtPropertyAccessor accessor, @NotNull PropertyDescriptor descriptor
     ) {
         LexicalScope accessorDeclaringScope = c.getDeclaringScope(accessor);
         assert accessorDeclaringScope != null : "Scope for accessor " + accessor.getText() + " should exists";
@@ -643,12 +643,12 @@ public class BodyResolver {
 
     public void resolvePropertyAccessors(
             @NotNull BodiesResolveContext c,
-            @NotNull JetProperty property,
+            @NotNull KtProperty property,
             @NotNull PropertyDescriptor propertyDescriptor
     ) {
         ObservableBindingTrace fieldAccessTrackingTrace = createFieldTrackingTrace(propertyDescriptor);
 
-        JetPropertyAccessor getter = property.getGetter();
+        KtPropertyAccessor getter = property.getGetter();
         PropertyGetterDescriptor getterDescriptor = propertyDescriptor.getGetter();
         if (getter != null && getterDescriptor != null) {
             LexicalScope accessorScope = makeScopeForPropertyAccessor(c, getter, propertyDescriptor);
@@ -656,7 +656,7 @@ public class BodyResolver {
             resolveFunctionBody(c.getOuterDataFlowInfo(), fieldAccessTrackingTrace, getter, getterDescriptor, accessorScope);
         }
 
-        JetPropertyAccessor setter = property.getSetter();
+        KtPropertyAccessor setter = property.getSetter();
         PropertySetterDescriptor setterDescriptor = propertyDescriptor.getSetter();
         if (setter != null && setterDescriptor != null) {
             LexicalScope accessorScope = makeScopeForPropertyAccessor(c, setter, propertyDescriptor);
@@ -666,12 +666,12 @@ public class BodyResolver {
     }
 
     private ObservableBindingTrace createFieldTrackingTrace(final PropertyDescriptor propertyDescriptor) {
-        return new ObservableBindingTrace(trace).addHandler(BindingContext.REFERENCE_TARGET, new ObservableBindingTrace.RecordHandler<JetReferenceExpression, DeclarationDescriptor>() {
+        return new ObservableBindingTrace(trace).addHandler(BindingContext.REFERENCE_TARGET, new ObservableBindingTrace.RecordHandler<KtReferenceExpression, DeclarationDescriptor>() {
             @Override
-            public void handleRecord(WritableSlice<JetReferenceExpression, DeclarationDescriptor> slice, JetReferenceExpression expression, DeclarationDescriptor descriptor) {
-                if (expression instanceof JetSimpleNameExpression) {
-                    JetSimpleNameExpression simpleNameExpression = (JetSimpleNameExpression) expression;
-                    if (simpleNameExpression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER) {
+            public void handleRecord(WritableSlice<KtReferenceExpression, DeclarationDescriptor> slice, KtReferenceExpression expression, DeclarationDescriptor descriptor) {
+                if (expression instanceof KtSimpleNameExpression) {
+                    KtSimpleNameExpression simpleNameExpression = (KtSimpleNameExpression) expression;
+                    if (simpleNameExpression.getReferencedNameElementType() == KtTokens.FIELD_IDENTIFIER) {
                         // This check may be considered redundant as long as $x is only accessible from accessors to $x
                         if (descriptor == propertyDescriptor) { // TODO : original?
                             trace.record(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor); // TODO: this trace?
@@ -688,18 +688,18 @@ public class BodyResolver {
 
     public void resolvePropertyDelegate(
             @NotNull DataFlowInfo outerDataFlowInfo,
-            @NotNull JetProperty jetProperty,
+            @NotNull KtProperty jetProperty,
             @NotNull PropertyDescriptor propertyDescriptor,
-            @NotNull JetExpression delegateExpression,
+            @NotNull KtExpression delegateExpression,
             @NotNull LexicalScope parentScopeForAccessor,
             @NotNull LexicalScope propertyScope
     ) {
-        JetPropertyAccessor getter = jetProperty.getGetter();
+        KtPropertyAccessor getter = jetProperty.getGetter();
         if (getter != null && getter.hasBody()) {
             trace.report(ACCESSOR_FOR_DELEGATED_PROPERTY.on(getter));
         }
 
-        JetPropertyAccessor setter = jetProperty.getSetter();
+        KtPropertyAccessor setter = jetProperty.getSetter();
         if (setter != null && setter.hasBody()) {
             trace.report(ACCESSOR_FOR_DELEGATED_PROPERTY.on(setter));
         }
@@ -709,7 +709,7 @@ public class BodyResolver {
         LexicalScope accessorScope = JetScopeUtils.makeScopeForPropertyAccessor(
                 propertyDescriptor, parentScopeForAccessor, trace);
 
-        JetType delegateType = delegatedPropertyResolver.resolveDelegateExpression(
+        KtType delegateType = delegatedPropertyResolver.resolveDelegateExpression(
                 delegateExpression, jetProperty, propertyDescriptor, propertyDeclarationInnerScope, accessorScope, trace,
                 outerDataFlowInfo);
 
@@ -727,14 +727,14 @@ public class BodyResolver {
 
     public void resolvePropertyInitializer(
             @NotNull DataFlowInfo outerDataFlowInfo,
-            @NotNull JetProperty property,
+            @NotNull KtProperty property,
             @NotNull PropertyDescriptor propertyDescriptor,
-            @NotNull JetExpression initializer,
+            @NotNull KtExpression initializer,
             @NotNull LexicalScope scope
     ) {
         LexicalScope propertyDeclarationInnerScope = JetScopeUtils.getPropertyDeclarationInnerScopeForInitializer(
                 propertyDescriptor, scope, propertyDescriptor.getTypeParameters(), null, trace);
-        JetType expectedTypeForInitializer = property.getTypeReference() != null ? propertyDescriptor.getType() : NO_EXPECTED_TYPE;
+        KtType expectedTypeForInitializer = property.getTypeReference() != null ? propertyDescriptor.getType() : NO_EXPECTED_TYPE;
         if (propertyDescriptor.getCompileTimeInitializer() == null) {
             expressionTypingServices.getType(propertyDeclarationInnerScope, initializer, expectedTypeForInitializer,
                                              outerDataFlowInfo, trace);
@@ -742,15 +742,15 @@ public class BodyResolver {
     }
 
     @NotNull
-    private static LexicalScope getScopeForProperty(@NotNull BodiesResolveContext c, @NotNull JetProperty property) {
+    private static LexicalScope getScopeForProperty(@NotNull BodiesResolveContext c, @NotNull KtProperty property) {
         LexicalScope scope = c.getDeclaringScope(property);
         assert scope != null : "Scope for property " + property.getText() + " should exists";
         return scope;
     }
 
     private void resolveFunctionBodies(@NotNull BodiesResolveContext c) {
-        for (Map.Entry<JetNamedFunction, SimpleFunctionDescriptor> entry : c.getFunctions().entrySet()) {
-            JetNamedFunction declaration = entry.getKey();
+        for (Map.Entry<KtNamedFunction, SimpleFunctionDescriptor> entry : c.getFunctions().entrySet()) {
+            KtNamedFunction declaration = entry.getKey();
 
             LexicalScope scope = c.getDeclaringScope(declaration);
             assert scope != null : "Scope is null: " + PsiUtilsKt.getElementTextWithContext(declaration);
@@ -768,7 +768,7 @@ public class BodyResolver {
     public void resolveFunctionBody(
             @NotNull DataFlowInfo outerDataFlowInfo,
             @NotNull BindingTrace trace,
-            @NotNull JetDeclarationWithBody function,
+            @NotNull KtDeclarationWithBody function,
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull LexicalScope declaringScope
     ) {
@@ -782,7 +782,7 @@ public class BodyResolver {
     public void resolveFunctionBody(
             @NotNull DataFlowInfo outerDataFlowInfo,
             @NotNull BindingTrace trace,
-            @NotNull JetDeclarationWithBody function,
+            @NotNull KtDeclarationWithBody function,
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull LexicalScope scope,
             @Nullable Function1<LexicalScope, DataFlowInfo> beforeBlockBody,
@@ -790,7 +790,7 @@ public class BodyResolver {
     ) {
         PreliminaryDeclarationVisitor.Companion.createForDeclaration(function, trace);
         LexicalScope innerScope = FunctionDescriptorUtil.getFunctionInnerScope(scope, functionDescriptor, trace);
-        List<JetParameter> valueParameters = function.getValueParameters();
+        List<KtParameter> valueParameters = function.getValueParameters();
         List<ValueParameterDescriptor> valueParameterDescriptors = functionDescriptor.getValueParameters();
 
         valueParameterResolver.resolveValueParameters(
@@ -802,7 +802,7 @@ public class BodyResolver {
         // Synthetic "field" creation
         if (functionDescriptor instanceof PropertyAccessorDescriptor && functionDescriptor.getExtensionReceiverParameter() == null) {
             PropertyAccessorDescriptor accessorDescriptor = (PropertyAccessorDescriptor) functionDescriptor;
-            JetProperty property = (JetProperty) function.getParent();
+            KtProperty property = (KtProperty) function.getParent();
             final SyntheticFieldDescriptor fieldDescriptor = new SyntheticFieldDescriptor(accessorDescriptor, property);
             innerScope = new LexicalScopeImpl(innerScope, functionDescriptor, true, null,
                                               "Accessor inner scope with synthetic field",
@@ -814,7 +814,7 @@ public class BodyResolver {
                 }
             });
             // Check parameter name shadowing
-            for (JetParameter parameter : function.getValueParameters()) {
+            for (KtParameter parameter : function.getValueParameters()) {
                 if (SyntheticFieldDescriptor.NAME.equals(parameter.getNameAsName())) {
                     trace.report(Errors.ACCESSOR_PARAMETER_NAME_SHADOWING.on(parameter));
                 }
@@ -838,11 +838,11 @@ public class BodyResolver {
     public void resolveConstructorParameterDefaultValuesAndAnnotations(
             @NotNull DataFlowInfo outerDataFlowInfo,
             @NotNull BindingTrace trace,
-            @NotNull JetClass klass,
+            @NotNull KtClass klass,
             @NotNull ConstructorDescriptor constructorDescriptor,
             @NotNull LexicalScope declaringScope
     ) {
-        List<JetParameter> valueParameters = klass.getPrimaryConstructorParameters();
+        List<KtParameter> valueParameters = klass.getPrimaryConstructorParameters();
         List<ValueParameterDescriptor> valueParameterDescriptors = constructorDescriptor.getValueParameters();
 
         LexicalScope scope = getPrimaryConstructorParametersScope(declaringScope, constructorDescriptor);
@@ -850,7 +850,7 @@ public class BodyResolver {
         valueParameterResolver.resolveValueParameters(valueParameters, valueParameterDescriptors, scope, outerDataFlowInfo, trace);
     }
 
-    private static void computeDeferredType(JetType type) {
+    private static void computeDeferredType(KtType type) {
         // handle type inference loop: function or property body contains a reference to itself
         // fun f() = { f() }
         // val x = x
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompileTimeConstantUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompileTimeConstantUtils.java
index f63420e4735..c15033a25d6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompileTimeConstantUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompileTimeConstantUtils.java
@@ -25,17 +25,17 @@ import org.jetbrains.kotlin.descriptors.VariableDescriptor;
 import org.jetbrains.kotlin.descriptors.annotations.Annotated;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetParameter;
-import org.jetbrains.kotlin.psi.JetPsiUtil;
-import org.jetbrains.kotlin.psi.JetTypeReference;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtParameter;
+import org.jetbrains.kotlin.psi.KtPsiUtil;
+import org.jetbrains.kotlin.psi.KtTypeReference;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.constants.BooleanValue;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.TypedCompileTimeConstant;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeProjection;
 import org.jetbrains.kotlin.types.TypeUtils;
 
@@ -56,12 +56,12 @@ public class CompileTimeConstantUtils {
             "kotlin.shortArrayOf", "kotlin.byteArrayOf", "kotlin.booleanArrayOf"
     );
 
-    public static void checkConstructorParametersType(@NotNull List<JetParameter> parameters, @NotNull BindingTrace trace) {
-        for (JetParameter parameter : parameters) {
+    public static void checkConstructorParametersType(@NotNull List<KtParameter> parameters, @NotNull BindingTrace trace) {
+        for (KtParameter parameter : parameters) {
             VariableDescriptor parameterDescriptor = trace.getBindingContext().get(VALUE_PARAMETER, parameter);
             if (parameterDescriptor == null) continue;
-            JetType parameterType = parameterDescriptor.getType();
-            JetTypeReference typeReference = parameter.getTypeReference();
+            KtType parameterType = parameterDescriptor.getType();
+            KtTypeReference typeReference = parameter.getTypeReference();
             if (typeReference != null) {
                 if (parameterType.isMarkedNullable()) {
                     trace.report(NULLABLE_TYPE_OF_ANNOTATION_MEMBER.on(typeReference));
@@ -73,7 +73,7 @@ public class CompileTimeConstantUtils {
         }
     }
 
-    private static boolean isAcceptableTypeForAnnotationParameter(@NotNull JetType parameterType) {
+    private static boolean isAcceptableTypeForAnnotationParameter(@NotNull KtType parameterType) {
         ClassDescriptor typeDescriptor = TypeUtils.getClassDescriptor(parameterType);
         if (typeDescriptor == null) {
             return false;
@@ -91,7 +91,7 @@ public class CompileTimeConstantUtils {
         if (KotlinBuiltIns.isArray(parameterType)) {
             List<TypeProjection> arguments = parameterType.getArguments();
             if (arguments.size() == 1) {
-                JetType arrayType = arguments.get(0).getType();
+                KtType arrayType = arguments.get(0).getType();
                 if (arrayType.isMarkedNullable()) {
                     return false;
                 }
@@ -125,11 +125,11 @@ public class CompileTimeConstantUtils {
     }
 
     public static boolean canBeReducedToBooleanConstant(
-            @Nullable JetExpression expression,
+            @Nullable KtExpression expression,
             @NotNull BindingTrace trace,
             @Nullable Boolean expectedValue
     ) {
-        JetExpression effectiveExpression = JetPsiUtil.deparenthesize(expression);
+        KtExpression effectiveExpression = KtPsiUtil.deparenthesize(expression);
 
         if (effectiveExpression == null) return false;
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompositeBindingContext.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompositeBindingContext.kt
index 73ae2ed0742..4bad29233af 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompositeBindingContext.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompositeBindingContext.kt
@@ -22,14 +22,14 @@ import com.google.common.collect.ImmutableMap
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import com.intellij.psi.PsiElement
 import com.intellij.openapi.util.ModificationTracker
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 public class CompositeBindingContext private constructor(
         private val delegates: List<BindingContext>
 ) : BindingContext {
-    override fun getType(expression: JetExpression): JetType? {
+    override fun getType(expression: KtExpression): KtType? {
         return delegates.asSequence().map { it.getType(expression) }.firstOrNull { it != null }
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ConstModifierChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ConstModifierChecker.kt
index 182a6df6a7b..4bb7b2f5a4d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ConstModifierChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ConstModifierChecker.kt
@@ -21,20 +21,20 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtProperty
 
 public object ConstModifierChecker : DeclarationChecker {
     override fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext
     ) {
-        if (descriptor !is VariableDescriptor || !declaration.hasModifier(JetTokens.CONST_KEYWORD)) return
+        if (descriptor !is VariableDescriptor || !declaration.hasModifier(KtTokens.CONST_KEYWORD)) return
 
-        val constModifierPsiElement = declaration.modifierList!!.getModifier(JetTokens.CONST_KEYWORD)!!
+        val constModifierPsiElement = declaration.modifierList!!.getModifier(KtTokens.CONST_KEYWORD)!!
 
         val diagnostic = checkCanBeConst(declaration, constModifierPsiElement, descriptor)
         if (diagnostic != null) {
@@ -42,11 +42,11 @@ public object ConstModifierChecker : DeclarationChecker {
         }
     }
 
-    fun checkCanBeConst(declaration: JetDeclaration,
+    fun checkCanBeConst(declaration: KtDeclaration,
                         constModifierPsiElement: PsiElement,
                         descriptor: VariableDescriptor): Diagnostic? {
         if (descriptor.isVar) {
-            return Errors.WRONG_MODIFIER_TARGET.on(constModifierPsiElement, JetTokens.CONST_KEYWORD, "vars")
+            return Errors.WRONG_MODIFIER_TARGET.on(constModifierPsiElement, KtTokens.CONST_KEYWORD, "vars")
         }
 
         val containingDeclaration = descriptor.containingDeclaration
@@ -54,7 +54,7 @@ public object ConstModifierChecker : DeclarationChecker {
             return Errors.CONST_VAL_NOT_TOP_LEVEL_OR_OBJECT.on(constModifierPsiElement)
         }
 
-        if (declaration !is JetProperty || descriptor !is PropertyDescriptor) return null
+        if (declaration !is KtProperty || descriptor !is PropertyDescriptor) return null
 
         if (declaration.hasDelegate()) {
             return Errors.CONST_VAL_WITH_DELEGATE.on(declaration.delegate!!)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ConstructorHeaderCallChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ConstructorHeaderCallChecker.kt
index 53b2ca2ede4..01fec41dcb4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ConstructorHeaderCallChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ConstructorHeaderCallChecker.kt
@@ -21,8 +21,8 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.psi.JetConstructorDelegationCall
-import org.jetbrains.kotlin.psi.JetInstanceExpressionWithLabel
+import org.jetbrains.kotlin.psi.KtConstructorDelegationCall
+import org.jetbrains.kotlin.psi.KtInstanceExpressionWithLabel
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
@@ -42,7 +42,7 @@ public class ConstructorHeaderCallChecker(constructor: ConstructorDescriptor) :
         }
         else {
             val callElement = resolvedCall.getCall().getCallElement()
-            if (callElement is JetInstanceExpressionWithLabel) {
+            if (callElement is KtInstanceExpressionWithLabel) {
                 val descriptor = context.trace.get(BindingContext.REFERENCE_TARGET, callElement.getInstanceReference())
                 if (containingClass == descriptor) {
                     reportError(context, resolvedCall)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java
index c9575d8d404..3fcb7edfcbf 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor;
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Map;
 
@@ -40,40 +40,40 @@ public class ControlFlowAnalyzer {
     }
 
     public void process(@NotNull BodiesResolveContext c) {
-        for (JetFile file : c.getFiles()) {
+        for (KtFile file : c.getFiles()) {
             checkDeclarationContainer(c, file);
         }
-        for (JetClassOrObject aClass : c.getDeclaredClasses().keySet()) {
+        for (KtClassOrObject aClass : c.getDeclaredClasses().keySet()) {
             checkDeclarationContainer(c, aClass);
         }
-        for (JetSecondaryConstructor constructor : c.getSecondaryConstructors().keySet()) {
+        for (KtSecondaryConstructor constructor : c.getSecondaryConstructors().keySet()) {
             checkSecondaryConstructor(constructor);
         }
-        for (Map.Entry<JetNamedFunction, SimpleFunctionDescriptor> entry : c.getFunctions().entrySet()) {
-            JetNamedFunction function = entry.getKey();
+        for (Map.Entry<KtNamedFunction, SimpleFunctionDescriptor> entry : c.getFunctions().entrySet()) {
+            KtNamedFunction function = entry.getKey();
             SimpleFunctionDescriptor functionDescriptor = entry.getValue();
-            JetType expectedReturnType = !function.hasBlockBody() && !function.hasDeclaredReturnType()
+            KtType expectedReturnType = !function.hasBlockBody() && !function.hasDeclaredReturnType()
                                                ? NO_EXPECTED_TYPE
                                                : functionDescriptor.getReturnType();
             checkFunction(c, function, expectedReturnType);
         }
-        for (Map.Entry<JetProperty, PropertyDescriptor> entry : c.getProperties().entrySet()) {
-            JetProperty property = entry.getKey();
+        for (Map.Entry<KtProperty, PropertyDescriptor> entry : c.getProperties().entrySet()) {
+            KtProperty property = entry.getKey();
             PropertyDescriptor propertyDescriptor = entry.getValue();
             checkProperty(c, property, propertyDescriptor);
         }
     }
 
-    private void checkSecondaryConstructor(@NotNull JetSecondaryConstructor constructor) {
+    private void checkSecondaryConstructor(@NotNull KtSecondaryConstructor constructor) {
         JetFlowInformationProvider flowInformationProvider = new JetFlowInformationProvider(constructor, trace);
         flowInformationProvider.checkDeclaration();
         flowInformationProvider.checkFunction(builtIns.getUnitType());
     }
 
-    private void checkDeclarationContainer(@NotNull BodiesResolveContext c, JetDeclarationContainer declarationContainer) {
+    private void checkDeclarationContainer(@NotNull BodiesResolveContext c, KtDeclarationContainer declarationContainer) {
         // A pseudocode of class/object initialization corresponds to a class/object
         // or initialization of properties corresponds to a package declared in a file
-        JetFlowInformationProvider flowInformationProvider = new JetFlowInformationProvider((JetElement) declarationContainer, trace);
+        JetFlowInformationProvider flowInformationProvider = new JetFlowInformationProvider((KtElement) declarationContainer, trace);
         if (c.getTopDownAnalysisMode().isLocalDeclarations()) {
             flowInformationProvider.checkForLocalClassOrObjectMode();
             return;
@@ -81,18 +81,18 @@ public class ControlFlowAnalyzer {
         flowInformationProvider.checkDeclaration();
     }
 
-    private void checkProperty(@NotNull BodiesResolveContext c, JetProperty property, PropertyDescriptor propertyDescriptor) {
-        for (JetPropertyAccessor accessor : property.getAccessors()) {
+    private void checkProperty(@NotNull BodiesResolveContext c, KtProperty property, PropertyDescriptor propertyDescriptor) {
+        for (KtPropertyAccessor accessor : property.getAccessors()) {
             PropertyAccessorDescriptor accessorDescriptor = accessor.isGetter()
                                                             ? propertyDescriptor.getGetter()
                                                             : propertyDescriptor.getSetter();
             assert accessorDescriptor != null : "no property accessor descriptor " + accessor.getText();
-            JetType returnType = accessorDescriptor.getReturnType();
+            KtType returnType = accessorDescriptor.getReturnType();
             checkFunction(c, accessor, returnType);
         }
     }
 
-    private void checkFunction(@NotNull BodiesResolveContext c, @NotNull JetDeclarationWithBody function, @Nullable JetType expectedReturnType) {
+    private void checkFunction(@NotNull BodiesResolveContext c, @NotNull KtDeclarationWithBody function, @Nullable KtType expectedReturnType) {
         if (!function.hasBody()) return;
         JetFlowInformationProvider flowInformationProvider = new JetFlowInformationProvider(function, trace);
         if (c.getTopDownAnalysisMode().isLocalDeclarations()) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DataClassAnnotationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DataClassAnnotationChecker.kt
index 05673d15831..0e6183b7a6b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DataClassAnnotationChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DataClassAnnotationChecker.kt
@@ -20,19 +20,19 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtDeclaration
 
 
 public class DataClassAnnotationChecker : DeclarationChecker {
     override fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext
     ) {
         if (descriptor !is ClassDescriptor) return
-        if (declaration !is JetClassOrObject) return
+        if (declaration !is KtClassOrObject) return
 
         if (descriptor.isData) {
             if (descriptor.unsubstitutedPrimaryConstructor == null && descriptor.constructors.isNotEmpty()) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationChecker.kt
index fcd3793703e..83d16dab7a6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationChecker.kt
@@ -18,12 +18,12 @@ package org.jetbrains.kotlin.resolve
 
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 
 public interface DeclarationChecker {
 
     public fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt
index dee4e7ed5b3..c3d70f6821a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt
@@ -29,8 +29,8 @@ import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetPackageDirective
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtPackageDirective
 import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider
 import org.jetbrains.kotlin.resolve.lazy.TopLevelDescriptorProvider
 import org.jetbrains.kotlin.utils.addIfNotNull
@@ -91,7 +91,7 @@ public class DeclarationResolver(
         }
     }
 
-    public fun checkRedeclarationsInPackages(topLevelDescriptorProvider: TopLevelDescriptorProvider, topLevelFqNames: Multimap<FqName, JetElement>) {
+    public fun checkRedeclarationsInPackages(topLevelDescriptorProvider: TopLevelDescriptorProvider, topLevelFqNames: Multimap<FqName, KtElement>) {
         for ((fqName, declarationsOrPackageDirectives) in topLevelFqNames.asMap()) {
             if (fqName.isRoot()) continue
 
@@ -100,7 +100,7 @@ public class DeclarationResolver(
             if (descriptors.size() > 1) {
                 for (declarationOrPackageDirective in declarationsOrPackageDirectives) {
                     val reportAt =
-                            if (declarationOrPackageDirective is JetPackageDirective) declarationOrPackageDirective.getNameIdentifier()
+                            if (declarationOrPackageDirective is KtPackageDirective) declarationOrPackageDirective.getNameIdentifier()
                             else declarationOrPackageDirective
                     trace.report(Errors.REDECLARATION.on(reportAt, fqName.shortName().asString()))
                 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java
index d9cda69ef70..28ce3494056 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java
@@ -27,11 +27,11 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory0;
 import org.jetbrains.kotlin.diagnostics.Errors;
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.types.*;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.typeUtil.TypeUtilsKt;
 
 import java.util.*;
@@ -64,27 +64,27 @@ public class DeclarationsChecker {
     }
 
     public void process(@NotNull BodiesResolveContext bodiesResolveContext) {
-        for (JetFile file : bodiesResolveContext.getFiles()) {
+        for (KtFile file : bodiesResolveContext.getFiles()) {
             checkModifiersAndAnnotationsInPackageDirective(file);
             annotationChecker.check(file, trace, null);
         }
 
-        Map<JetClassOrObject, ClassDescriptorWithResolutionScopes> classes = bodiesResolveContext.getDeclaredClasses();
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : classes.entrySet()) {
-            JetClassOrObject classOrObject = entry.getKey();
+        Map<KtClassOrObject, ClassDescriptorWithResolutionScopes> classes = bodiesResolveContext.getDeclaredClasses();
+        for (Map.Entry<KtClassOrObject, ClassDescriptorWithResolutionScopes> entry : classes.entrySet()) {
+            KtClassOrObject classOrObject = entry.getKey();
             ClassDescriptorWithResolutionScopes classDescriptor = entry.getValue();
 
             checkSupertypesForConsistency(classDescriptor);
             checkTypesInClassHeader(classOrObject);
 
-            if (classOrObject instanceof JetClass) {
-                JetClass jetClass = (JetClass) classOrObject;
-                checkClass(bodiesResolveContext, jetClass, classDescriptor);
+            if (classOrObject instanceof KtClass) {
+                KtClass ktClass = (KtClass) classOrObject;
+                checkClass(bodiesResolveContext, ktClass, classDescriptor);
                 descriptorResolver.checkNamesInConstraints(
-                        jetClass, classDescriptor, classDescriptor.getScopeForClassHeaderResolution(), trace);
+                        ktClass, classDescriptor, classDescriptor.getScopeForClassHeaderResolution(), trace);
             }
-            else if (classOrObject instanceof JetObjectDeclaration) {
-                checkObject((JetObjectDeclaration) classOrObject, classDescriptor);
+            else if (classOrObject instanceof KtObjectDeclaration) {
+                checkObject((KtObjectDeclaration) classOrObject, classDescriptor);
             }
 
             checkPrimaryConstructor(classOrObject, classDescriptor);
@@ -94,9 +94,9 @@ public class DeclarationsChecker {
             checkClassExposedType(classOrObject, classDescriptor);
         }
 
-        Map<JetNamedFunction, SimpleFunctionDescriptor> functions = bodiesResolveContext.getFunctions();
-        for (Map.Entry<JetNamedFunction, SimpleFunctionDescriptor> entry : functions.entrySet()) {
-            JetNamedFunction function = entry.getKey();
+        Map<KtNamedFunction, SimpleFunctionDescriptor> functions = bodiesResolveContext.getFunctions();
+        for (Map.Entry<KtNamedFunction, SimpleFunctionDescriptor> entry : functions.entrySet()) {
+            KtNamedFunction function = entry.getKey();
             SimpleFunctionDescriptor functionDescriptor = entry.getValue();
 
             checkFunction(function, functionDescriptor);
@@ -104,9 +104,9 @@ public class DeclarationsChecker {
             identifierChecker.checkDeclaration(function, trace);
         }
 
-        Map<JetProperty, PropertyDescriptor> properties = bodiesResolveContext.getProperties();
-        for (Map.Entry<JetProperty, PropertyDescriptor> entry : properties.entrySet()) {
-            JetProperty property = entry.getKey();
+        Map<KtProperty, PropertyDescriptor> properties = bodiesResolveContext.getProperties();
+        for (Map.Entry<KtProperty, PropertyDescriptor> entry : properties.entrySet()) {
+            KtProperty property = entry.getKey();
             PropertyDescriptor propertyDescriptor = entry.getValue();
 
             checkProperty(property, propertyDescriptor);
@@ -114,30 +114,30 @@ public class DeclarationsChecker {
             identifierChecker.checkDeclaration(property, trace);
         }
 
-        for (Map.Entry<JetSecondaryConstructor, ConstructorDescriptor> entry : bodiesResolveContext.getSecondaryConstructors().entrySet()) {
+        for (Map.Entry<KtSecondaryConstructor, ConstructorDescriptor> entry : bodiesResolveContext.getSecondaryConstructors().entrySet()) {
             ConstructorDescriptor constructorDescriptor = entry.getValue();
-            JetSecondaryConstructor declaration = entry.getKey();
+            KtSecondaryConstructor declaration = entry.getKey();
             checkConstructorDeclaration(constructorDescriptor, declaration);
             checkFunctionExposedType(declaration, constructorDescriptor);
         }
     }
 
-    private void checkConstructorDeclaration(ConstructorDescriptor constructorDescriptor, JetDeclaration declaration) {
+    private void checkConstructorDeclaration(ConstructorDescriptor constructorDescriptor, KtDeclaration declaration) {
         modifiersChecker.checkModifiersForDeclaration(declaration, constructorDescriptor);
         identifierChecker.checkDeclaration(declaration, trace);
     }
 
-    private void checkModifiersAndAnnotationsInPackageDirective(JetFile file) {
-        JetPackageDirective packageDirective = file.getPackageDirective();
+    private void checkModifiersAndAnnotationsInPackageDirective(KtFile file) {
+        KtPackageDirective packageDirective = file.getPackageDirective();
         if (packageDirective == null) return;
 
-        JetModifierList modifierList = packageDirective.getModifierList();
+        KtModifierList modifierList = packageDirective.getModifierList();
         if (modifierList == null) return;
 
-        for (JetAnnotationEntry annotationEntry : modifierList.getAnnotationEntries()) {
-            JetConstructorCalleeExpression calleeExpression = annotationEntry.getCalleeExpression();
+        for (KtAnnotationEntry annotationEntry : modifierList.getAnnotationEntries()) {
+            KtConstructorCalleeExpression calleeExpression = annotationEntry.getCalleeExpression();
             if (calleeExpression != null) {
-                JetReferenceExpression reference = calleeExpression.getConstructorReferenceExpression();
+                KtReferenceExpression reference = calleeExpression.getConstructorReferenceExpression();
                 if (reference != null) {
                     trace.report(UNRESOLVED_REFERENCE.on(reference, reference));
                 }
@@ -147,37 +147,37 @@ public class DeclarationsChecker {
         ModifierCheckerCore.INSTANCE$.check(packageDirective, trace, null);
     }
 
-    private void checkTypesInClassHeader(@NotNull JetClassOrObject classOrObject) {
-        for (JetDelegationSpecifier delegationSpecifier : classOrObject.getDelegationSpecifiers()) {
+    private void checkTypesInClassHeader(@NotNull KtClassOrObject classOrObject) {
+        for (KtDelegationSpecifier delegationSpecifier : classOrObject.getDelegationSpecifiers()) {
             checkBoundsForTypeInClassHeader(delegationSpecifier.getTypeReference());
         }
 
-        if (!(classOrObject instanceof JetClass)) return;
-        JetClass jetClass = (JetClass) classOrObject;
+        if (!(classOrObject instanceof KtClass)) return;
+        KtClass ktClass = (KtClass) classOrObject;
 
-        for (JetTypeParameter jetTypeParameter : jetClass.getTypeParameters()) {
+        for (KtTypeParameter jetTypeParameter : ktClass.getTypeParameters()) {
             checkBoundsForTypeInClassHeader(jetTypeParameter.getExtendsBound());
             checkFinalUpperBounds(jetTypeParameter.getExtendsBound());
         }
 
-        for (JetTypeConstraint constraint : jetClass.getTypeConstraints()) {
+        for (KtTypeConstraint constraint : ktClass.getTypeConstraints()) {
             checkBoundsForTypeInClassHeader(constraint.getBoundTypeReference());
             checkFinalUpperBounds(constraint.getBoundTypeReference());
         }
     }
 
-    private void checkBoundsForTypeInClassHeader(@Nullable JetTypeReference typeReference) {
+    private void checkBoundsForTypeInClassHeader(@Nullable KtTypeReference typeReference) {
         if (typeReference != null) {
-            JetType type = trace.getBindingContext().get(TYPE, typeReference);
+            KtType type = trace.getBindingContext().get(TYPE, typeReference);
             if (type != null) {
                 DescriptorResolver.checkBounds(typeReference, type, trace);
             }
         }
     }
 
-    private void checkFinalUpperBounds(@Nullable JetTypeReference typeReference) {
+    private void checkFinalUpperBounds(@Nullable KtTypeReference typeReference) {
         if (typeReference != null) {
-            JetType type = trace.getBindingContext().get(TYPE, typeReference);
+            KtType type = trace.getBindingContext().get(TYPE, typeReference);
             if (type != null) {
                 DescriptorResolver.checkUpperBoundType(typeReference, type, trace);
             }
@@ -196,7 +196,7 @@ public class DeclarationsChecker {
                 TypeParameterDescriptor typeParameterDescriptor = (TypeParameterDescriptor) declarationDescriptor;
 
                 // Immediate arguments of supertypes cannot be projected
-                Set<JetType> conflictingTypes = Sets.newLinkedHashSet();
+                Set<KtType> conflictingTypes = Sets.newLinkedHashSet();
                 for (TypeProjection projection : projections) {
                     conflictingTypes.add(projection.getType());
                 }
@@ -204,9 +204,9 @@ public class DeclarationsChecker {
                 if (conflictingTypes.size() > 1) {
                     DeclarationDescriptor containingDeclaration = typeParameterDescriptor.getContainingDeclaration();
                     assert containingDeclaration instanceof ClassDescriptor : containingDeclaration;
-                    JetClassOrObject psiElement = (JetClassOrObject) DescriptorToSourceUtils.getSourceFromDescriptor(classDescriptor);
+                    KtClassOrObject psiElement = (KtClassOrObject) DescriptorToSourceUtils.getSourceFromDescriptor(classDescriptor);
                     assert psiElement != null;
-                    JetDelegationSpecifierList delegationSpecifierList = psiElement.getDelegationSpecifierList();
+                    KtDelegationSpecifierList delegationSpecifierList = psiElement.getDelegationSpecifierList();
                     assert delegationSpecifierList != null;
                     //                        trace.getErrorHandler().genericError(delegationSpecifierList.getNode(), "Type parameter " + typeParameterDescriptor.getName() + " of " + containingDeclaration.getName() + " has inconsistent values: " + conflictingTypes);
                     trace.report(INCONSISTENT_TYPE_PARAMETER_VALUES
@@ -217,7 +217,7 @@ public class DeclarationsChecker {
         }
     }
 
-    private void checkClassExposedType(@NotNull JetClassOrObject klass, @NotNull ClassDescriptor classDescriptor) {
+    private void checkClassExposedType(@NotNull KtClassOrObject klass, @NotNull ClassDescriptor classDescriptor) {
         checkExposedSupertypes(klass, classDescriptor);
         checkExposedParameterBounds(klass, classDescriptor);
 
@@ -226,16 +226,16 @@ public class DeclarationsChecker {
         }
     }
 
-    private void checkExposedParameterBounds(@NotNull JetClassOrObject klass, @NotNull ClassDescriptor classDescriptor) {
+    private void checkExposedParameterBounds(@NotNull KtClassOrObject klass, @NotNull ClassDescriptor classDescriptor) {
         EffectiveVisibility classVisibility = EffectiveVisibility.Companion.forClass(classDescriptor);
-        List<JetTypeParameter> typeParameterList = klass.getTypeParameters();
+        List<KtTypeParameter> typeParameterList = klass.getTypeParameters();
         int i = 0;
         for (TypeParameterDescriptor typeParameterDescriptor : classDescriptor.getTypeConstructor().getParameters()) {
             if (i >= typeParameterList.size()) return;
-            for (JetType upperBound : typeParameterDescriptor.getUpperBounds()) {
+            for (KtType upperBound : typeParameterDescriptor.getUpperBounds()) {
                 EffectiveVisibility upperBoundVisibility = EffectiveVisibility.Companion.forType(upperBound);
                 if (!upperBoundVisibility.sameOrMorePermissive(classVisibility)) {
-                    JetTypeParameter typeParameter = typeParameterList.get(i);
+                    KtTypeParameter typeParameter = typeParameterList.get(i);
                     trace.report(EXPOSED_TYPE_PARAMETER_BOUND.on(typeParameter, classVisibility, upperBoundVisibility));
                     break;
                 }
@@ -244,12 +244,12 @@ public class DeclarationsChecker {
         }
     }
 
-    private void checkExposedSupertypes(@NotNull JetClassOrObject klass, @NotNull ClassDescriptor classDescriptor) {
+    private void checkExposedSupertypes(@NotNull KtClassOrObject klass, @NotNull ClassDescriptor classDescriptor) {
         EffectiveVisibility classVisibility = EffectiveVisibility.Companion.forClass(classDescriptor);
         boolean isInterface = classDescriptor.getKind() == ClassKind.INTERFACE;
-        List<JetDelegationSpecifier> delegationList = klass.getDelegationSpecifiers();
+        List<KtDelegationSpecifier> delegationList = klass.getDelegationSpecifiers();
         int i = -1;
-        for (JetType superType : classDescriptor.getTypeConstructor().getSupertypes()) {
+        for (KtType superType : classDescriptor.getTypeConstructor().getSupertypes()) {
             i++;
             if (i >= delegationList.size()) return;
             ClassDescriptor superDescriptor = TypeUtils.getClassDescriptor(superType);
@@ -272,11 +272,11 @@ public class DeclarationsChecker {
         }
     }
 
-    private static void removeDuplicateTypes(Set<JetType> conflictingTypes) {
-        for (Iterator<JetType> iterator = conflictingTypes.iterator(); iterator.hasNext(); ) {
-            JetType type = iterator.next();
-            for (JetType otherType : conflictingTypes) {
-                boolean subtypeOf = JetTypeChecker.DEFAULT.equalTypes(type, otherType);
+    private static void removeDuplicateTypes(Set<KtType> conflictingTypes) {
+        for (Iterator<KtType> iterator = conflictingTypes.iterator(); iterator.hasNext(); ) {
+            KtType type = iterator.next();
+            for (KtType otherType : conflictingTypes) {
+                boolean subtypeOf = KotlinTypeChecker.DEFAULT.equalTypes(type, otherType);
                 if (type != otherType && subtypeOf) {
                     iterator.remove();
                     break;
@@ -285,13 +285,13 @@ public class DeclarationsChecker {
         }
     }
 
-    private void checkObject(JetObjectDeclaration declaration, ClassDescriptor classDescriptor) {
+    private void checkObject(KtObjectDeclaration declaration, ClassDescriptor classDescriptor) {
         if  (declaration.isLocal() && !declaration.isCompanion() && !declaration.isObjectLiteral()) {
             trace.report(LOCAL_OBJECT_NOT_ALLOWED.on(declaration, classDescriptor));
         }
     }
 
-    private void checkClass(BodiesResolveContext c, JetClass aClass, ClassDescriptorWithResolutionScopes classDescriptor) {
+    private void checkClass(BodiesResolveContext c, KtClass aClass, ClassDescriptorWithResolutionScopes classDescriptor) {
         checkOpenMembers(classDescriptor);
         checkTypeParameters(aClass);
         checkTypeParameterConstraints(aClass);
@@ -307,24 +307,24 @@ public class DeclarationsChecker {
             checkAnnotationClassWithBody(aClass);
             checkValOnAnnotationParameter(aClass);
         }
-        else if (aClass instanceof JetEnumEntry) {
-            checkEnumEntry((JetEnumEntry) aClass, classDescriptor);
+        else if (aClass instanceof KtEnumEntry) {
+            checkEnumEntry((KtEnumEntry) aClass, classDescriptor);
         }
         for (CallableMemberDescriptor memberDescriptor : classDescriptor.getDeclaredCallableMembers()) {
             if (memberDescriptor.getKind() != CallableMemberDescriptor.Kind.DECLARATION) continue;
-            JetNamedDeclaration member = (JetNamedDeclaration) DescriptorToSourceUtils.descriptorToDeclaration(memberDescriptor);
-            if (member instanceof JetFunction && memberDescriptor instanceof FunctionDescriptor) {
-                checkFunctionExposedType((JetFunction) member, (FunctionDescriptor) memberDescriptor);
+            KtNamedDeclaration member = (KtNamedDeclaration) DescriptorToSourceUtils.descriptorToDeclaration(memberDescriptor);
+            if (member instanceof KtFunction && memberDescriptor instanceof FunctionDescriptor) {
+                checkFunctionExposedType((KtFunction) member, (FunctionDescriptor) memberDescriptor);
             }
         }
     }
 
-    private void checkPrimaryConstructor(JetClassOrObject classOrObject, ClassDescriptor classDescriptor) {
+    private void checkPrimaryConstructor(KtClassOrObject classOrObject, ClassDescriptor classDescriptor) {
         ConstructorDescriptor primaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
-        JetPrimaryConstructor declaration = classOrObject.getPrimaryConstructor();
+        KtPrimaryConstructor declaration = classOrObject.getPrimaryConstructor();
         if (primaryConstructor == null || declaration == null) return;
 
-        for (JetParameter parameter : declaration.getValueParameters()) {
+        for (KtParameter parameter : declaration.getValueParameters()) {
             PropertyDescriptor propertyDescriptor = trace.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, parameter);
             if (propertyDescriptor != null) {
                 modifiersChecker.checkModifiersForDeclaration(parameter, propertyDescriptor);
@@ -336,16 +336,16 @@ public class DeclarationsChecker {
             trace.report(MISSING_CONSTRUCTOR_KEYWORD.on(declaration.getModifierList()));
         }
 
-        if (!(classOrObject instanceof JetClass)) {
+        if (!(classOrObject instanceof KtClass)) {
             trace.report(CONSTRUCTOR_IN_OBJECT.on(declaration));
         }
 
         checkConstructorDeclaration(primaryConstructor, declaration);
     }
 
-    private void checkTypeParameters(JetTypeParameterListOwner typeParameterListOwner) {
+    private void checkTypeParameters(KtTypeParameterListOwner typeParameterListOwner) {
         // TODO: Support annotation for type parameters
-        for (JetTypeParameter jetTypeParameter : typeParameterListOwner.getTypeParameters()) {
+        for (KtTypeParameter jetTypeParameter : typeParameterListOwner.getTypeParameters()) {
             AnnotationResolver.reportUnsupportedAnnotationForTypeParameter(jetTypeParameter, trace);
 
             TypeParameterDescriptor typeParameter = trace.get(TYPE_PARAMETER, jetTypeParameter);
@@ -355,10 +355,10 @@ public class DeclarationsChecker {
         }
     }
 
-    private void checkTypeParameterConstraints(JetTypeParameterListOwner typeParameterListOwner) {
-        List<JetTypeConstraint> constraints = typeParameterListOwner.getTypeConstraints();
+    private void checkTypeParameterConstraints(KtTypeParameterListOwner typeParameterListOwner) {
+        List<KtTypeConstraint> constraints = typeParameterListOwner.getTypeConstraints();
         if (!constraints.isEmpty()) {
-            for (JetTypeParameter typeParameter : typeParameterListOwner.getTypeParameters()) {
+            for (KtTypeParameter typeParameter : typeParameterListOwner.getTypeParameters()) {
                 if (typeParameter.getExtendsBound() != null && hasConstraints(typeParameter, constraints)) {
                     trace.report(MISPLACED_TYPE_PARAMETER_CONSTRAINTS.on(typeParameter));
                 }
@@ -366,9 +366,9 @@ public class DeclarationsChecker {
         }
     }
 
-    private static boolean hasConstraints(JetTypeParameter typeParameter, List<JetTypeConstraint> constraints) {
-        for (JetTypeConstraint constraint : constraints) {
-            JetSimpleNameExpression parameterName = constraint.getSubjectTypeParameterName();
+    private static boolean hasConstraints(KtTypeParameter typeParameter, List<KtTypeConstraint> constraints) {
+        for (KtTypeConstraint constraint : constraints) {
+            KtSimpleNameExpression parameterName = constraint.getSubjectTypeParameterName();
             if (parameterName != null && parameterName.getText().equals(typeParameter.getName())) {
                 return true;
             }
@@ -376,8 +376,8 @@ public class DeclarationsChecker {
         return false;
     }
 
-    private void checkConstructorInInterface(JetClass klass) {
-        JetPrimaryConstructor primaryConstructor = klass.getPrimaryConstructor();
+    private void checkConstructorInInterface(KtClass klass) {
+        KtPrimaryConstructor primaryConstructor = klass.getPrimaryConstructor();
         if (primaryConstructor != null) {
             trace.report(CONSTRUCTOR_IN_INTERFACE.on(primaryConstructor));
         }
@@ -389,8 +389,8 @@ public class DeclarationsChecker {
             FunctionDescriptor functionDescriptor = (FunctionDescriptor) declaredCallableMember;
 
             PsiElement declaration = DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor);
-            if (!(declaration instanceof JetNamedFunction)) continue;
-            JetNamedFunction functionDeclaration = (JetNamedFunction) declaration;
+            if (!(declaration instanceof KtNamedFunction)) continue;
+            KtNamedFunction functionDeclaration = (KtNamedFunction) declaration;
 
             if (isHidingParentMemberIfPresent(declaredCallableMember)) continue;
 
@@ -433,22 +433,22 @@ public class DeclarationsChecker {
     }
 
     private static boolean isHidingParentMemberIfPresent(CallableMemberDescriptor member) {
-        JetNamedDeclaration declaration = (JetNamedDeclaration) DescriptorToSourceUtils.descriptorToDeclaration(member);
+        KtNamedDeclaration declaration = (KtNamedDeclaration) DescriptorToSourceUtils.descriptorToDeclaration(member);
         if (declaration != null) {
-            JetModifierList modifierList = declaration.getModifierList();
-            return modifierList == null || !modifierList.hasModifier(JetTokens.OVERRIDE_KEYWORD);
+            KtModifierList modifierList = declaration.getModifierList();
+            return modifierList == null || !modifierList.hasModifier(KtTokens.OVERRIDE_KEYWORD);
         }
         return false;
     }
 
-    private void checkAnnotationClassWithBody(JetClassOrObject classOrObject) {
+    private void checkAnnotationClassWithBody(KtClassOrObject classOrObject) {
         if (classOrObject.getBody() != null) {
             trace.report(ANNOTATION_CLASS_WITH_BODY.on(classOrObject.getBody()));
         }
     }
 
-    private void checkValOnAnnotationParameter(JetClass aClass) {
-        for (JetParameter parameter : aClass.getPrimaryConstructorParameters()) {
+    private void checkValOnAnnotationParameter(KtClass aClass) {
+        for (KtParameter parameter : aClass.getPrimaryConstructorParameters()) {
             if (!parameter.hasValOrVar()) {
                 trace.report(MISSING_VAL_ON_ANNOTATION_PARAMETER.on(parameter));
             }
@@ -460,14 +460,14 @@ public class DeclarationsChecker {
 
         for (CallableMemberDescriptor memberDescriptor : classDescriptor.getDeclaredCallableMembers()) {
             if (memberDescriptor.getKind() != CallableMemberDescriptor.Kind.DECLARATION) continue;
-            JetNamedDeclaration member = (JetNamedDeclaration) DescriptorToSourceUtils.descriptorToDeclaration(memberDescriptor);
-            if (member != null && member.hasModifier(JetTokens.OPEN_KEYWORD)) {
+            KtNamedDeclaration member = (KtNamedDeclaration) DescriptorToSourceUtils.descriptorToDeclaration(memberDescriptor);
+            if (member != null && member.hasModifier(KtTokens.OPEN_KEYWORD)) {
                 trace.report(NON_FINAL_MEMBER_IN_FINAL_CLASS.on(member));
             }
         }
     }
 
-    private void checkProperty(JetProperty property, PropertyDescriptor propertyDescriptor) {
+    private void checkProperty(KtProperty property, PropertyDescriptor propertyDescriptor) {
         DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration();
         if (containingDeclaration instanceof ClassDescriptor) {
             checkPropertyAbstractness(property, propertyDescriptor, (ClassDescriptor) containingDeclaration);
@@ -485,8 +485,8 @@ public class DeclarationsChecker {
             if (isTypeParameterUsedInReceiverType(typeParameter, descriptor)) continue;
 
             PsiElement typeParameterPsi = DescriptorToSourceUtils.getSourceFromDescriptor(typeParameter);
-            if (typeParameterPsi instanceof JetTypeParameter) {
-                trace.report(TYPE_PARAMETER_OF_PROPERTY_NOT_USED_IN_RECEIVER.on((JetTypeParameter) typeParameterPsi));
+            if (typeParameterPsi instanceof KtTypeParameter) {
+                trace.report(TYPE_PARAMETER_OF_PROPERTY_NOT_USED_IN_RECEIVER.on((KtTypeParameter) typeParameterPsi));
             }
         }
     }
@@ -498,18 +498,18 @@ public class DeclarationsChecker {
         ReceiverParameterDescriptor receiverParameter = descriptor.getExtensionReceiverParameter();
         if (receiverParameter == null) return false;
 
-        return TypeUtils.containsSpecialType(receiverParameter.getType(), new Function1<JetType, Boolean>() {
+        return TypeUtils.containsSpecialType(receiverParameter.getType(), new Function1<KtType, Boolean>() {
             @Override
-            public Boolean invoke(JetType type) {
+            public Boolean invoke(KtType type) {
                 return parameter.equals(type.getConstructor().getDeclarationDescriptor());
             }
         });
     }
 
-    private void checkPropertyLateInit(@NotNull JetCallableDeclaration property, @NotNull PropertyDescriptor propertyDescriptor) {
-        JetModifierList modifierList = property.getModifierList();
+    private void checkPropertyLateInit(@NotNull KtCallableDeclaration property, @NotNull PropertyDescriptor propertyDescriptor) {
+        KtModifierList modifierList = property.getModifierList();
         if (modifierList == null) return;
-        PsiElement modifier = modifierList.getModifier(JetTokens.LATEINIT_KEYWORD);
+        PsiElement modifier = modifierList.getModifier(KtTokens.LATEINIT_KEYWORD);
         if (modifier == null) return;
 
         if (!propertyDescriptor.isVar()) {
@@ -519,7 +519,7 @@ public class DeclarationsChecker {
         boolean returnTypeIsNullable = true;
         boolean returnTypeIsPrimitive = true;
 
-        JetType returnType = propertyDescriptor.getReturnType();
+        KtType returnType = propertyDescriptor.getReturnType();
         if (returnType != null) {
             returnTypeIsNullable = TypeUtils.isNullableType(returnType);
             returnTypeIsPrimitive = KotlinBuiltIns.isPrimitiveType(returnType);
@@ -538,13 +538,13 @@ public class DeclarationsChecker {
             trace.report(INAPPLICABLE_LATEINIT_MODIFIER.on(modifier, "is not allowed on abstract properties"));
         }
 
-        if (property instanceof JetParameter) {
+        if (property instanceof KtParameter) {
             trace.report(INAPPLICABLE_LATEINIT_MODIFIER.on(modifier, "is not allowed on primary constructor parameters"));
         }
 
         boolean hasDelegateExpressionOrInitializer = false;
-        if (property instanceof JetProperty) {
-            hasDelegateExpressionOrInitializer = ((JetProperty) property).hasDelegateExpressionOrInitializer();
+        if (property instanceof KtProperty) {
+            hasDelegateExpressionOrInitializer = ((KtProperty) property).hasDelegateExpressionOrInitializer();
             if (hasDelegateExpressionOrInitializer) {
                 trace.report(INAPPLICABLE_LATEINIT_MODIFIER.on(modifier,
                         "is not allowed on properties with initializer or on delegated properties"));
@@ -579,15 +579,15 @@ public class DeclarationsChecker {
     }
 
     private void checkPropertyAbstractness(
-            @NotNull JetProperty property,
+            @NotNull KtProperty property,
             @NotNull PropertyDescriptor propertyDescriptor,
             @NotNull ClassDescriptor classDescriptor
     ) {
-        JetPropertyAccessor getter = property.getGetter();
-        JetPropertyAccessor setter = property.getSetter();
-        JetModifierList modifierList = property.getModifierList();
+        KtPropertyAccessor getter = property.getGetter();
+        KtPropertyAccessor setter = property.getSetter();
+        KtModifierList modifierList = property.getModifierList();
 
-        if (modifierList != null && modifierList.hasModifier(JetTokens.ABSTRACT_KEYWORD)) { //has abstract modifier
+        if (modifierList != null && modifierList.hasModifier(KtTokens.ABSTRACT_KEYWORD)) { //has abstract modifier
             if (!classCanHaveAbstractMembers(classDescriptor)) {
                 String name = property.getName();
                 trace.report(ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS.on(property, name != null ? name : "", classDescriptor));
@@ -599,11 +599,11 @@ public class DeclarationsChecker {
         }
 
         if (propertyDescriptor.getModality() == Modality.ABSTRACT) {
-            JetExpression initializer = property.getInitializer();
+            KtExpression initializer = property.getInitializer();
             if (initializer != null) {
                 trace.report(ABSTRACT_PROPERTY_WITH_INITIALIZER.on(initializer));
             }
-            JetPropertyDelegate delegate = property.getDelegate();
+            KtPropertyDelegate delegate = property.getDelegate();
             if (delegate != null) {
                 trace.report(ABSTRACT_DELEGATED_PROPERTY.on(delegate));
             }
@@ -616,9 +616,9 @@ public class DeclarationsChecker {
         }
     }
 
-    private void checkPropertyInitializer(@NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor) {
-        JetPropertyAccessor getter = property.getGetter();
-        JetPropertyAccessor setter = property.getSetter();
+    private void checkPropertyInitializer(@NotNull KtProperty property, @NotNull PropertyDescriptor propertyDescriptor) {
+        KtPropertyAccessor getter = property.getGetter();
+        KtPropertyAccessor setter = property.getSetter();
         boolean hasAccessorImplementation = (getter != null && getter.hasBody()) ||
                                             (setter != null && setter.hasBody());
 
@@ -628,13 +628,13 @@ public class DeclarationsChecker {
             if (!property.hasDelegateExpressionOrInitializer() && property.getTypeReference() == null) {
                 trace.report(PROPERTY_WITH_NO_TYPE_NO_INITIALIZER.on(property));
             }
-            if (inTrait && property.hasModifier(JetTokens.PRIVATE_KEYWORD) && !property.hasModifier(JetTokens.ABSTRACT_KEYWORD)) {
+            if (inTrait && property.hasModifier(KtTokens.PRIVATE_KEYWORD) && !property.hasModifier(KtTokens.ABSTRACT_KEYWORD)) {
                 trace.report(PRIVATE_PROPERTY_IN_INTERFACE.on(property));
             }
             return;
         }
-        JetExpression initializer = property.getInitializer();
-        JetPropertyDelegate delegate = property.getDelegate();
+        KtExpression initializer = property.getInitializer();
+        KtPropertyDelegate delegate = property.getDelegate();
         boolean backingFieldRequired =
                 Boolean.TRUE.equals(trace.getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor));
 
@@ -658,7 +658,7 @@ public class DeclarationsChecker {
             if (!error && property.getTypeReference() == null) {
                 trace.report(PROPERTY_WITH_NO_TYPE_NO_INITIALIZER.on(property));
             }
-            if (inTrait && property.hasModifier(JetTokens.FINAL_KEYWORD) && backingFieldRequired) {
+            if (inTrait && property.hasModifier(KtTokens.FINAL_KEYWORD) && backingFieldRequired) {
                 trace.report(FINAL_PROPERTY_IN_INTERFACE.on(property));
             }
             return;
@@ -682,7 +682,7 @@ public class DeclarationsChecker {
         }
     }
 
-    private void checkMemberReceiverExposedType(@Nullable JetTypeReference typeReference, @NotNull CallableMemberDescriptor memberDescriptor) {
+    private void checkMemberReceiverExposedType(@Nullable KtTypeReference typeReference, @NotNull CallableMemberDescriptor memberDescriptor) {
         if (typeReference == null) return;
         ReceiverParameterDescriptor receiverParameterDescriptor = memberDescriptor.getExtensionReceiverParameter();
         if (receiverParameterDescriptor == null) return;
@@ -693,7 +693,7 @@ public class DeclarationsChecker {
         }
     }
 
-    private void checkPropertyExposedType(@NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor) {
+    private void checkPropertyExposedType(@NotNull KtProperty property, @NotNull PropertyDescriptor propertyDescriptor) {
         EffectiveVisibility propertyVisibility = EffectiveVisibility.Companion.forMember(propertyDescriptor);
         EffectiveVisibility typeVisibility = EffectiveVisibility.Companion.forType(propertyDescriptor.getType());
         if (!typeVisibility.sameOrMorePermissive(propertyVisibility)) {
@@ -702,8 +702,8 @@ public class DeclarationsChecker {
         checkMemberReceiverExposedType(property.getReceiverTypeReference(), propertyDescriptor);
     }
 
-    protected void checkFunction(JetNamedFunction function, SimpleFunctionDescriptor functionDescriptor) {
-        JetTypeParameterList typeParameterList = function.getTypeParameterList();
+    protected void checkFunction(KtNamedFunction function, SimpleFunctionDescriptor functionDescriptor) {
+        KtTypeParameterList typeParameterList = function.getTypeParameterList();
         PsiElement nameIdentifier = function.getNameIdentifier();
         if (typeParameterList != null && nameIdentifier != null &&
             typeParameterList.getTextRange().getStartOffset() > nameIdentifier.getTextRange().getStartOffset()) {
@@ -712,8 +712,8 @@ public class DeclarationsChecker {
         checkTypeParameterConstraints(function);
 
         DeclarationDescriptor containingDescriptor = functionDescriptor.getContainingDeclaration();
-        boolean hasAbstractModifier = function.hasModifier(JetTokens.ABSTRACT_KEYWORD);
-        boolean hasExternalModifier = function.hasModifier(JetTokens.EXTERNAL_KEYWORD);
+        boolean hasAbstractModifier = function.hasModifier(KtTokens.ABSTRACT_KEYWORD);
+        boolean hasExternalModifier = function.hasModifier(KtTokens.EXTERNAL_KEYWORD);
 
         if (containingDescriptor instanceof ClassDescriptor) {
             ClassDescriptor classDescriptor = (ClassDescriptor) containingDescriptor;
@@ -729,10 +729,10 @@ public class DeclarationsChecker {
                 trace.report(ABSTRACT_FUNCTION_WITH_BODY.on(function, functionDescriptor));
             }
             if (!hasBody && inTrait) {
-                if (function.hasModifier(JetTokens.FINAL_KEYWORD) && !hasExternalModifier) {
+                if (function.hasModifier(KtTokens.FINAL_KEYWORD) && !hasExternalModifier) {
                     trace.report(FINAL_FUNCTION_WITH_NO_BODY.on(function, functionDescriptor));
                 }
-                if (function.hasModifier(JetTokens.PRIVATE_KEYWORD)) {
+                if (function.hasModifier(KtTokens.PRIVATE_KEYWORD)) {
                     trace.report(PRIVATE_FUNCTION_WITH_NO_BODY.on(function, functionDescriptor));
                 }
             }
@@ -750,9 +750,9 @@ public class DeclarationsChecker {
         checkFunctionExposedType(function, functionDescriptor);
     }
 
-    private void checkFunctionExposedType(@NotNull JetFunction function, @NotNull FunctionDescriptor functionDescriptor) {
+    private void checkFunctionExposedType(@NotNull KtFunction function, @NotNull FunctionDescriptor functionDescriptor) {
         EffectiveVisibility functionVisibility = EffectiveVisibility.Companion.forMember(functionDescriptor);
-        if (!(function instanceof JetConstructor)) {
+        if (!(function instanceof KtConstructor)) {
             EffectiveVisibility returnTypeVisibility = EffectiveVisibility.Companion.forType(functionDescriptor.getReturnType());
             if (!returnTypeVisibility.sameOrMorePermissive(functionVisibility)) {
                 PsiElement reportOn = function.getNameIdentifier();
@@ -773,8 +773,8 @@ public class DeclarationsChecker {
         checkMemberReceiverExposedType(function.getReceiverTypeReference(), functionDescriptor);
     }
 
-    private void checkAccessors(@NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor) {
-        for (JetPropertyAccessor accessor : property.getAccessors()) {
+    private void checkAccessors(@NotNull KtProperty property, @NotNull PropertyDescriptor propertyDescriptor) {
+        for (KtPropertyAccessor accessor : property.getAccessors()) {
             PropertyAccessorDescriptor propertyAccessorDescriptor = accessor.isGetter() ? propertyDescriptor.getGetter() : propertyDescriptor.getSetter();
             assert propertyAccessorDescriptor != null : "No property accessor descriptor for " + property.getText();
             modifiersChecker.checkModifiersForDeclaration(accessor, propertyAccessorDescriptor);
@@ -792,15 +792,15 @@ public class DeclarationsChecker {
 
     private void checkAccessor(
             @NotNull PropertyDescriptor propertyDescriptor,
-            @Nullable JetPropertyAccessor accessor,
+            @Nullable KtPropertyAccessor accessor,
             @Nullable PropertyAccessorDescriptor accessorDescriptor
     ) {
         if (accessor == null) return;
-        JetModifierList accessorModifierList = accessor.getModifierList();
+        KtModifierList accessorModifierList = accessor.getModifierList();
         if (accessorModifierList != null && accessorDescriptor != null) {
-            Map<JetModifierKeywordToken, PsiElement> tokens = modifiersChecker.getTokensCorrespondingToModifiers(accessorModifierList, Sets
-                    .newHashSet(JetTokens.PUBLIC_KEYWORD, JetTokens.PROTECTED_KEYWORD, JetTokens.PRIVATE_KEYWORD,
-                                JetTokens.INTERNAL_KEYWORD));
+            Map<KtModifierKeywordToken, PsiElement> tokens = modifiersChecker.getTokensCorrespondingToModifiers(accessorModifierList, Sets
+                    .newHashSet(KtTokens.PUBLIC_KEYWORD, KtTokens.PROTECTED_KEYWORD, KtTokens.PRIVATE_KEYWORD,
+                                KtTokens.INTERNAL_KEYWORD));
             if (propertyDescriptor.getModality() == Modality.ABSTRACT && accessorDescriptor.getVisibility() != propertyDescriptor.getVisibility()) {
                 reportVisibilityModifierDiagnostics(tokens.values(), Errors.ACCESSOR_VISIBILITY_FOR_ABSTRACT_PROPERTY);
             }
@@ -820,7 +820,7 @@ public class DeclarationsChecker {
         }
     }
 
-    private void checkEnumEntry(@NotNull JetEnumEntry enumEntry, @NotNull ClassDescriptor classDescriptor) {
+    private void checkEnumEntry(@NotNull KtEnumEntry enumEntry, @NotNull ClassDescriptor classDescriptor) {
         DeclarationDescriptor declaration = classDescriptor.getContainingDeclaration();
         if (DescriptorUtils.isEnumClass(declaration)) {
             ClassDescriptor enumClass = (ClassDescriptor) declaration;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java
index 2a205ef8766..f27483c5a7c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java
@@ -37,9 +37,9 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.resolve.validation.OperatorValidator;
 import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
 import org.jetbrains.kotlin.types.DeferredType;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
 import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
@@ -49,7 +49,7 @@ import java.util.Collections;
 import java.util.List;
 
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
-import static org.jetbrains.kotlin.psi.JetPsiFactoryKt.JetPsiFactory;
+import static org.jetbrains.kotlin.psi.KtPsiFactoryKt.KtPsiFactory;
 import static org.jetbrains.kotlin.resolve.BindingContext.*;
 import static org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.FROM_COMPLETER;
 import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
@@ -83,10 +83,10 @@ public class DelegatedPropertyResolver {
     }
 
     @Nullable
-    public JetType getDelegatedPropertyGetMethodReturnType(
+    public KtType getDelegatedPropertyGetMethodReturnType(
             @NotNull PropertyDescriptor propertyDescriptor,
-            @NotNull JetExpression delegateExpression,
-            @NotNull JetType delegateType,
+            @NotNull KtExpression delegateExpression,
+            @NotNull KtType delegateType,
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope
     ) {
@@ -98,17 +98,17 @@ public class DelegatedPropertyResolver {
 
     public void resolveDelegatedPropertyGetMethod(
             @NotNull PropertyDescriptor propertyDescriptor,
-            @NotNull JetExpression delegateExpression,
-            @NotNull JetType delegateType,
+            @NotNull KtExpression delegateExpression,
+            @NotNull KtType delegateType,
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope
     ) {
-        JetType returnType = getDelegatedPropertyGetMethodReturnType(
+        KtType returnType = getDelegatedPropertyGetMethodReturnType(
                 propertyDescriptor, delegateExpression, delegateType, trace, scope);
-        JetType propertyType = propertyDescriptor.getType();
+        KtType propertyType = propertyDescriptor.getType();
 
         /* Do not check return type of get() method of delegate for properties with DeferredType because property type is taken from it */
-        if (!(propertyType instanceof DeferredType) && returnType != null && !JetTypeChecker.DEFAULT.isSubtypeOf(returnType, propertyType)) {
+        if (!(propertyType instanceof DeferredType) && returnType != null && !KotlinTypeChecker.DEFAULT.isSubtypeOf(returnType, propertyType)) {
             Call call = trace.getBindingContext().get(DELEGATED_PROPERTY_CALL, propertyDescriptor.getGetter());
             assert call != null : "Call should exists for " + propertyDescriptor.getGetter();
             trace.report(DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH
@@ -118,8 +118,8 @@ public class DelegatedPropertyResolver {
 
     public void resolveDelegatedPropertySetMethod(
             @NotNull PropertyDescriptor propertyDescriptor,
-            @NotNull JetExpression delegateExpression,
-            @NotNull JetType delegateType,
+            @NotNull KtExpression delegateExpression,
+            @NotNull KtType delegateType,
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope
     ) {
@@ -127,14 +127,14 @@ public class DelegatedPropertyResolver {
     }
 
     @NotNull
-    private static JetExpression createExpressionForProperty(@NotNull JetPsiFactory psiFactory) {
+    private static KtExpression createExpressionForProperty(@NotNull KtPsiFactory psiFactory) {
         return psiFactory.createExpression("null as " + KotlinBuiltIns.FQ_NAMES.kProperty.asSingleFqName().asString() + "<*>");
     }
 
     public void resolveDelegatedPropertyPDMethod(
             @NotNull PropertyDescriptor propertyDescriptor,
-            @NotNull JetExpression delegateExpression,
-            @NotNull JetType delegateType,
+            @NotNull KtExpression delegateExpression,
+            @NotNull KtType delegateType,
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope
     ) {
@@ -143,8 +143,8 @@ public class DelegatedPropertyResolver {
                 traceToResolvePDMethod, scope,
                 DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE);
 
-        JetPsiFactory psiFactory = JetPsiFactory(delegateExpression);
-        List<JetExpression> arguments = Collections.singletonList(createExpressionForProperty(psiFactory));
+        KtPsiFactory psiFactory = KtPsiFactory(delegateExpression);
+        List<KtExpression> arguments = Collections.singletonList(createExpressionForProperty(psiFactory));
         ExpressionReceiver receiver = new ExpressionReceiver(delegateExpression, delegateType);
 
         Pair<Call, OverloadResolutionResults<FunctionDescriptor>> resolutionResult =
@@ -171,8 +171,8 @@ public class DelegatedPropertyResolver {
     /* Resolve getValue() or setValue() methods from delegate */
     private void resolveDelegatedPropertyConventionMethod(
             @NotNull PropertyDescriptor propertyDescriptor,
-            @NotNull JetExpression delegateExpression,
-            @NotNull JetType delegateType,
+            @NotNull KtExpression delegateExpression,
+            @NotNull KtType delegateType,
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             boolean isGet
@@ -211,9 +211,9 @@ public class DelegatedPropertyResolver {
 
         ResolvedCall<FunctionDescriptor> resultingCall = functionResults.getResultingCall();
         PsiElement declaration = DescriptorToSourceUtils.descriptorToDeclaration(propertyDescriptor);
-        if (declaration instanceof JetProperty) {
-            JetProperty property = (JetProperty) declaration;
-            JetPropertyDelegate delegate = property.getDelegate();
+        if (declaration instanceof KtProperty) {
+            KtProperty property = (KtProperty) declaration;
+            KtPropertyDelegate delegate = property.getDelegate();
             if (delegate != null) {
                 PsiElement byKeyword = delegate.getByKeywordNode().getPsi();
 
@@ -230,8 +230,8 @@ public class DelegatedPropertyResolver {
     /* Resolve getValue() or setValue() methods from delegate */
     public OverloadResolutionResults<FunctionDescriptor> getDelegatedPropertyConventionMethod(
             @NotNull PropertyDescriptor propertyDescriptor,
-            @NotNull JetExpression delegateExpression,
-            @NotNull JetType delegateType,
+            @NotNull KtExpression delegateExpression,
+            @NotNull KtType delegateType,
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             boolean isGet,
@@ -240,7 +240,7 @@ public class DelegatedPropertyResolver {
         PropertyAccessorDescriptor accessor = isGet ? propertyDescriptor.getGetter() : propertyDescriptor.getSetter();
         assert accessor != null : "Delegated property should have getter/setter " + propertyDescriptor + " " + delegateExpression.getText();
 
-        JetType expectedType = isComplete && isGet && !(propertyDescriptor.getType() instanceof DeferredType)
+        KtType expectedType = isComplete && isGet && !(propertyDescriptor.getType() instanceof DeferredType)
                                ? propertyDescriptor.getType() : TypeUtils.NO_EXPECTED_TYPE;
 
         ExpressionTypingContext context = ExpressionTypingContext.newContext(
@@ -249,15 +249,15 @@ public class DelegatedPropertyResolver {
 
         boolean hasThis = propertyDescriptor.getExtensionReceiverParameter() != null || propertyDescriptor.getDispatchReceiverParameter() != null;
 
-        List<JetExpression> arguments = Lists.newArrayList();
-        JetPsiFactory psiFactory = JetPsiFactory(delegateExpression);
+        List<KtExpression> arguments = Lists.newArrayList();
+        KtPsiFactory psiFactory = KtPsiFactory(delegateExpression);
         arguments.add(psiFactory.createExpression(hasThis ? "this" : "null"));
         arguments.add(createExpressionForProperty(psiFactory));
 
         if (!isGet) {
-            JetReferenceExpression fakeArgument = (JetReferenceExpression) createFakeExpressionOfType(delegateExpression.getProject(), trace,
+            KtReferenceExpression fakeArgument = (KtReferenceExpression) createFakeExpressionOfType(delegateExpression.getProject(), trace,
                                                                                                       "fakeArgument" + arguments.size(),
-                                                                                                      propertyDescriptor.getType());
+                                                                                                    propertyDescriptor.getType());
             arguments.add(fakeArgument);
             List<ValueParameterDescriptor> valueParameters = accessor.getValueParameters();
             trace.record(REFERENCE_TARGET, fakeArgument, valueParameters.get(0));
@@ -280,9 +280,9 @@ public class DelegatedPropertyResolver {
                 FunctionDescriptor resultingDescriptor = additionalResolutionResult.getSecond().getResultingDescriptor();
 
                 PsiElement declaration = DescriptorToSourceUtils.descriptorToDeclaration(propertyDescriptor);
-                if (declaration instanceof JetProperty) {
-                    JetProperty property = (JetProperty) declaration;
-                    JetPropertyDelegate delegate = property.getDelegate();
+                if (declaration instanceof KtProperty) {
+                    KtProperty property = (KtProperty) declaration;
+                    KtPropertyDelegate delegate = property.getDelegate();
                     if (delegate != null) {
                         PsiElement byKeyword = delegate.getByKeywordNode().getPsi();
 
@@ -301,11 +301,11 @@ public class DelegatedPropertyResolver {
     }
 
     private static String renderCall(@NotNull Call call, @NotNull BindingContext context) {
-        JetExpression calleeExpression = call.getCalleeExpression();
+        KtExpression calleeExpression = call.getCalleeExpression();
         assert calleeExpression != null : "CalleeExpression should exists for fake call of convention method";
         StringBuilder builder = new StringBuilder(calleeExpression.getText());
         builder.append("(");
-        List<JetType> argumentTypes = Lists.newArrayList();
+        List<KtType> argumentTypes = Lists.newArrayList();
         for (ValueArgument argument : call.getValueArguments()) {
             argumentTypes.add(context.getType(argument.getArgumentExpression()));
 
@@ -316,9 +316,9 @@ public class DelegatedPropertyResolver {
     }
 
     @Nullable
-    public JetType resolveDelegateExpression(
-            @NotNull JetExpression delegateExpression,
-            @NotNull JetProperty jetProperty,
+    public KtType resolveDelegateExpression(
+            @NotNull KtExpression delegateExpression,
+            @NotNull KtProperty jetProperty,
             @NotNull PropertyDescriptor propertyDescriptor,
             @NotNull LexicalScope propertyDeclarationInnerScope,
             @NotNull LexicalScope accessorScope,
@@ -326,14 +326,14 @@ public class DelegatedPropertyResolver {
             @NotNull DataFlowInfo dataFlowInfo
     ) {
         TemporaryBindingTrace traceToResolveDelegatedProperty = TemporaryBindingTrace.create(trace, "Trace to resolve delegated property");
-        JetExpression calleeExpression = CallUtilKt.getCalleeExpressionIfAny(delegateExpression);
+        KtExpression calleeExpression = CallUtilKt.getCalleeExpressionIfAny(delegateExpression);
         ConstraintSystemCompleter completer = createConstraintSystemCompleter(
                 jetProperty, propertyDescriptor, delegateExpression, accessorScope, trace);
         if (calleeExpression != null) {
             traceToResolveDelegatedProperty.record(CONSTRAINT_SYSTEM_COMPLETER, calleeExpression, completer);
         }
-        JetType delegateType = expressionTypingServices.safeGetType(propertyDeclarationInnerScope, delegateExpression, NO_EXPECTED_TYPE,
-                                                                    dataFlowInfo, traceToResolveDelegatedProperty);
+        KtType delegateType = expressionTypingServices.safeGetType(propertyDeclarationInnerScope, delegateExpression, NO_EXPECTED_TYPE,
+                                                                   dataFlowInfo, traceToResolveDelegatedProperty);
         traceToResolveDelegatedProperty.commit(new TraceEntryFilter() {
             @Override
             public boolean accept(@Nullable WritableSlice<?, ?> slice, Object key) {
@@ -345,19 +345,19 @@ public class DelegatedPropertyResolver {
 
     @NotNull
     private ConstraintSystemCompleter createConstraintSystemCompleter(
-            @NotNull JetProperty property,
+            @NotNull KtProperty property,
             @NotNull final PropertyDescriptor propertyDescriptor,
-            @NotNull final JetExpression delegateExpression,
+            @NotNull final KtExpression delegateExpression,
             @NotNull final LexicalScope accessorScope,
             @NotNull final BindingTrace trace
     ) {
-        final JetType expectedType = property.getTypeReference() != null ? propertyDescriptor.getType() : NO_EXPECTED_TYPE;
+        final KtType expectedType = property.getTypeReference() != null ? propertyDescriptor.getType() : NO_EXPECTED_TYPE;
         return new ConstraintSystemCompleter() {
             @Override
             public void completeConstraintSystem(
                     @NotNull ConstraintSystem constraintSystem, @NotNull ResolvedCall<?> resolvedCall
             ) {
-                JetType returnType = resolvedCall.getCandidateDescriptor().getReturnType();
+                KtType returnType = resolvedCall.getCandidateDescriptor().getReturnType();
                 if (returnType == null) return;
 
                 TemporaryBindingTrace traceToResolveConventionMethods =
@@ -370,7 +370,7 @@ public class DelegatedPropertyResolver {
 
                 if (conventionMethodFound(getMethodResults)) {
                     FunctionDescriptor descriptor = getMethodResults.getResultingDescriptor();
-                    JetType returnTypeOfGetMethod = descriptor.getReturnType();
+                    KtType returnTypeOfGetMethod = descriptor.getReturnType();
                     if (returnTypeOfGetMethod != null) {
                         constraintSystem.addSupertypeConstraint(expectedType, returnTypeOfGetMethod, FROM_COMPLETER.position());
                     }
@@ -413,7 +413,7 @@ public class DelegatedPropertyResolver {
             private void addConstraintForThisValue(ConstraintSystem constraintSystem, FunctionDescriptor resultingDescriptor) {
                 ReceiverParameterDescriptor extensionReceiver = propertyDescriptor.getExtensionReceiverParameter();
                 ReceiverParameterDescriptor dispatchReceiver = propertyDescriptor.getDispatchReceiverParameter();
-                JetType typeOfThis =
+                KtType typeOfThis =
                         extensionReceiver != null ? extensionReceiver.getType() :
                         dispatchReceiver != null ? dispatchReceiver.getType() :
                         builtIns.getNullableNothingType();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatingBindingTrace.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatingBindingTrace.java
index 5e5e437e25f..5f8ce203b10 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatingBindingTrace.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatingBindingTrace.java
@@ -23,10 +23,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
 import org.jetbrains.kotlin.resolve.diagnostics.MutableDiagnosticsWithSuppression;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.expressions.JetTypeInfo;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt;
 import org.jetbrains.kotlin.util.slicedMap.*;
@@ -58,7 +58,7 @@ public class DelegatingBindingTrace implements BindingTrace {
 
         @Nullable
         @Override
-        public JetType getType(@NotNull JetExpression expression) {
+        public KtType getType(@NotNull KtExpression expression) {
             return DelegatingBindingTrace.this.getType(expression);
         }
 
@@ -139,13 +139,13 @@ public class DelegatingBindingTrace implements BindingTrace {
 
     @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) {
         JetTypeInfo typeInfo = get(BindingContext.EXPRESSION_TYPE_INFO, expression);
         if (typeInfo == null) {
             typeInfo = TypeInfoFactoryKt.createTypeInfo(type);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegationResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegationResolver.java
index 2a832d42751..7862dd69e87 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegationResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegationResolver.java
@@ -21,11 +21,11 @@ import com.google.common.collect.Collections2;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetDelegationSpecifier;
-import org.jetbrains.kotlin.psi.JetDelegatorByExpressionSpecifier;
-import org.jetbrains.kotlin.psi.JetTypeReference;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtDelegationSpecifier;
+import org.jetbrains.kotlin.psi.KtDelegatorByExpressionSpecifier;
+import org.jetbrains.kotlin.psi.KtTypeReference;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 
 import java.util.ArrayList;
@@ -41,7 +41,7 @@ public final class DelegationResolver<T extends CallableMemberDescriptor> {
 
     @NotNull
     public static <T extends CallableMemberDescriptor> Collection<T> generateDelegatedMembers(
-            @NotNull JetClassOrObject classOrObject,
+            @NotNull KtClassOrObject classOrObject,
             @NotNull ClassDescriptor ownerDescriptor,
             @NotNull Collection<? extends CallableDescriptor> existingMembers,
             @NotNull BindingTrace trace,
@@ -52,7 +52,7 @@ public final class DelegationResolver<T extends CallableMemberDescriptor> {
                 .generateDelegatedMembers();
     }
 
-    @NotNull private final JetClassOrObject classOrObject;
+    @NotNull private final KtClassOrObject classOrObject;
     @NotNull private final ClassDescriptor ownerDescriptor;
     @NotNull private final Collection<? extends CallableDescriptor> existingMembers;
     @NotNull private final BindingTrace trace;
@@ -60,7 +60,7 @@ public final class DelegationResolver<T extends CallableMemberDescriptor> {
     @NotNull private final TypeResolver typeResolver;
 
     private DelegationResolver(
-            @NotNull JetClassOrObject classOrObject,
+            @NotNull KtClassOrObject classOrObject,
             @NotNull ClassDescriptor ownerDescriptor,
             @NotNull Collection<? extends CallableDescriptor> existingMembers,
             @NotNull BindingTrace trace,
@@ -79,16 +79,16 @@ public final class DelegationResolver<T extends CallableMemberDescriptor> {
     @NotNull
     private Collection<T> generateDelegatedMembers() {
         Collection<T> delegatedMembers = new HashSet<T>();
-        for (JetDelegationSpecifier delegationSpecifier : classOrObject.getDelegationSpecifiers()) {
-            if (!(delegationSpecifier instanceof JetDelegatorByExpressionSpecifier)) {
+        for (KtDelegationSpecifier delegationSpecifier : classOrObject.getDelegationSpecifiers()) {
+            if (!(delegationSpecifier instanceof KtDelegatorByExpressionSpecifier)) {
                 continue;
             }
-            JetDelegatorByExpressionSpecifier specifier = (JetDelegatorByExpressionSpecifier) delegationSpecifier;
-            JetTypeReference typeReference = specifier.getTypeReference();
+            KtDelegatorByExpressionSpecifier specifier = (KtDelegatorByExpressionSpecifier) delegationSpecifier;
+            KtTypeReference typeReference = specifier.getTypeReference();
             if (typeReference == null) {
                 continue;
             }
-            JetType delegatedTraitType = typeResolver.resolve(typeReference);
+            KtType delegatedTraitType = typeResolver.resolve(typeReference);
             if (delegatedTraitType == null || delegatedTraitType.isError()) {
                 continue;
             }
@@ -101,7 +101,7 @@ public final class DelegationResolver<T extends CallableMemberDescriptor> {
     @NotNull
     private Collection<T> generateDelegatesForTrait(
             @NotNull Collection<T> existingDelegates,
-            @NotNull JetType delegatedTraitType
+            @NotNull KtType delegatedTraitType
     ) {
         Collection<T> result = new HashSet<T>();
         Collection<T> candidates = generateDelegationCandidates(delegatedTraitType);
@@ -120,7 +120,7 @@ public final class DelegationResolver<T extends CallableMemberDescriptor> {
     }
 
     @NotNull
-    private Collection<T> generateDelegationCandidates(@NotNull JetType delegatedTraitType) {
+    private Collection<T> generateDelegationCandidates(@NotNull KtType delegatedTraitType) {
         Collection<T> descriptorsToDelegate = overridableMembersNotFromSuperClassOfTrait(delegatedTraitType);
         Collection<T> result = new ArrayList<T>(descriptorsToDelegate.size());
         for (T memberDescriptor : descriptorsToDelegate) {
@@ -156,7 +156,7 @@ public final class DelegationResolver<T extends CallableMemberDescriptor> {
     }
 
     @NotNull
-    private Collection<T> overridableMembersNotFromSuperClassOfTrait(@NotNull JetType trait) {
+    private Collection<T> overridableMembersNotFromSuperClassOfTrait(@NotNull KtType trait) {
         final Collection<T> membersToSkip = getMembersFromClassSupertypeOfTrait(trait);
         return Collections2.filter(
                 memberExtractor.getMembersByType(trait),
@@ -182,9 +182,9 @@ public final class DelegationResolver<T extends CallableMemberDescriptor> {
     }
 
     @NotNull
-    private Collection<T> getMembersFromClassSupertypeOfTrait(@NotNull JetType traitType) {
-        JetType classSupertype = null;
-        for (JetType supertype : TypeUtils.getAllSupertypes(traitType)) {
+    private Collection<T> getMembersFromClassSupertypeOfTrait(@NotNull KtType traitType) {
+        KtType classSupertype = null;
+        for (KtType supertype : TypeUtils.getAllSupertypes(traitType)) {
             if (isNotTrait(supertype.getConstructor().getDeclarationDescriptor())) {
                 classSupertype = supertype;
                 break;
@@ -203,11 +203,11 @@ public final class DelegationResolver<T extends CallableMemberDescriptor> {
 
     public interface MemberExtractor<T extends CallableMemberDescriptor> {
         @NotNull
-        Collection<T> getMembersByType(@NotNull JetType type);
+        Collection<T> getMembersByType(@NotNull KtType type);
     }
 
     public interface TypeResolver {
         @Nullable
-        JetType resolve(@NotNull JetTypeReference reference);
+        KtType resolve(@NotNull KtTypeReference reference);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java
index 9b28337526e..c79902ffcbf 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.descriptors.annotations.CompositeAnnotations;
 import org.jetbrains.kotlin.descriptors.impl.*;
 import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
@@ -53,7 +53,7 @@ import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
 import org.jetbrains.kotlin.resolve.source.KotlinSourceElementKt;
 import org.jetbrains.kotlin.storage.StorageManager;
 import org.jetbrains.kotlin.types.*;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
 import org.jetbrains.kotlin.types.expressions.PreliminaryDeclarationVisitor;
 
@@ -61,7 +61,7 @@ import java.util.*;
 
 import static org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget.*;
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
+import static org.jetbrains.kotlin.lexer.KtTokens.*;
 import static org.jetbrains.kotlin.resolve.BindingContext.*;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
 import static org.jetbrains.kotlin.resolve.ModifiersChecker.resolveModalityFromModifiers;
@@ -96,20 +96,20 @@ public class DescriptorResolver {
         this.constantExpressionEvaluator = constantExpressionEvaluator;
     }
 
-    public List<JetType> resolveSupertypes(
+    public List<KtType> resolveSupertypes(
             @NotNull LexicalScope scope,
             @NotNull ClassDescriptor classDescriptor,
-            @NotNull JetClassOrObject jetClass,
+            @NotNull KtClassOrObject jetClass,
             BindingTrace trace
     ) {
-        List<JetType> supertypes = Lists.newArrayList();
-        List<JetDelegationSpecifier> delegationSpecifiers = jetClass.getDelegationSpecifiers();
-        Collection<JetType> declaredSupertypes = resolveDelegationSpecifiers(
+        List<KtType> supertypes = Lists.newArrayList();
+        List<KtDelegationSpecifier> delegationSpecifiers = jetClass.getDelegationSpecifiers();
+        Collection<KtType> declaredSupertypes = resolveDelegationSpecifiers(
                 scope,
                 delegationSpecifiers,
                 typeResolver, trace, false);
 
-        for (JetType declaredSupertype : declaredSupertypes) {
+        for (KtType declaredSupertype : declaredSupertypes) {
             addValidSupertype(supertypes, declaredSupertype);
         }
 
@@ -118,21 +118,21 @@ public class DescriptorResolver {
         }
 
         if (supertypes.isEmpty()) {
-            JetType defaultSupertype = getDefaultSupertype(jetClass, trace, classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS);
+            KtType defaultSupertype = getDefaultSupertype(jetClass, trace, classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS);
             addValidSupertype(supertypes, defaultSupertype);
         }
 
         return supertypes;
     }
 
-    private static void addValidSupertype(List<JetType> supertypes, JetType declaredSupertype) {
+    private static void addValidSupertype(List<KtType> supertypes, KtType declaredSupertype) {
         if (!declaredSupertype.isError()) {
             supertypes.add(declaredSupertype);
         }
     }
 
-    private boolean containsClass(Collection<JetType> result) {
-        for (JetType type : result) {
+    private boolean containsClass(Collection<KtType> result) {
+        for (KtType type : result) {
             ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
             if (descriptor instanceof ClassDescriptor && ((ClassDescriptor) descriptor).getKind() != ClassKind.INTERFACE) {
                 return true;
@@ -141,10 +141,10 @@ public class DescriptorResolver {
         return false;
     }
 
-    private JetType getDefaultSupertype(JetClassOrObject jetClass, BindingTrace trace, boolean isAnnotation) {
+    private KtType getDefaultSupertype(KtClassOrObject jetClass, BindingTrace trace, boolean isAnnotation) {
         // TODO : beautify
-        if (jetClass instanceof JetEnumEntry) {
-            JetClassOrObject parent = JetStubbedPsiUtil.getContainingDeclaration(jetClass, JetClassOrObject.class);
+        if (jetClass instanceof KtEnumEntry) {
+            KtClassOrObject parent = KtStubbedPsiUtil.getContainingDeclaration(jetClass, KtClassOrObject.class);
             ClassDescriptor parentDescriptor = trace.getBindingContext().get(BindingContext.CLASS, parent);
             if (parentDescriptor.getTypeConstructor().getParameters().isEmpty()) {
                 return parentDescriptor.getDefaultType();
@@ -160,9 +160,9 @@ public class DescriptorResolver {
         return builtIns.getAnyType();
     }
 
-    public Collection<JetType> resolveDelegationSpecifiers(
+    public Collection<KtType> resolveDelegationSpecifiers(
             LexicalScope extensibleScope,
-            List<JetDelegationSpecifier> delegationSpecifiers,
+            List<KtDelegationSpecifier> delegationSpecifiers,
             @NotNull TypeResolver resolver,
             BindingTrace trace,
             boolean checkBounds
@@ -170,17 +170,17 @@ public class DescriptorResolver {
         if (delegationSpecifiers.isEmpty()) {
             return Collections.emptyList();
         }
-        Collection<JetType> result = Lists.newArrayList();
-        for (JetDelegationSpecifier delegationSpecifier : delegationSpecifiers) {
-            JetTypeReference typeReference = delegationSpecifier.getTypeReference();
+        Collection<KtType> result = Lists.newArrayList();
+        for (KtDelegationSpecifier delegationSpecifier : delegationSpecifiers) {
+            KtTypeReference typeReference = delegationSpecifier.getTypeReference();
             if (typeReference != null) {
-                JetType supertype = resolver.resolveType(extensibleScope, typeReference, trace, checkBounds);
+                KtType supertype = resolver.resolveType(extensibleScope, typeReference, trace, checkBounds);
                 if (DynamicTypesKt.isDynamic(supertype)) {
                     trace.report(DYNAMIC_SUPERTYPE.on(typeReference));
                 }
                 else {
                     result.add(supertype);
-                    JetTypeElement bareSuperType = checkNullableSupertypeAndStripQuestionMarks(trace, typeReference.getTypeElement());
+                    KtTypeElement bareSuperType = checkNullableSupertypeAndStripQuestionMarks(trace, typeReference.getTypeElement());
                     checkProjectionsInImmediateArguments(trace, bareSuperType);
                 }
             }
@@ -192,24 +192,24 @@ public class DescriptorResolver {
     }
 
     @Nullable
-    private static JetTypeElement checkNullableSupertypeAndStripQuestionMarks(@NotNull BindingTrace trace, @Nullable JetTypeElement typeElement) {
-        while (typeElement instanceof JetNullableType) {
-            JetNullableType nullableType = (JetNullableType) typeElement;
+    private static KtTypeElement checkNullableSupertypeAndStripQuestionMarks(@NotNull BindingTrace trace, @Nullable KtTypeElement typeElement) {
+        while (typeElement instanceof KtNullableType) {
+            KtNullableType nullableType = (KtNullableType) typeElement;
             typeElement = nullableType.getInnerType();
             // report only for innermost '?', the rest gets a 'redundant' warning
-            if (!(typeElement instanceof JetNullableType) && typeElement != null) {
+            if (!(typeElement instanceof KtNullableType) && typeElement != null) {
                 trace.report(NULLABLE_SUPERTYPE.on(nullableType));
             }
         }
         return typeElement;
     }
 
-    private static void checkProjectionsInImmediateArguments(@NotNull BindingTrace trace, @Nullable JetTypeElement typeElement) {
-        if (typeElement instanceof JetUserType) {
-            JetUserType userType = (JetUserType) typeElement;
-            List<JetTypeProjection> typeArguments = userType.getTypeArguments();
-            for (JetTypeProjection typeArgument : typeArguments) {
-                if (typeArgument.getProjectionKind() != JetProjectionKind.NONE) {
+    private static void checkProjectionsInImmediateArguments(@NotNull BindingTrace trace, @Nullable KtTypeElement typeElement) {
+        if (typeElement instanceof KtUserType) {
+            KtUserType userType = (KtUserType) typeElement;
+            List<KtTypeProjection> typeArguments = userType.getTypeArguments();
+            for (KtTypeProjection typeArgument : typeArguments) {
+                if (typeArgument.getProjectionKind() != KtProjectionKind.NONE) {
                     trace.report(PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE.on(typeArgument));
                 }
             }
@@ -225,7 +225,7 @@ public class DescriptorResolver {
             @NotNull BindingTrace trace
     ) {
         Name functionName = DataClassUtilsKt.createComponentName(parameterIndex);
-        JetType returnType = property.getType();
+        KtType returnType = property.getType();
 
         SimpleFunctionDescriptorImpl functionDescriptor = SimpleFunctionDescriptorImpl.create(
                 classDescriptor,
@@ -257,7 +257,7 @@ public class DescriptorResolver {
             @NotNull ClassDescriptor classDescriptor,
             @NotNull BindingTrace trace
     ) {
-        JetType returnType = classDescriptor.getDefaultType();
+        KtType returnType = classDescriptor.getDefaultType();
 
         SimpleFunctionDescriptorImpl functionDescriptor = SimpleFunctionDescriptorImpl.create(
                 classDescriptor,
@@ -300,10 +300,10 @@ public class DescriptorResolver {
         return functionDescriptor;
     }
 
-    public static Visibility getDefaultVisibility(JetModifierListOwner modifierListOwner, DeclarationDescriptor containingDescriptor) {
+    public static Visibility getDefaultVisibility(KtModifierListOwner modifierListOwner, DeclarationDescriptor containingDescriptor) {
         Visibility defaultVisibility;
         if (containingDescriptor instanceof ClassDescriptor) {
-            JetModifierList modifierList = modifierListOwner.getModifierList();
+            KtModifierList modifierList = modifierListOwner.getModifierList();
             defaultVisibility = modifierList != null && modifierList.hasModifier(OVERRIDE_KEYWORD)
                                            ? Visibilities.INHERITED
                                            : Visibilities.DEFAULT_VISIBILITY;
@@ -333,16 +333,16 @@ public class DescriptorResolver {
 
     @NotNull
     public ValueParameterDescriptorImpl resolveValueParameterDescriptor(
-            LexicalScope scope, FunctionDescriptor owner, JetParameter valueParameter, int index, JetType type, BindingTrace trace
+            LexicalScope scope, FunctionDescriptor owner, KtParameter valueParameter, int index, KtType type, BindingTrace trace
     ) {
-        JetType varargElementType = null;
-        JetType variableType = type;
+        KtType varargElementType = null;
+        KtType variableType = type;
         if (valueParameter.hasModifier(VARARG_KEYWORD)) {
             varargElementType = type;
             variableType = getVarargParameterType(type);
         }
 
-        JetModifierList modifierList = valueParameter.getModifierList();
+        KtModifierList modifierList = valueParameter.getModifierList();
 
         Annotations allAnnotations =
                 annotationResolver.resolveAnnotationsWithoutArguments(scope, valueParameter.getModifierList(), trace);
@@ -364,7 +364,7 @@ public class DescriptorResolver {
                 null,
                 index,
                 valueParameterAnnotations,
-                JetPsiUtil.safeName(valueParameter.getName()),
+                KtPsiUtil.safeName(valueParameter.getName()),
                 variableType,
                 valueParameter.hasDefaultValue(),
                 valueParameter.hasModifier(CROSSINLINE_KEYWORD),
@@ -378,8 +378,8 @@ public class DescriptorResolver {
     }
 
     @NotNull
-    private JetType getVarargParameterType(@NotNull JetType elementType) {
-        JetType primitiveArrayType = builtIns.getPrimitiveArrayJetTypeByPrimitiveJetType(elementType);
+    private KtType getVarargParameterType(@NotNull KtType elementType) {
+        KtType primitiveArrayType = builtIns.getPrimitiveArrayJetTypeByPrimitiveJetType(elementType);
         if (primitiveArrayType != null) {
             return primitiveArrayType;
         }
@@ -390,12 +390,12 @@ public class DescriptorResolver {
             DeclarationDescriptor containingDescriptor,
             LexicalWritableScope extensibleScope,
             LexicalScope scopeForAnnotationsResolve,
-            List<JetTypeParameter> typeParameters,
+            List<KtTypeParameter> typeParameters,
             BindingTrace trace
     ) {
         List<TypeParameterDescriptorImpl> result = new ArrayList<TypeParameterDescriptorImpl>();
         for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) {
-            JetTypeParameter typeParameter = typeParameters.get(i);
+            KtTypeParameter typeParameter = typeParameters.get(i);
             result.add(resolveTypeParameterForCallableDescriptor(
                     containingDescriptor, extensibleScope, scopeForAnnotationsResolve, typeParameter, i, trace));
         }
@@ -406,7 +406,7 @@ public class DescriptorResolver {
             DeclarationDescriptor containingDescriptor,
             LexicalWritableScope extensibleScope,
             LexicalScope scopeForAnnotationsResolve,
-            JetTypeParameter typeParameter,
+            KtTypeParameter typeParameter,
             int index,
             BindingTrace trace
     ) {
@@ -421,9 +421,9 @@ public class DescriptorResolver {
         TypeParameterDescriptorImpl typeParameterDescriptor = TypeParameterDescriptorImpl.createForFurtherModification(
                 containingDescriptor,
                 annotations,
-                typeParameter.hasModifier(JetTokens.REIFIED_KEYWORD),
+                typeParameter.hasModifier(KtTokens.REIFIED_KEYWORD),
                 typeParameter.getVariance(),
-                JetPsiUtil.safeName(typeParameter.getName()),
+                KtPsiUtil.safeName(typeParameter.getName()),
                 index,
                 KotlinSourceElementKt.toSourceElement(typeParameter)
         );
@@ -434,36 +434,36 @@ public class DescriptorResolver {
 
     @NotNull
     public static ConstructorDescriptorImpl createAndRecordPrimaryConstructorForObject(
-            @Nullable JetClassOrObject object,
+            @Nullable KtClassOrObject object,
             @NotNull ClassDescriptor classDescriptor,
             @NotNull BindingTrace trace
     ) {
         ConstructorDescriptorImpl constructorDescriptor =
                 DescriptorFactory.createPrimaryConstructorForObject(classDescriptor, KotlinSourceElementKt.toSourceElement(object));
         if (object != null) {
-            JetPrimaryConstructor primaryConstructor = object.getPrimaryConstructor();
+            KtPrimaryConstructor primaryConstructor = object.getPrimaryConstructor();
             trace.record(CONSTRUCTOR, primaryConstructor != null ? primaryConstructor : object, constructorDescriptor);
         }
         return constructorDescriptor;
     }
 
     static final class UpperBoundCheckerTask {
-        JetTypeReference upperBound;
-        JetType upperBoundType;
+        KtTypeReference upperBound;
+        KtType upperBoundType;
 
-        private UpperBoundCheckerTask(JetTypeReference upperBound, JetType upperBoundType) {
+        private UpperBoundCheckerTask(KtTypeReference upperBound, KtType upperBoundType) {
             this.upperBound = upperBound;
             this.upperBoundType = upperBoundType;
         }
     }
 
-    public JetType resolveTypeParameterExtendsBound(
+    public KtType resolveTypeParameterExtendsBound(
             @NotNull TypeParameterDescriptor typeParameterDescriptor,
-            @NotNull JetTypeReference extendsBound,
+            @NotNull KtTypeReference extendsBound,
             LexicalScope scope,
             BindingTrace trace
     ) {
-        JetType type = typeResolver.resolveType(scope, extendsBound, trace, false);
+        KtType type = typeResolver.resolveType(scope, extendsBound, trace, false);
         if (type.getConstructor().equals(typeParameterDescriptor.getTypeConstructor())) {
             trace.report(Errors.CYCLIC_GENERIC_UPPER_BOUND.on(extendsBound));
             type = ErrorUtils.createErrorType("Cyclic upper bound: " + type);
@@ -472,7 +472,7 @@ public class DescriptorResolver {
     }
 
     public void resolveGenericBounds(
-            @NotNull JetTypeParameterListOwner declaration,
+            @NotNull KtTypeParameterListOwner declaration,
             @NotNull DeclarationDescriptor descriptor,
             LexicalScope scope,
             List<TypeParameterDescriptorImpl> parameters,
@@ -480,30 +480,30 @@ public class DescriptorResolver {
     ) {
         List<UpperBoundCheckerTask> deferredUpperBoundCheckerTasks = Lists.newArrayList();
 
-        List<JetTypeParameter> typeParameters = declaration.getTypeParameters();
+        List<KtTypeParameter> typeParameters = declaration.getTypeParameters();
         Map<Name, TypeParameterDescriptorImpl> parameterByName = Maps.newHashMap();
         for (int i = 0; i < typeParameters.size(); i++) {
-            JetTypeParameter jetTypeParameter = typeParameters.get(i);
+            KtTypeParameter jetTypeParameter = typeParameters.get(i);
             TypeParameterDescriptorImpl typeParameterDescriptor = parameters.get(i);
 
             parameterByName.put(typeParameterDescriptor.getName(), typeParameterDescriptor);
 
-            JetTypeReference extendsBound = jetTypeParameter.getExtendsBound();
+            KtTypeReference extendsBound = jetTypeParameter.getExtendsBound();
             if (extendsBound != null) {
-                JetType type = resolveTypeParameterExtendsBound(typeParameterDescriptor, extendsBound, scope, trace);
+                KtType type = resolveTypeParameterExtendsBound(typeParameterDescriptor, extendsBound, scope, trace);
                 typeParameterDescriptor.addUpperBound(type);
                 deferredUpperBoundCheckerTasks.add(new UpperBoundCheckerTask(extendsBound, type));
             }
         }
-        for (JetTypeConstraint constraint : declaration.getTypeConstraints()) {
-            JetSimpleNameExpression subjectTypeParameterName = constraint.getSubjectTypeParameterName();
+        for (KtTypeConstraint constraint : declaration.getTypeConstraints()) {
+            KtSimpleNameExpression subjectTypeParameterName = constraint.getSubjectTypeParameterName();
             if (subjectTypeParameterName == null) {
                 continue;
             }
             Name referencedName = subjectTypeParameterName.getReferencedNameAsName();
             TypeParameterDescriptorImpl typeParameterDescriptor = parameterByName.get(referencedName);
-            JetTypeReference boundTypeReference = constraint.getBoundTypeReference();
-            JetType bound = null;
+            KtTypeReference boundTypeReference = constraint.getBoundTypeReference();
+            KtType bound = null;
             if (boundTypeReference != null) {
                 bound = typeResolver.resolveType(scope, boundTypeReference, trace, false);
                 deferredUpperBoundCheckerTasks.add(new UpperBoundCheckerTask(boundTypeReference, bound));
@@ -525,7 +525,7 @@ public class DescriptorResolver {
             checkConflictingUpperBounds(trace, parameter, typeParameters.get(parameter.getIndex()));
         }
 
-        if (!(declaration instanceof JetClass)) {
+        if (!(declaration instanceof KtClass)) {
             for (UpperBoundCheckerTask checkerTask : deferredUpperBoundCheckerTasks) {
                 checkUpperBoundType(checkerTask.upperBound, checkerTask.upperBoundType, trace);
             }
@@ -537,7 +537,7 @@ public class DescriptorResolver {
     public static void checkConflictingUpperBounds(
             @NotNull BindingTrace trace,
             @NotNull TypeParameterDescriptor parameter,
-            @NotNull JetTypeParameter typeParameter
+            @NotNull KtTypeParameter typeParameter
     ) {
         if (KotlinBuiltIns.isNothing(parameter.getUpperBoundsAsType())) {
             trace.report(CONFLICTING_UPPER_BOUNDS.on(typeParameter, parameter));
@@ -545,13 +545,13 @@ public class DescriptorResolver {
     }
 
     public void checkNamesInConstraints(
-            @NotNull JetTypeParameterListOwner declaration,
+            @NotNull KtTypeParameterListOwner declaration,
             @NotNull DeclarationDescriptor descriptor,
             @NotNull LexicalScope scope,
             @NotNull BindingTrace trace
     ) {
-        for (JetTypeConstraint constraint : declaration.getTypeConstraints()) {
-            JetSimpleNameExpression nameExpression = constraint.getSubjectTypeParameterName();
+        for (KtTypeConstraint constraint : declaration.getTypeConstraints()) {
+            KtSimpleNameExpression nameExpression = constraint.getSubjectTypeParameterName();
             if (nameExpression == null) continue;
 
             Name name = nameExpression.getReferencedNameAsName();
@@ -568,7 +568,7 @@ public class DescriptorResolver {
                 trace.report(UNRESOLVED_REFERENCE.on(nameExpression, nameExpression));
             }
 
-            JetTypeReference boundTypeReference = constraint.getBoundTypeReference();
+            KtTypeReference boundTypeReference = constraint.getBoundTypeReference();
             if (boundTypeReference != null) {
                 typeResolver.resolveType(scope, boundTypeReference, trace, true);
             }
@@ -576,11 +576,11 @@ public class DescriptorResolver {
     }
 
     public static void checkUpperBoundType(
-            JetTypeReference upperBound,
-            @NotNull JetType upperBoundType,
+            KtTypeReference upperBound,
+            @NotNull KtType upperBoundType,
             BindingTrace trace
     ) {
-        if (!TypeUtils.canHaveSubtypes(JetTypeChecker.DEFAULT, upperBoundType)) {
+        if (!TypeUtils.canHaveSubtypes(KotlinTypeChecker.DEFAULT, upperBoundType)) {
             ClassifierDescriptor descriptor = upperBoundType.getConstructor().getDeclarationDescriptor();
             if (descriptor instanceof ClassDescriptor) {
                 if (((ClassDescriptor) descriptor).getModality() == Modality.SEALED) return;
@@ -595,16 +595,16 @@ public class DescriptorResolver {
     @NotNull
     public VariableDescriptor resolveLocalVariableDescriptor(
             @NotNull LexicalScope scope,
-            @NotNull JetParameter parameter,
+            @NotNull KtParameter parameter,
             BindingTrace trace
     ) {
-        JetType type = resolveParameterType(scope, parameter, trace);
+        KtType type = resolveParameterType(scope, parameter, trace);
         return resolveLocalVariableDescriptor(parameter, type, trace, scope);
     }
 
-    private JetType resolveParameterType(LexicalScope scope, JetParameter parameter, BindingTrace trace) {
-        JetTypeReference typeReference = parameter.getTypeReference();
-        JetType type;
+    private KtType resolveParameterType(LexicalScope scope, KtParameter parameter, BindingTrace trace) {
+        KtTypeReference typeReference = parameter.getTypeReference();
+        KtType type;
         if (typeReference != null) {
             type = typeResolver.resolveType(scope, typeReference, trace, true);
         }
@@ -619,15 +619,15 @@ public class DescriptorResolver {
     }
 
     public VariableDescriptor resolveLocalVariableDescriptor(
-            @NotNull JetParameter parameter,
-            @NotNull JetType type,
+            @NotNull KtParameter parameter,
+            @NotNull KtType type,
             BindingTrace trace,
             @NotNull LexicalScope scope
     ) {
         VariableDescriptor variableDescriptor = new LocalVariableDescriptor(
                 scope.getOwnerDescriptor(),
                 annotationResolver.resolveAnnotationsWithArguments(scope, parameter.getModifierList(), trace),
-                JetPsiUtil.safeName(parameter.getName()),
+                KtPsiUtil.safeName(parameter.getName()),
                 type,
                 false,
                 KotlinSourceElementKt.toSourceElement(parameter)
@@ -641,22 +641,22 @@ public class DescriptorResolver {
     @NotNull
     public VariableDescriptor resolveLocalVariableDescriptor(
             LexicalScope scope,
-            JetVariableDeclaration variable,
+            KtVariableDeclaration variable,
             DataFlowInfo dataFlowInfo,
             BindingTrace trace
     ) {
         DeclarationDescriptor containingDeclaration = scope.getOwnerDescriptor();
         VariableDescriptor result;
-        JetType type;
+        KtType type;
         // SCRIPT: Create property descriptors
-        if (JetPsiUtil.isScriptDeclaration(variable)) {
+        if (KtPsiUtil.isScriptDeclaration(variable)) {
             PropertyDescriptorImpl propertyDescriptor = PropertyDescriptorImpl.create(
                     containingDeclaration,
                     annotationResolver.resolveAnnotationsWithArguments(scope, variable.getModifierList(), trace),
                     Modality.FINAL,
                     Visibilities.INTERNAL,
                     variable.isVar(),
-                    JetPsiUtil.safeName(variable.getName()),
+                    KtPsiUtil.safeName(variable.getName()),
                     CallableMemberDescriptor.Kind.DECLARATION,
                     KotlinSourceElementKt.toSourceElement(variable),
                     /* lateInit = */ false,
@@ -666,7 +666,7 @@ public class DescriptorResolver {
             type = getVariableType(propertyDescriptor, scope, variable, dataFlowInfo, false, trace);
 
             ReceiverParameterDescriptor receiverParameter = ((ScriptDescriptor) containingDeclaration).getThisAsReceiverParameter();
-            propertyDescriptor.setType(type, Collections.<TypeParameterDescriptor>emptyList(), receiverParameter, (JetType) null);
+            propertyDescriptor.setType(type, Collections.<TypeParameterDescriptor>emptyList(), receiverParameter, (KtType) null);
             initializeWithDefaultGetterSetter(propertyDescriptor);
             trace.record(BindingContext.VARIABLE, variable, propertyDescriptor);
             result = propertyDescriptor;
@@ -701,14 +701,14 @@ public class DescriptorResolver {
     @NotNull
     public LocalVariableDescriptor resolveLocalVariableDescriptorWithType(
             @NotNull LexicalScope scope,
-            @NotNull JetVariableDeclaration variable,
-            @Nullable JetType type,
+            @NotNull KtVariableDeclaration variable,
+            @Nullable KtType type,
             @NotNull BindingTrace trace
     ) {
         LocalVariableDescriptor variableDescriptor = new LocalVariableDescriptor(
                 scope.getOwnerDescriptor(),
                 annotationResolver.resolveAnnotationsWithArguments(scope, variable.getModifierList(), trace),
-                JetPsiUtil.safeName(variable.getName()),
+                KtPsiUtil.safeName(variable.getName()),
                 type,
                 variable.isVar(),
                 KotlinSourceElementKt.toSourceElement(variable)
@@ -721,11 +721,11 @@ public class DescriptorResolver {
     public PropertyDescriptor resolvePropertyDescriptor(
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull LexicalScope scope,
-            @NotNull JetProperty property,
+            @NotNull KtProperty property,
             @NotNull final BindingTrace trace,
             @NotNull DataFlowInfo dataFlowInfo
     ) {
-        JetModifierList modifierList = property.getModifierList();
+        KtModifierList modifierList = property.getModifierList();
         boolean isVar = property.isVar();
 
         boolean hasBody = hasBody(property);
@@ -755,20 +755,20 @@ public class DescriptorResolver {
                 modality,
                 visibility,
                 isVar,
-                JetPsiUtil.safeName(property.getName()),
+                KtPsiUtil.safeName(property.getName()),
                 CallableMemberDescriptor.Kind.DECLARATION,
                 KotlinSourceElementKt.toSourceElement(property),
-                modifierList != null && modifierList.hasModifier(JetTokens.LATEINIT_KEYWORD),
-                modifierList != null && modifierList.hasModifier(JetTokens.CONST_KEYWORD)
+                modifierList != null && modifierList.hasModifier(KtTokens.LATEINIT_KEYWORD),
+                modifierList != null && modifierList.hasModifier(KtTokens.CONST_KEYWORD)
         );
         wrapper.setProperty(propertyDescriptor);
 
         List<TypeParameterDescriptorImpl> typeParameterDescriptors;
         LexicalScope scopeWithTypeParameters;
-        JetType receiverType = null;
+        KtType receiverType = null;
 
         {
-            List<JetTypeParameter> typeParameters = property.getTypeParameters();
+            List<KtTypeParameter> typeParameters = property.getTypeParameters();
             if (typeParameters.isEmpty()) {
                 scopeWithTypeParameters = scope;
                 typeParameterDescriptors = Collections.emptyList();
@@ -784,7 +784,7 @@ public class DescriptorResolver {
                 scopeWithTypeParameters = writableScope;
             }
 
-            JetTypeReference receiverTypeRef = property.getReceiverTypeReference();
+            KtTypeReference receiverTypeRef = property.getReceiverTypeReference();
             if (receiverTypeRef != null) {
                 receiverType = typeResolver.resolveType(scopeWithTypeParameters, receiverTypeRef, trace, true);
             }
@@ -798,7 +798,7 @@ public class DescriptorResolver {
         LexicalScope propertyScope = JetScopeUtils.getPropertyDeclarationInnerScope(propertyDescriptor, scope, typeParameterDescriptors,
                                                                                     implicitInitializerReceiver, trace);
 
-        JetType type = getVariableType(propertyDescriptor, propertyScope, property, dataFlowInfo, true, trace);
+        KtType type = getVariableType(propertyDescriptor, propertyScope, property, dataFlowInfo, true, trace);
 
         propertyDescriptor.setType(type, typeParameterDescriptors, getDispatchReceiverParameterIfNeeded(containingDeclaration),
                                    receiverDescriptor);
@@ -815,14 +815,14 @@ public class DescriptorResolver {
     }
 
     /*package*/
-    static boolean hasBody(JetProperty property) {
+    static boolean hasBody(KtProperty property) {
         boolean hasBody = property.hasDelegateExpressionOrInitializer();
         if (!hasBody) {
-            JetPropertyAccessor getter = property.getGetter();
+            KtPropertyAccessor getter = property.getGetter();
             if (getter != null && getter.hasBody()) {
                 hasBody = true;
             }
-            JetPropertyAccessor setter = property.getSetter();
+            KtPropertyAccessor setter = property.getSetter();
             if (!hasBody && setter != null && setter.hasBody()) {
                 hasBody = true;
             }
@@ -831,28 +831,28 @@ public class DescriptorResolver {
     }
 
     @NotNull
-    private JetType getVariableType(
+    private KtType getVariableType(
             @NotNull final VariableDescriptorWithInitializerImpl variableDescriptor,
             @NotNull final LexicalScope scope,
-            @NotNull final JetVariableDeclaration variable,
+            @NotNull final KtVariableDeclaration variable,
             @NotNull final DataFlowInfo dataFlowInfo,
             boolean notLocal,
             @NotNull final BindingTrace trace
     ) {
-        JetTypeReference propertyTypeRef = variable.getTypeReference();
+        KtTypeReference propertyTypeRef = variable.getTypeReference();
 
-        boolean hasDelegate = variable instanceof JetProperty && ((JetProperty) variable).hasDelegateExpression();
+        boolean hasDelegate = variable instanceof KtProperty && ((KtProperty) variable).hasDelegateExpression();
         if (propertyTypeRef == null) {
             if (!variable.hasInitializer()) {
                 if (hasDelegate && variableDescriptor instanceof PropertyDescriptor) {
-                    final JetProperty property = (JetProperty) variable;
+                    final KtProperty property = (KtProperty) variable;
                     if (property.hasDelegateExpression()) {
                         return DeferredType.createRecursionIntolerant(
                                 storageManager,
                                 trace,
-                                new Function0<JetType>() {
+                                new Function0<KtType>() {
                                     @Override
-                                    public JetType invoke() {
+                                    public KtType invoke() {
                                         return resolveDelegatedPropertyType(property, (PropertyDescriptor) variableDescriptor, scope,
                                                                             property.getDelegateExpression(), dataFlowInfo, trace);
                                     }
@@ -869,11 +869,11 @@ public class DescriptorResolver {
                     return DeferredType.createRecursionIntolerant(
                             storageManager,
                             trace,
-                            new Function0<JetType>() {
+                            new Function0<KtType>() {
                                 @Override
-                                public JetType invoke() {
+                                public KtType invoke() {
                                     PreliminaryDeclarationVisitor.Companion.createForDeclaration(variable, trace);
-                                    JetType initializerType = resolveInitializerType(scope, variable.getInitializer(), dataFlowInfo, trace);
+                                    KtType initializerType = resolveInitializerType(scope, variable.getInitializer(), dataFlowInfo, trace);
                                     setConstantForVariableIfNeeded(variableDescriptor, scope, variable, dataFlowInfo, initializerType, trace);
                                     return transformAnonymousTypeIfNeeded(variableDescriptor, variable, initializerType, trace);
                                 }
@@ -881,14 +881,14 @@ public class DescriptorResolver {
                     );
                 }
                 else {
-                    JetType initializerType = resolveInitializerType(scope, variable.getInitializer(), dataFlowInfo, trace);
+                    KtType initializerType = resolveInitializerType(scope, variable.getInitializer(), dataFlowInfo, trace);
                     setConstantForVariableIfNeeded(variableDescriptor, scope, variable, dataFlowInfo, initializerType, trace);
                     return initializerType;
                 }
             }
         }
         else {
-            JetType type = typeResolver.resolveType(scope, propertyTypeRef, trace, true);
+            KtType type = typeResolver.resolveType(scope, propertyTypeRef, trace, true);
             setConstantForVariableIfNeeded(variableDescriptor, scope, variable, dataFlowInfo, type, trace);
             return type;
         }
@@ -897,9 +897,9 @@ public class DescriptorResolver {
     private void setConstantForVariableIfNeeded(
             @NotNull final VariableDescriptorWithInitializerImpl variableDescriptor,
             @NotNull final LexicalScope scope,
-            @NotNull final JetVariableDeclaration variable,
+            @NotNull final KtVariableDeclaration variable,
             @NotNull final DataFlowInfo dataFlowInfo,
-            @NotNull final JetType variableType,
+            @NotNull final KtType variableType,
             @NotNull final BindingTrace trace
     ) {
         if (!shouldRecordInitializerForProperty(variableDescriptor, variableType)) return;
@@ -911,8 +911,8 @@ public class DescriptorResolver {
                 @Nullable
                 @Override
                 public ConstantValue<?> invoke() {
-                    JetExpression initializer = variable.getInitializer();
-                    JetType initializerType = expressionTypingServices.safeGetType(scope, initializer, variableType, dataFlowInfo, trace);
+                    KtExpression initializer = variable.getInitializer();
+                    KtType initializerType = expressionTypingServices.safeGetType(scope, initializer, variableType, dataFlowInfo, trace);
                     CompileTimeConstant<?> constant = constantExpressionEvaluator.evaluateExpression(initializer, trace, initializerType);
 
                     if (constant == null) return null;
@@ -928,21 +928,21 @@ public class DescriptorResolver {
     }
 
     @NotNull
-    private JetType resolveDelegatedPropertyType(
-            @NotNull JetProperty property,
+    private KtType resolveDelegatedPropertyType(
+            @NotNull KtProperty property,
             @NotNull PropertyDescriptor propertyDescriptor,
             @NotNull LexicalScope scope,
-            @NotNull JetExpression delegateExpression,
+            @NotNull KtExpression delegateExpression,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull BindingTrace trace
     ) {
         LexicalScope accessorScope = JetScopeUtils.makeScopeForPropertyAccessor(propertyDescriptor, scope, trace);
 
-        JetType type = delegatedPropertyResolver.resolveDelegateExpression(
+        KtType type = delegatedPropertyResolver.resolveDelegateExpression(
                 delegateExpression, property, propertyDescriptor, scope, accessorScope, trace, dataFlowInfo);
 
         if (type != null) {
-            JetType getterReturnType = delegatedPropertyResolver
+            KtType getterReturnType = delegatedPropertyResolver
                     .getDelegatedPropertyGetMethodReturnType(propertyDescriptor, delegateExpression, type, trace, accessorScope);
             if (getterReturnType != null) {
                 return getterReturnType;
@@ -952,10 +952,10 @@ public class DescriptorResolver {
     }
 
     @Nullable
-    /*package*/ static JetType transformAnonymousTypeIfNeeded(
+    /*package*/ static KtType transformAnonymousTypeIfNeeded(
             @NotNull DeclarationDescriptorWithVisibility descriptor,
-            @NotNull JetNamedDeclaration declaration,
-            @NotNull JetType type,
+            @NotNull KtNamedDeclaration declaration,
+            @NotNull KtType type,
             @NotNull BindingTrace trace
     ) {
         ClassifierDescriptor classifier = type.getConstructor().getDeclarationDescriptor();
@@ -977,9 +977,9 @@ public class DescriptorResolver {
     }
 
     @NotNull
-    private JetType resolveInitializerType(
+    private KtType resolveInitializerType(
             @NotNull LexicalScope scope,
-            @NotNull JetExpression initializer,
+            @NotNull KtExpression initializer,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull BindingTrace trace
     ) {
@@ -989,18 +989,18 @@ public class DescriptorResolver {
     @Nullable
     private PropertySetterDescriptor resolvePropertySetterDescriptor(
             @NotNull LexicalScope scope,
-            @NotNull JetProperty property,
+            @NotNull KtProperty property,
             @NotNull PropertyDescriptor propertyDescriptor,
             @NotNull AnnotationSplitter annotationSplitter,
             BindingTrace trace
     ) {
-        JetPropertyAccessor setter = property.getSetter();
+        KtPropertyAccessor setter = property.getSetter();
         PropertySetterDescriptorImpl setterDescriptor = null;
         if (setter != null) {
             Annotations annotations = new CompositeAnnotations(CollectionsKt.listOf(
                     annotationSplitter.getAnnotationsForTarget(PROPERTY_SETTER),
                     annotationResolver.resolveAnnotationsWithoutArguments(scope, setter.getModifierList(), trace)));
-            JetParameter parameter = setter.getParameter();
+            KtParameter parameter = setter.getParameter();
 
             setterDescriptor = new PropertySetterDescriptorImpl(propertyDescriptor, annotations,
                                                                 resolveModalityFromModifiers(setter, propertyDescriptor.getModality()),
@@ -1015,14 +1015,14 @@ public class DescriptorResolver {
                     trace.report(SETTER_PARAMETER_WITH_DEFAULT_VALUE.on(parameter.getDefaultValue()));
                 }
 
-                JetType type;
-                JetTypeReference typeReference = parameter.getTypeReference();
+                KtType type;
+                KtTypeReference typeReference = parameter.getTypeReference();
                 if (typeReference == null) {
                     type = propertyDescriptor.getType(); // TODO : this maybe unknown at this point
                 }
                 else {
                     type = typeResolver.resolveType(scope, typeReference, trace, true);
-                    JetType inType = propertyDescriptor.getType();
+                    KtType inType = propertyDescriptor.getType();
                     if (inType != null) {
                         if (!TypeUtils.equalTypes(type, inType)) {
                             trace.report(WRONG_SETTER_PARAMETER_TYPE.on(typeReference, inType, type));
@@ -1061,21 +1061,21 @@ public class DescriptorResolver {
     @Nullable
     private PropertyGetterDescriptorImpl resolvePropertyGetterDescriptor(
             @NotNull LexicalScope scope,
-            @NotNull JetProperty property,
+            @NotNull KtProperty property,
             @NotNull PropertyDescriptor propertyDescriptor,
             @NotNull AnnotationSplitter annotationSplitter,
             BindingTrace trace
     ) {
         PropertyGetterDescriptorImpl getterDescriptor;
-        JetPropertyAccessor getter = property.getGetter();
+        KtPropertyAccessor getter = property.getGetter();
         if (getter != null) {
             Annotations getterAnnotations = new CompositeAnnotations(CollectionsKt.listOf(
                     annotationSplitter.getAnnotationsForTarget(PROPERTY_GETTER),
                     annotationResolver.resolveAnnotationsWithoutArguments(scope, getter.getModifierList(), trace)));
 
-            JetType outType = propertyDescriptor.getType();
-            JetType returnType = outType;
-            JetTypeReference returnTypeReference = getter.getReturnTypeReference();
+            KtType outType = propertyDescriptor.getType();
+            KtType returnType = outType;
+            KtTypeReference returnTypeReference = getter.getReturnTypeReference();
             if (returnTypeReference != null) {
                 returnType = typeResolver.resolveType(scope, returnTypeReference, trace, true);
                 if (outType != null && !TypeUtils.equalTypes(returnType, outType)) {
@@ -1106,15 +1106,15 @@ public class DescriptorResolver {
             @NotNull ClassDescriptor classDescriptor,
             @NotNull ValueParameterDescriptor valueParameter,
             @NotNull LexicalScope scope,
-            @NotNull JetParameter parameter, final BindingTrace trace
+            @NotNull KtParameter parameter, final BindingTrace trace
     ) {
-        JetType type = resolveParameterType(scope, parameter, trace);
+        KtType type = resolveParameterType(scope, parameter, trace);
         Name name = parameter.getNameAsSafeName();
         boolean isMutable = parameter.isMutable();
-        JetModifierList modifierList = parameter.getModifierList();
+        KtModifierList modifierList = parameter.getModifierList();
 
         if (modifierList != null) {
-            if (modifierList.hasModifier(JetTokens.ABSTRACT_KEYWORD)) {
+            if (modifierList.hasModifier(KtTokens.ABSTRACT_KEYWORD)) {
                 trace.report(ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS.on(parameter));
             }
         }
@@ -1165,17 +1165,17 @@ public class DescriptorResolver {
         return propertyDescriptor;
     }
 
-    public static void checkBounds(@NotNull JetTypeReference typeReference, @NotNull JetType type, @NotNull BindingTrace trace) {
+    public static void checkBounds(@NotNull KtTypeReference typeReference, @NotNull KtType type, @NotNull BindingTrace trace) {
         if (type.isError()) return;
 
-        JetTypeElement typeElement = typeReference.getTypeElement();
+        KtTypeElement typeElement = typeReference.getTypeElement();
         if (typeElement == null) return;
 
         List<TypeParameterDescriptor> parameters = type.getConstructor().getParameters();
         List<TypeProjection> arguments = type.getArguments();
         assert parameters.size() == arguments.size();
 
-        List<JetTypeReference> jetTypeArguments = typeElement.getTypeArgumentsAsTypes();
+        List<KtTypeReference> jetTypeArguments = typeElement.getTypeArgumentsAsTypes();
 
         // A type reference from Kotlin code can yield a flexible type only if it's `ft<T1, T2>`, whose bounds should not be checked
         if (FlexibleTypesKt.isFlexible(type) && !DynamicTypesKt.isDynamic(type)) {
@@ -1193,11 +1193,11 @@ public class DescriptorResolver {
 
         TypeSubstitutor substitutor = TypeSubstitutor.create(type);
         for (int i = 0; i < jetTypeArguments.size(); i++) {
-            JetTypeReference jetTypeArgument = jetTypeArguments.get(i);
+            KtTypeReference jetTypeArgument = jetTypeArguments.get(i);
 
             if (jetTypeArgument == null) continue;
 
-            JetType typeArgument = arguments.get(i).getType();
+            KtType typeArgument = arguments.get(i).getType();
             checkBounds(jetTypeArgument, typeArgument, trace);
 
             TypeParameterDescriptor typeParameterDescriptor = parameters.get(i);
@@ -1206,15 +1206,15 @@ public class DescriptorResolver {
     }
 
     public static void checkBounds(
-            @NotNull JetTypeReference jetTypeArgument,
-            @NotNull JetType typeArgument,
+            @NotNull KtTypeReference jetTypeArgument,
+            @NotNull KtType typeArgument,
             @NotNull TypeParameterDescriptor typeParameterDescriptor,
             @NotNull TypeSubstitutor substitutor,
             @NotNull BindingTrace trace
     ) {
-        for (JetType bound : typeParameterDescriptor.getUpperBounds()) {
-            JetType substitutedBound = substitutor.safeSubstitute(bound, Variance.INVARIANT);
-            if (!JetTypeChecker.DEFAULT.isSubtypeOf(typeArgument, substitutedBound)) {
+        for (KtType bound : typeParameterDescriptor.getUpperBounds()) {
+            KtType substitutedBound = substitutor.safeSubstitute(bound, Variance.INVARIANT);
+            if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(typeArgument, substitutedBound)) {
                 trace.report(UPPER_BOUND_VIOLATED.on(jetTypeArgument, substitutedBound, typeArgument));
             }
         }
@@ -1259,11 +1259,11 @@ public class DescriptorResolver {
         return getParentOfType(scope.getOwnerDescriptor(), ClassDescriptor.class, false);
     }
 
-    public static void registerFileInPackage(@NotNull BindingTrace trace, @NotNull JetFile file) {
+    public static void registerFileInPackage(@NotNull BindingTrace trace, @NotNull KtFile file) {
         // Register files corresponding to this package
         // The trace currently does not support bi-di multimaps that would handle this task nicer
         FqName fqName = file.getPackageFqName();
-        Collection<JetFile> files = trace.get(PACKAGE_TO_FILES, fqName);
+        Collection<KtFile> files = trace.get(PACKAGE_TO_FILES, fqName);
         if (files == null) {
             files = Sets.newIdentityHashSet();
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorToSourceUtils.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorToSourceUtils.kt
index 8ca94a63422..e95fbbdae68 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorToSourceUtils.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorToSourceUtils.kt
@@ -22,9 +22,9 @@ import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DECLARATIO
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYNTHESIZED
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.idea.MainFunctionDetector
-import org.jetbrains.kotlin.psi.JetAnnotationEntry
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtAnnotationEntry
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.resolve.source.getPsi
 import java.util.ArrayList
 
@@ -55,8 +55,8 @@ public object DescriptorToSourceUtils {
     }
 
     @JvmStatic
-    public fun getSourceFromAnnotation(descriptor: AnnotationDescriptor): JetAnnotationEntry? {
-        return descriptor.source.getPsi() as? JetAnnotationEntry
+    public fun getSourceFromAnnotation(descriptor: AnnotationDescriptor): KtAnnotationEntry? {
+        return descriptor.source.getPsi() as? KtAnnotationEntry
     }
 
     // NOTE this is also used by KDoc
@@ -70,14 +70,14 @@ public object DescriptorToSourceUtils {
     }
 
     @JvmStatic
-    public fun getContainingFile(declarationDescriptor: DeclarationDescriptor): JetFile? {
+    public fun getContainingFile(declarationDescriptor: DeclarationDescriptor): KtFile? {
         // declarationDescriptor may describe a synthesized element which doesn't have PSI
         // To workaround that, we find a top-level parent (which is inside a PackageFragmentDescriptor), which is guaranteed to have PSI
         val descriptor = findTopLevelParent(declarationDescriptor) ?: return null
 
         val declaration = descriptorToDeclaration(descriptor) ?: return null
 
-        return declaration.getContainingFile() as? JetFile
+        return declaration.getContainingFile() as? KtFile
     }
 
     @JvmStatic
@@ -87,7 +87,7 @@ public object DescriptorToSourceUtils {
             declarationDescriptor.name.asString() != "main") return false
 
         val element = descriptorToDeclaration(declarationDescriptor)
-        return element is JetNamedFunction && mainFunctionDetector.isMain(element)
+        return element is KtNamedFunction && mainFunctionDetector.isMain(element)
     }
 
     private fun findTopLevelParent(declarationDescriptor: DeclarationDescriptor): DeclarationDescriptor? {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionAnalyzerExtension.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionAnalyzerExtension.java
index 22b8b869d3e..afbb08600c0 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionAnalyzerExtension.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionAnalyzerExtension.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
 import org.jetbrains.kotlin.resolve.inline.InlineAnalyzerExtension;
 import org.jetbrains.kotlin.resolve.inline.InlineUtil;
 
@@ -30,7 +30,7 @@ import java.util.Map;
 public class FunctionAnalyzerExtension {
 
     public interface AnalyzerExtension {
-        void process(@NotNull FunctionDescriptor descriptor, @NotNull JetNamedFunction function, @NotNull BindingTrace trace);
+        void process(@NotNull FunctionDescriptor descriptor, @NotNull KtNamedFunction function, @NotNull BindingTrace trace);
     }
 
     @NotNull private final BindingTrace trace;
@@ -40,8 +40,8 @@ public class FunctionAnalyzerExtension {
     }
 
     public void process(@NotNull BodiesResolveContext bodiesResolveContext) {
-        for (Map.Entry<JetNamedFunction, SimpleFunctionDescriptor> entry : bodiesResolveContext.getFunctions().entrySet()) {
-            JetNamedFunction function = entry.getKey();
+        for (Map.Entry<KtNamedFunction, SimpleFunctionDescriptor> entry : bodiesResolveContext.getFunctions().entrySet()) {
+            KtNamedFunction function = entry.getKey();
             SimpleFunctionDescriptor functionDescriptor = entry.getValue();
 
             for (AnalyzerExtension extension : getExtensions(functionDescriptor)) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt
index 30ff42fb391..52a533b91c7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl.create
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.diagnostics.Errors.*
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.DescriptorResolver.getDefaultModality
@@ -47,9 +47,9 @@ import org.jetbrains.kotlin.resolve.source.toSourceElement
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.DeferredType
 import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
 import org.jetbrains.kotlin.types.expressions.PreliminaryDeclarationVisitor
@@ -67,7 +67,7 @@ class FunctionDescriptorResolver(
     public fun resolveFunctionDescriptor(
             containingDescriptor: DeclarationDescriptor,
             scope: LexicalScope,
-            function: JetNamedFunction,
+            function: KtNamedFunction,
             trace: BindingTrace,
             dataFlowInfo: DataFlowInfo
     ): SimpleFunctionDescriptor {
@@ -81,10 +81,10 @@ class FunctionDescriptorResolver(
     public fun resolveFunctionExpressionDescriptor(
             containingDescriptor: DeclarationDescriptor,
             scope: LexicalScope,
-            function: JetNamedFunction,
+            function: KtNamedFunction,
             trace: BindingTrace,
             dataFlowInfo: DataFlowInfo,
-            expectedFunctionType: JetType
+            expectedFunctionType: KtType
     ): SimpleFunctionDescriptor = resolveFunctionDescriptor(
             ::FunctionExpressionDescriptor, containingDescriptor, scope, function, trace, dataFlowInfo, expectedFunctionType)
 
@@ -92,10 +92,10 @@ class FunctionDescriptorResolver(
             functionConstructor: (DeclarationDescriptor, Annotations, Name, CallableMemberDescriptor.Kind, SourceElement) -> SimpleFunctionDescriptorImpl,
             containingDescriptor: DeclarationDescriptor,
             scope: LexicalScope,
-            function: JetNamedFunction,
+            function: KtNamedFunction,
             trace: BindingTrace,
             dataFlowInfo: DataFlowInfo,
-            expectedFunctionType: JetType
+            expectedFunctionType: KtType
     ): SimpleFunctionDescriptor {
         val functionDescriptor = functionConstructor(
                 containingDescriptor,
@@ -112,7 +112,7 @@ class FunctionDescriptorResolver(
 
     private fun initializeFunctionReturnTypeBasedOnFunctionBody(
             scope: LexicalScope,
-            function: JetNamedFunction,
+            function: KtNamedFunction,
             functionDescriptor: SimpleFunctionDescriptorImpl,
             trace: BindingTrace,
             dataFlowInfo: DataFlowInfo
@@ -140,10 +140,10 @@ class FunctionDescriptorResolver(
     fun initializeFunctionDescriptorAndExplicitReturnType(
             containingDescriptor: DeclarationDescriptor,
             scope: LexicalScope,
-            function: JetFunction,
+            function: KtFunction,
             functionDescriptor: SimpleFunctionDescriptorImpl,
             trace: BindingTrace,
-            expectedFunctionType: JetType
+            expectedFunctionType: KtType
     ) {
         val innerScope = LexicalWritableScope(scope, functionDescriptor, true, null,
                                               TraceBasedRedeclarationHandler(trace), "Function descriptor header scope")
@@ -178,11 +178,11 @@ class FunctionDescriptorResolver(
                 modality,
                 visibility
         )
-        functionDescriptor.isOperator = function.hasModifier(JetTokens.OPERATOR_KEYWORD)
-        functionDescriptor.isInfix = function.hasModifier(JetTokens.INFIX_KEYWORD)
-        functionDescriptor.isExternal = function.hasModifier(JetTokens.EXTERNAL_KEYWORD)
-        functionDescriptor.isInline = function.hasModifier(JetTokens.INLINE_KEYWORD)
-        functionDescriptor.isTailrec = function.hasModifier(JetTokens.TAILREC_KEYWORD)
+        functionDescriptor.isOperator = function.hasModifier(KtTokens.OPERATOR_KEYWORD)
+        functionDescriptor.isInfix = function.hasModifier(KtTokens.INFIX_KEYWORD)
+        functionDescriptor.isExternal = function.hasModifier(KtTokens.EXTERNAL_KEYWORD)
+        functionDescriptor.isInline = function.hasModifier(KtTokens.INLINE_KEYWORD)
+        functionDescriptor.isTailrec = function.hasModifier(KtTokens.TAILREC_KEYWORD)
         receiverType?.let { ForceResolveUtil.forceResolveAllContents(it.getAnnotations()) }
         for (valueParameterDescriptor in valueParameterDescriptors) {
             ForceResolveUtil.forceResolveAllContents(valueParameterDescriptor.getType().getAnnotations())
@@ -190,15 +190,15 @@ class FunctionDescriptorResolver(
     }
 
     private fun createValueParameterDescriptors(
-            function: JetFunction,
+            function: KtFunction,
             functionDescriptor: SimpleFunctionDescriptorImpl,
             innerScope: LexicalWritableScope,
             trace: BindingTrace,
-            expectedFunctionType: JetType
+            expectedFunctionType: KtType
     ): List<ValueParameterDescriptor> {
         val expectedValueParameters = expectedFunctionType.getValueParameters(functionDescriptor)
         if (expectedValueParameters != null) {
-            if (expectedValueParameters.size() == 1 && function is JetFunctionLiteral && function.getValueParameterList() == null) {
+            if (expectedValueParameters.size() == 1 && function is KtFunctionLiteral && function.getValueParameterList() == null) {
                 // it parameter for lambda
                 val valueParameterDescriptor = expectedValueParameters.first()
                 val it = ValueParameterDescriptorImpl(functionDescriptor, null, 0, Annotations.EMPTY, Name.identifier("it"),
@@ -225,17 +225,17 @@ class FunctionDescriptorResolver(
         )
     }
 
-    private fun JetType.functionTypeExpected() = !TypeUtils.noExpectedType(this) && KotlinBuiltIns.isFunctionOrExtensionFunctionType(this)
-    private fun JetType.getReceiverType(): JetType? =
+    private fun KtType.functionTypeExpected() = !TypeUtils.noExpectedType(this) && KotlinBuiltIns.isFunctionOrExtensionFunctionType(this)
+    private fun KtType.getReceiverType(): KtType? =
             if (functionTypeExpected()) KotlinBuiltIns.getReceiverType(this) else null
 
-    private fun JetType.getValueParameters(owner: FunctionDescriptor): List<ValueParameterDescriptor>? =
+    private fun KtType.getValueParameters(owner: FunctionDescriptor): List<ValueParameterDescriptor>? =
             if (functionTypeExpected()) KotlinBuiltIns.getValueParameters(owner, this) else null
 
     public fun resolvePrimaryConstructorDescriptor(
             scope: LexicalScope,
             classDescriptor: ClassDescriptor,
-            classElement: JetClassOrObject,
+            classElement: KtClassOrObject,
             trace: BindingTrace
     ): ConstructorDescriptorImpl? {
         if (classDescriptor.getKind() == ClassKind.ENUM_ENTRY || !classElement.hasPrimaryConstructor()) return null
@@ -254,7 +254,7 @@ class FunctionDescriptorResolver(
     public fun resolveSecondaryConstructorDescriptor(
             scope: LexicalScope,
             classDescriptor: ClassDescriptor,
-            constructor: JetSecondaryConstructor,
+            constructor: KtSecondaryConstructor,
             trace: BindingTrace
     ): ConstructorDescriptorImpl {
         return createConstructorDescriptor(
@@ -273,10 +273,10 @@ class FunctionDescriptorResolver(
             scope: LexicalScope,
             classDescriptor: ClassDescriptor,
             isPrimary: Boolean,
-            modifierList: JetModifierList?,
-            declarationToTrace: JetDeclaration,
+            modifierList: KtModifierList?,
+            declarationToTrace: KtDeclaration,
             typeParameters: List<TypeParameterDescriptor>,
-            valueParameters: List<JetParameter>,
+            valueParameters: List<KtParameter>,
             trace: BindingTrace
     ): ConstructorDescriptorImpl {
         val constructorDescriptor = ConstructorDescriptorImpl.create(
@@ -311,7 +311,7 @@ class FunctionDescriptorResolver(
     private fun resolveValueParameters(
             functionDescriptor: FunctionDescriptor,
             parameterScope: LexicalWritableScope,
-            valueParameters: List<JetParameter>,
+            valueParameters: List<KtParameter>,
             trace: BindingTrace,
             expectedValueParameters: List<ValueParameterDescriptor>?
     ): List<ValueParameterDescriptor> {
@@ -322,11 +322,11 @@ class FunctionDescriptorResolver(
             val typeReference = valueParameter.getTypeReference()
             val expectedType = expectedValueParameters?.let { if (i < it.size()) it[i].getType() else null }
 
-            val type: JetType
+            val type: KtType
             if (typeReference != null) {
                 type = typeResolver.resolveType(parameterScope, typeReference, trace, true)
                 if (expectedType != null && !TypeUtils.noExpectedType(expectedType)) {
-                    if (!JetTypeChecker.DEFAULT.isSubtypeOf(expectedType, type)) {
+                    if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(expectedType, type)) {
                         trace.report(EXPECTED_PARAMETER_TYPE_MISMATCH.on(valueParameter, expectedType))
                     }
                 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java
index 0cf7d052a19..94bc443aa0d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java
@@ -38,7 +38,7 @@ public class FunctionDescriptorUtil {
     private static final TypeSubstitutor MAKE_TYPE_PARAMETERS_FRESH = TypeSubstitutor.create(new TypeSubstitution() {
 
         @Override
-        public TypeProjection get(@NotNull JetType key) {
+        public TypeProjection get(@NotNull KtType key) {
             return null;
         }
 
@@ -53,7 +53,7 @@ public class FunctionDescriptorUtil {
 
     public static TypeSubstitution createSubstitution(
             @NotNull FunctionDescriptor functionDescriptor,
-            @NotNull List<JetType> typeArguments
+            @NotNull List<KtType> typeArguments
     ) {
         if (functionDescriptor.getTypeParameters().isEmpty()) return TypeSubstitution.getEMPTY();
 
@@ -90,7 +90,7 @@ public class FunctionDescriptorUtil {
 
     public static void initializeFromFunctionType(
             @NotNull FunctionDescriptorImpl functionDescriptor,
-            @NotNull JetType functionType,
+            @NotNull KtType functionType,
             @Nullable ReceiverParameterDescriptor dispatchReceiverParameter,
             @NotNull Modality modality,
             @NotNull Visibility visibility
@@ -129,7 +129,7 @@ public class FunctionDescriptorUtil {
         List<ValueParameterDescriptor> parameters = new ArrayList<ValueParameterDescriptor>(newParameters.size());
         int idx = 0;
         for (ValueParameterDescriptor parameter : newParameters) {
-            JetType returnType = parameter.getReturnType();
+            KtType returnType = parameter.getReturnType();
             assert returnType != null;
 
             parameters.add(
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/IdentifierChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/IdentifierChecker.kt
index af3800f58e1..c72d1aa00a1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/IdentifierChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/IdentifierChecker.kt
@@ -18,14 +18,14 @@ package org.jetbrains.kotlin.resolve
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 
 public interface IdentifierChecker {
     fun checkIdentifier(identifier: PsiElement?, diagnosticHolder: DiagnosticSink)
-    fun checkDeclaration(declaration: JetDeclaration, diagnosticHolder: DiagnosticSink)
+    fun checkDeclaration(declaration: KtDeclaration, diagnosticHolder: DiagnosticSink)
 
     object DEFAULT : IdentifierChecker {
         override fun checkIdentifier(identifier: PsiElement?, diagnosticHolder: DiagnosticSink) {}
-        override fun checkDeclaration(declaration: JetDeclaration, diagnosticHolder: DiagnosticSink) {}
+        override fun checkDeclaration(declaration: KtDeclaration, diagnosticHolder: DiagnosticSink) {}
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/InfixModifierChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/InfixModifierChecker.kt
index aa01f0ac0e7..9ce5befb999 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/InfixModifierChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/InfixModifierChecker.kt
@@ -20,21 +20,21 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasDefaultValue
 
 public class InfixModifierChecker : DeclarationChecker {
 
     override fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext
     ) {
         val functionDescriptor = descriptor as? FunctionDescriptor ?: return
         if (!functionDescriptor.isInfix) return
-        val modifier = declaration.modifierList?.getModifier(JetTokens.INFIX_KEYWORD) ?: return
+        val modifier = declaration.modifierList?.getModifier(KtTokens.INFIX_KEYWORD) ?: return
 
         if (!isApplicable(functionDescriptor)) {
             diagnosticHolder.report(Errors.INAPPLICABLE_INFIX_MODIFIER.on(modifier))
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/InlineParameterChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/InlineParameterChecker.kt
index d40bfa0535f..aece38aac63 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/InlineParameterChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/InlineParameterChecker.kt
@@ -20,31 +20,31 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetFunction
-import org.jetbrains.kotlin.psi.JetParameter
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.psi.KtParameter
 
 object InlineParameterChecker : DeclarationChecker {
-    override fun check(declaration: JetDeclaration,
+    override fun check(declaration: KtDeclaration,
                        descriptor: DeclarationDescriptor,
                        diagnosticHolder: DiagnosticSink,
                        bindingContext: BindingContext
     ) {
-        if (declaration is JetFunction) {
-            val inline = declaration.hasModifier(JetTokens.INLINE_KEYWORD)
+        if (declaration is KtFunction) {
+            val inline = declaration.hasModifier(KtTokens.INLINE_KEYWORD)
             for (parameter in declaration.valueParameters) {
                 val parameterDescriptor = bindingContext.get(BindingContext.VALUE_PARAMETER, parameter)
                 if (!inline || (parameterDescriptor != null && !KotlinBuiltIns.isFunctionOrExtensionFunctionType(parameterDescriptor.type))) {
-                    parameter.reportIncorrectInline(JetTokens.NOINLINE_KEYWORD, diagnosticHolder)
-                    parameter.reportIncorrectInline(JetTokens.CROSSINLINE_KEYWORD, diagnosticHolder)
+                    parameter.reportIncorrectInline(KtTokens.NOINLINE_KEYWORD, diagnosticHolder)
+                    parameter.reportIncorrectInline(KtTokens.CROSSINLINE_KEYWORD, diagnosticHolder)
                 }
             }
         }
     }
 
-    private fun JetParameter.reportIncorrectInline(modifierToken: JetModifierKeywordToken, diagnosticHolder: DiagnosticSink) {
+    private fun KtParameter.reportIncorrectInline(modifierToken: KtModifierKeywordToken, diagnosticHolder: DiagnosticSink) {
         val modifier = modifierList?.getModifier(modifierToken)
         modifier?.let {
             diagnosticHolder.report(Errors.ILLEGAL_INLINE_PARAMETER_MODIFIER.on(modifier, modifierToken))
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt
index 195b905e49d..b9087e5e32d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt
@@ -54,25 +54,25 @@ public class LazyTopDownAnalyzer(
 
         val c = TopDownAnalysisContext(topDownAnalysisMode, outerDataFlowInfo, declarationScopeProvider)
 
-        val topLevelFqNames = HashMultimap.create<FqName, JetElement>()
+        val topLevelFqNames = HashMultimap.create<FqName, KtElement>()
 
-        val properties = ArrayList<JetProperty>()
-        val functions = ArrayList<JetNamedFunction>()
+        val properties = ArrayList<KtProperty>()
+        val functions = ArrayList<KtNamedFunction>()
 
         // fill in the context
         for (declaration in declarations) {
-            declaration.accept(object : JetVisitorVoid() {
-                private fun registerDeclarations(declarations: List<JetDeclaration>) {
+            declaration.accept(object : KtVisitorVoid() {
+                private fun registerDeclarations(declarations: List<KtDeclaration>) {
                     for (jetDeclaration in declarations) {
                         jetDeclaration.accept(this)
                     }
                 }
 
-                override fun visitDeclaration(dcl: JetDeclaration) {
+                override fun visitDeclaration(dcl: KtDeclaration) {
                     throw IllegalArgumentException("Unsupported declaration: " + dcl + " " + dcl.getText())
                 }
 
-                override fun visitJetFile(file: JetFile) {
+                override fun visitJetFile(file: KtFile) {
                     if (file.isScript()) {
                         val script = file.getScript() ?: throw AssertionError("getScript() is null for file: $file")
 
@@ -94,17 +94,17 @@ public class LazyTopDownAnalyzer(
                     }
                 }
 
-                override fun visitPackageDirective(directive: JetPackageDirective) {
+                override fun visitPackageDirective(directive: KtPackageDirective) {
                     directive.packageNames.forEach { identifierChecker.checkIdentifier(it.getIdentifier(), trace) }
                     qualifiedExpressionResolver.resolvePackageHeader(directive, moduleDescriptor, trace)
                 }
 
-                override fun visitImportDirective(importDirective: JetImportDirective) {
+                override fun visitImportDirective(importDirective: KtImportDirective) {
                     val fileScope = fileScopeProvider.getFileScope(importDirective.getContainingJetFile())
                     fileScope.forceResolveImport(importDirective)
                 }
 
-                override fun visitClassOrObject(classOrObject: JetClassOrObject) {
+                override fun visitClassOrObject(classOrObject: KtClassOrObject) {
                     val location = if (classOrObject.isTopLevel()) KotlinLookupLocation(classOrObject) else NoLookupLocation.WHEN_RESOLVE_DECLARATION
                     val descriptor = lazyDeclarationResolver.getClassDescriptor(classOrObject, location) as ClassDescriptorWithResolutionScopes
 
@@ -115,16 +115,16 @@ public class LazyTopDownAnalyzer(
                     checkClassOrObjectDeclarations(classOrObject, descriptor)
                 }
 
-                private fun checkClassOrObjectDeclarations(classOrObject: JetClassOrObject, classDescriptor: ClassDescriptor) {
+                private fun checkClassOrObjectDeclarations(classOrObject: KtClassOrObject, classDescriptor: ClassDescriptor) {
                     var companionObjectAlreadyFound = false
                     for (jetDeclaration in classOrObject.getDeclarations()) {
-                        if (jetDeclaration is JetObjectDeclaration && jetDeclaration.isCompanion()) {
+                        if (jetDeclaration is KtObjectDeclaration && jetDeclaration.isCompanion()) {
                             if (companionObjectAlreadyFound) {
                                 trace.report(MANY_COMPANION_OBJECTS.on(jetDeclaration))
                             }
                             companionObjectAlreadyFound = true
                         }
-                        else if (jetDeclaration is JetSecondaryConstructor) {
+                        else if (jetDeclaration is KtSecondaryConstructor) {
                             if (DescriptorUtils.isSingletonOrAnonymousObject(classDescriptor)) {
                                 trace.report(CONSTRUCTOR_IN_OBJECT.on(jetDeclaration))
                             }
@@ -135,12 +135,12 @@ public class LazyTopDownAnalyzer(
                     }
                 }
 
-                override fun visitClass(klass: JetClass) {
+                override fun visitClass(klass: KtClass) {
                     visitClassOrObject(klass)
                     registerPrimaryConstructorParameters(klass)
                 }
 
-                private fun registerPrimaryConstructorParameters(klass: JetClass) {
+                private fun registerPrimaryConstructorParameters(klass: KtClass) {
                     for (jetParameter in klass.getPrimaryConstructorParameters()) {
                         if (jetParameter.hasValOrVar()) {
                             c.getPrimaryConstructorParameterProperties().put(jetParameter, lazyDeclarationResolver.resolveToDescriptor(jetParameter) as PropertyDescriptor)
@@ -148,36 +148,36 @@ public class LazyTopDownAnalyzer(
                     }
                 }
 
-                override fun visitSecondaryConstructor(constructor: JetSecondaryConstructor) {
+                override fun visitSecondaryConstructor(constructor: KtSecondaryConstructor) {
                     c.getSecondaryConstructors().put(constructor, lazyDeclarationResolver.resolveToDescriptor(constructor) as ConstructorDescriptor)
                 }
 
-                override fun visitEnumEntry(enumEntry: JetEnumEntry) {
+                override fun visitEnumEntry(enumEntry: KtEnumEntry) {
                     visitClassOrObject(enumEntry)
                 }
 
-                override fun visitObjectDeclaration(declaration: JetObjectDeclaration) {
+                override fun visitObjectDeclaration(declaration: KtObjectDeclaration) {
                     visitClassOrObject(declaration)
                 }
 
-                override fun visitAnonymousInitializer(initializer: JetClassInitializer) {
-                    val classOrObject = PsiTreeUtil.getParentOfType<JetClassOrObject>(initializer, javaClass<JetClassOrObject>())!!
+                override fun visitAnonymousInitializer(initializer: KtClassInitializer) {
+                    val classOrObject = PsiTreeUtil.getParentOfType<KtClassOrObject>(initializer, javaClass<KtClassOrObject>())!!
                     c.getAnonymousInitializers().put(initializer, lazyDeclarationResolver.resolveToDescriptor(classOrObject) as ClassDescriptorWithResolutionScopes)
                 }
 
-                override fun visitTypedef(typedef: JetTypedef) {
+                override fun visitTypedef(typedef: KtTypedef) {
                     trace.report(UNSUPPORTED.on(typedef, "Typedefs are not supported"))
                 }
 
-                override fun visitMultiDeclaration(multiDeclaration: JetMultiDeclaration) {
+                override fun visitMultiDeclaration(multiDeclaration: KtMultiDeclaration) {
                     // Ignore: multi-declarations are only allowed locally
                 }
 
-                override fun visitNamedFunction(function: JetNamedFunction) {
+                override fun visitNamedFunction(function: KtNamedFunction) {
                     functions.add(function)
                 }
 
-                override fun visitProperty(property: JetProperty) {
+                override fun visitProperty(property: KtProperty) {
                     properties.add(property)
                 }
             })
@@ -211,7 +211,7 @@ public class LazyTopDownAnalyzer(
         }
     }
 
-    private fun createPropertyDescriptors(c: TopDownAnalysisContext, topLevelFqNames: Multimap<FqName, JetElement>, properties: List<JetProperty>) {
+    private fun createPropertyDescriptors(c: TopDownAnalysisContext, topLevelFqNames: Multimap<FqName, KtElement>, properties: List<KtProperty>) {
         for (property in properties) {
             val descriptor = lazyDeclarationResolver.resolveToDescriptor(property) as PropertyDescriptor
 
@@ -221,7 +221,7 @@ public class LazyTopDownAnalyzer(
         }
     }
 
-    private fun createFunctionDescriptors(c: TopDownAnalysisContext, functions: List<JetNamedFunction>) {
+    private fun createFunctionDescriptors(c: TopDownAnalysisContext, functions: List<KtNamedFunction>) {
         for (function in functions) {
             val simpleFunctionDescriptor = lazyDeclarationResolver.resolveToDescriptor(function) as SimpleFunctionDescriptor
             c.getFunctions().put(function, simpleFunctionDescriptor)
@@ -232,7 +232,7 @@ public class LazyTopDownAnalyzer(
         }
     }
 
-    private fun registerTopLevelFqName(topLevelFqNames: Multimap<FqName, JetElement>, declaration: JetNamedDeclaration, descriptor: DeclarationDescriptor) {
+    private fun registerTopLevelFqName(topLevelFqNames: Multimap<FqName, KtElement>, declaration: KtNamedDeclaration, descriptor: DeclarationDescriptor) {
         if (DescriptorUtils.isTopLevelDeclaration(descriptor)) {
             val fqName = declaration.getFqName()
             if (fqName != null) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java
index 34439abe845..011c8ac8b60 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java
@@ -22,8 +22,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetScript;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtScript;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.kotlin.resolve.lazy.LazyFileScope;
@@ -48,7 +48,7 @@ public class LazyTopDownAnalyzerForTopLevel {
     @NotNull
     public TopDownAnalysisContext analyzeFiles(
             @NotNull TopDownAnalysisMode topDownAnalysisMode,
-            @NotNull Collection<JetFile> files,
+            @NotNull Collection<KtFile> files,
             @NotNull List<? extends PackageFragmentProvider> additionalProviders
     ) {
         PackageFragmentProvider provider;
@@ -79,16 +79,16 @@ public class LazyTopDownAnalyzerForTopLevel {
     }
 
     private static void resolveImportsInAllFiles(TopDownAnalysisContext c, KotlinCodeAnalyzer resolveSession) {
-        for (JetFile file : c.getFiles()) {
+        for (KtFile file : c.getFiles()) {
             resolveAndCheckImports(file, resolveSession);
         }
 
-        for (JetScript script : c.getScripts().keySet()) {
+        for (KtScript script : c.getScripts().keySet()) {
             resolveAndCheckImports(script.getContainingJetFile(), resolveSession);
         }
     }
 
-    private static void resolveAndCheckImports(@NotNull JetFile file, @NotNull KotlinCodeAnalyzer resolveSession) {
+    private static void resolveAndCheckImports(@NotNull KtFile file, @NotNull KotlinCodeAnalyzer resolveSession) {
         LazyFileScope fileScope = resolveSession.getFileScopeProvider().getFileScope(file);
         fileScope.forceResolveAllImports();
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java
index 91a059c7fd4..b69b3c5ccac 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java
@@ -23,24 +23,24 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1;
-import org.jetbrains.kotlin.lexer.JetKeywordToken;
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtKeywordToken;
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 
 import java.util.*;
 
 import static org.jetbrains.kotlin.diagnostics.Errors.NESTED_CLASS_NOT_ALLOWED;
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
-import static org.jetbrains.kotlin.psi.JetStubbedPsiUtil.getContainingDeclaration;
+import static org.jetbrains.kotlin.lexer.KtTokens.*;
+import static org.jetbrains.kotlin.psi.KtStubbedPsiUtil.getContainingDeclaration;
 
 public class ModifiersChecker {
-    private static final Set<JetModifierKeywordToken> MODIFIERS_ILLEGAL_ON_PARAMETERS;
+    private static final Set<KtModifierKeywordToken> MODIFIERS_ILLEGAL_ON_PARAMETERS;
 
     static {
         MODIFIERS_ILLEGAL_ON_PARAMETERS = Sets.newHashSet();
-        MODIFIERS_ILLEGAL_ON_PARAMETERS.addAll(Arrays.asList(JetTokens.MODIFIER_KEYWORDS_ARRAY));
-        MODIFIERS_ILLEGAL_ON_PARAMETERS.remove(JetTokens.VARARG_KEYWORD);
+        MODIFIERS_ILLEGAL_ON_PARAMETERS.addAll(Arrays.asList(KtTokens.MODIFIER_KEYWORDS_ARRAY));
+        MODIFIERS_ILLEGAL_ON_PARAMETERS.remove(KtTokens.VARARG_KEYWORD);
     }
 
     public static boolean isIllegalInner(@NotNull DeclarationDescriptor descriptor) {
@@ -57,10 +57,10 @@ public class ModifiersChecker {
 
     // NOTE: just checks if this is legal context for companion modifier (Companion object descriptor can be created)
     // COMPANION_OBJECT_NOT_ALLOWED can be reported later
-    public static boolean isCompanionModifierAllowed(@NotNull JetDeclaration declaration) {
-        if (declaration instanceof JetObjectDeclaration) {
-            JetDeclaration containingDeclaration = getContainingDeclaration(declaration);
-            if (containingDeclaration instanceof JetClassOrObject) {
+    public static boolean isCompanionModifierAllowed(@NotNull KtDeclaration declaration) {
+        if (declaration instanceof KtObjectDeclaration) {
+            KtDeclaration containingDeclaration = getContainingDeclaration(declaration);
+            if (containingDeclaration instanceof KtClassOrObject) {
                 return true;
             }
         }
@@ -98,14 +98,14 @@ public class ModifiersChecker {
 
     @NotNull
     public static Modality resolveModalityFromModifiers(
-            @NotNull JetModifierListOwner modifierListOwner,
+            @NotNull KtModifierListOwner modifierListOwner,
             @NotNull Modality defaultModality
     ) {
         return resolveModalityFromModifiers(modifierListOwner.getModifierList(), defaultModality);
     }
 
     @NotNull
-    public static Modality resolveModalityFromModifiers(@Nullable JetModifierList modifierList, @NotNull Modality defaultModality) {
+    public static Modality resolveModalityFromModifiers(@Nullable KtModifierList modifierList, @NotNull Modality defaultModality) {
         if (modifierList == null) return defaultModality;
         boolean hasAbstractModifier = modifierList.hasModifier(ABSTRACT_KEYWORD);
         boolean hasOverrideModifier = modifierList.hasModifier(OVERRIDE_KEYWORD);
@@ -134,13 +134,13 @@ public class ModifiersChecker {
 
     @NotNull
     public static Visibility resolveVisibilityFromModifiers(
-            @NotNull JetModifierListOwner modifierListOwner,
+            @NotNull KtModifierListOwner modifierListOwner,
             @NotNull Visibility defaultVisibility
     ) {
         return resolveVisibilityFromModifiers(modifierListOwner.getModifierList(), defaultVisibility);
     }
 
-    public static Visibility resolveVisibilityFromModifiers(@Nullable JetModifierList modifierList, @NotNull Visibility defaultVisibility) {
+    public static Visibility resolveVisibilityFromModifiers(@Nullable KtModifierList modifierList, @NotNull Visibility defaultVisibility) {
         if (modifierList == null) return defaultVisibility;
         if (modifierList.hasModifier(PRIVATE_KEYWORD)) return Visibilities.PRIVATE;
         if (modifierList.hasModifier(PUBLIC_KEYWORD)) return Visibilities.PUBLIC;
@@ -149,7 +149,7 @@ public class ModifiersChecker {
         return defaultVisibility;
     }
 
-    public static boolean isInnerClass(@Nullable JetModifierList modifierList) {
+    public static boolean isInnerClass(@Nullable KtModifierList modifierList) {
         return modifierList != null && modifierList.hasModifier(INNER_KEYWORD);
     }
 
@@ -163,22 +163,22 @@ public class ModifiersChecker {
         }
 
         public void checkParameterHasNoValOrVar(
-                @NotNull JetParameter parameter,
-                @NotNull DiagnosticFactory1<PsiElement, JetKeywordToken> diagnosticFactory
+                @NotNull KtParameter parameter,
+                @NotNull DiagnosticFactory1<PsiElement, KtKeywordToken> diagnosticFactory
         ) {
             PsiElement valOrVar = parameter.getValOrVarKeyword();
             if (valOrVar != null) {
-                trace.report(diagnosticFactory.on(valOrVar, ((JetKeywordToken) valOrVar.getNode().getElementType())));
+                trace.report(diagnosticFactory.on(valOrVar, ((KtKeywordToken) valOrVar.getNode().getElementType())));
             }
         }
 
-        public void checkModifiersForDeclaration(@NotNull JetDeclaration modifierListOwner, @NotNull MemberDescriptor descriptor) {
+        public void checkModifiersForDeclaration(@NotNull KtDeclaration modifierListOwner, @NotNull MemberDescriptor descriptor) {
             checkNestedClassAllowed(modifierListOwner, descriptor);
             checkTypeParametersModifiers(modifierListOwner);
             checkModifierListCommon(modifierListOwner, descriptor);
         }
 
-        private void checkModifierListCommon(@NotNull JetDeclaration modifierListOwner, @NotNull DeclarationDescriptor descriptor) {
+        private void checkModifierListCommon(@NotNull KtDeclaration modifierListOwner, @NotNull DeclarationDescriptor descriptor) {
             AnnotationUseSiteTargetChecker.INSTANCE.check(modifierListOwner, descriptor, trace);
             runDeclarationCheckers(modifierListOwner, descriptor);
             annotationChecker.check(modifierListOwner, trace, descriptor);
@@ -186,26 +186,26 @@ public class ModifiersChecker {
         }
 
         public void checkModifiersForLocalDeclaration(
-                @NotNull JetDeclaration modifierListOwner,
+                @NotNull KtDeclaration modifierListOwner,
                 @NotNull DeclarationDescriptor descriptor
         ) {
             checkModifierListCommon(modifierListOwner, descriptor);
         }
 
-        public void checkModifiersForMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration) {
+        public void checkModifiersForMultiDeclaration(@NotNull KtMultiDeclaration multiDeclaration) {
             annotationChecker.check(multiDeclaration, trace, null);
             ModifierCheckerCore.INSTANCE.check(multiDeclaration, trace, null);
-            for (JetMultiDeclarationEntry multiEntry: multiDeclaration.getEntries()) {
+            for (KtMultiDeclarationEntry multiEntry: multiDeclaration.getEntries()) {
                 annotationChecker.check(multiEntry, trace, null);
                 ModifierCheckerCore.INSTANCE.check(multiEntry, trace, null);
                 UnderscoreChecker.INSTANCE.checkNamed(multiEntry, trace);
             }
         }
 
-        private void checkNestedClassAllowed(@NotNull JetModifierListOwner modifierListOwner, @NotNull DeclarationDescriptor descriptor) {
+        private void checkNestedClassAllowed(@NotNull KtModifierListOwner modifierListOwner, @NotNull DeclarationDescriptor descriptor) {
             if (modifierListOwner.hasModifier(INNER_KEYWORD)) return;
-            if (modifierListOwner instanceof JetClass && !(modifierListOwner instanceof JetEnumEntry)) {
-                JetClass aClass = (JetClass) modifierListOwner;
+            if (modifierListOwner instanceof KtClass && !(modifierListOwner instanceof KtEnumEntry)) {
+                KtClass aClass = (KtClass) modifierListOwner;
                 boolean localEnumError = aClass.isLocal() && aClass.isEnum();
                 if (!localEnumError && isIllegalNestedClass(descriptor)) {
                     trace.report(NESTED_CLASS_NOT_ALLOWED.on(aClass));
@@ -214,12 +214,12 @@ public class ModifiersChecker {
         }
 
         @NotNull
-        public Map<JetModifierKeywordToken, PsiElement> getTokensCorrespondingToModifiers(
-                @NotNull JetModifierList modifierList,
-                @NotNull Collection<JetModifierKeywordToken> possibleModifiers
+        public Map<KtModifierKeywordToken, PsiElement> getTokensCorrespondingToModifiers(
+                @NotNull KtModifierList modifierList,
+                @NotNull Collection<KtModifierKeywordToken> possibleModifiers
         ) {
-            Map<JetModifierKeywordToken, PsiElement> tokens = Maps.newHashMap();
-            for (JetModifierKeywordToken modifier : possibleModifiers) {
+            Map<KtModifierKeywordToken, PsiElement> tokens = Maps.newHashMap();
+            for (KtModifierKeywordToken modifier : possibleModifiers) {
                 if (modifierList.hasModifier(modifier)) {
                     tokens.put(modifier, modifierList.getModifier(modifier));
                 }
@@ -228,16 +228,16 @@ public class ModifiersChecker {
         }
 
 
-        private void runDeclarationCheckers(@NotNull JetDeclaration declaration, @NotNull DeclarationDescriptor descriptor) {
+        private void runDeclarationCheckers(@NotNull KtDeclaration declaration, @NotNull DeclarationDescriptor descriptor) {
             for (DeclarationChecker checker : declarationCheckers) {
                 checker.check(declaration, descriptor, trace, trace.getBindingContext());
             }
         }
 
-        public void checkTypeParametersModifiers(@NotNull JetModifierListOwner modifierListOwner) {
-            if (!(modifierListOwner instanceof JetTypeParameterListOwner)) return;
-            List<JetTypeParameter> typeParameters = ((JetTypeParameterListOwner) modifierListOwner).getTypeParameters();
-            for (JetTypeParameter typeParameter : typeParameters) {
+        public void checkTypeParametersModifiers(@NotNull KtModifierListOwner modifierListOwner) {
+            if (!(modifierListOwner instanceof KtTypeParameterListOwner)) return;
+            List<KtTypeParameter> typeParameters = ((KtTypeParameterListOwner) modifierListOwner).getTypeParameters();
+            for (KtTypeParameter typeParameter : typeParameters) {
                 ModifierCheckerCore.INSTANCE.check(typeParameter, trace, null);
             }
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt
index a66625e5d3f..4891da6499e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt
@@ -25,13 +25,13 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget.*
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.lexer.JetTokens.*
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetDeclarationWithBody
-import org.jetbrains.kotlin.psi.JetModifierList
-import org.jetbrains.kotlin.psi.JetModifierListOwner
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.lexer.KtTokens.*
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtDeclarationWithBody
+import org.jetbrains.kotlin.psi.KtModifierList
+import org.jetbrains.kotlin.psi.KtModifierListOwner
 import java.util.*
 
 public object ModifierCheckerCore {
@@ -56,7 +56,7 @@ public object ModifierCheckerCore {
                                                       MEMBER_FUNCTION, TOP_LEVEL_FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER,
                                                       MEMBER_PROPERTY, TOP_LEVEL_PROPERTY, CONSTRUCTOR)
 
-    val possibleTargetMap = mapOf<JetModifierKeywordToken, Set<KotlinTarget>>(
+    val possibleTargetMap = mapOf<KtModifierKeywordToken, Set<KotlinTarget>>(
             ENUM_KEYWORD      to EnumSet.of(ENUM_CLASS),
             ABSTRACT_KEYWORD  to EnumSet.of(CLASS_ONLY, LOCAL_CLASS, INNER_CLASS, INTERFACE, MEMBER_PROPERTY, MEMBER_FUNCTION),
             OPEN_KEYWORD      to EnumSet.of(CLASS_ONLY, LOCAL_CLASS, INNER_CLASS, INTERFACE, MEMBER_PROPERTY, MEMBER_FUNCTION),
@@ -89,13 +89,13 @@ public object ModifierCheckerCore {
     )
 
     // NOTE: redundant targets must be possible!
-    private val redundantTargetMap = mapOf<JetModifierKeywordToken, Set<KotlinTarget>>(
+    private val redundantTargetMap = mapOf<KtModifierKeywordToken, Set<KotlinTarget>>(
             ABSTRACT_KEYWORD  to EnumSet.of(INTERFACE),
             OPEN_KEYWORD      to EnumSet.of(INTERFACE),
             FINAL_KEYWORD     to EnumSet.of(ENUM_CLASS, OBJECT)
     )
 
-    val possibleParentTargetMap = mapOf<JetModifierKeywordToken, Set<KotlinTarget>>(
+    val possibleParentTargetMap = mapOf<KtModifierKeywordToken, Set<KotlinTarget>>(
             INNER_KEYWORD     to EnumSet.of(CLASS_ONLY, INNER_CLASS, LOCAL_CLASS, ENUM_CLASS, ENUM_ENTRY),
             OVERRIDE_KEYWORD  to EnumSet.of(CLASS_ONLY, INNER_CLASS, LOCAL_CLASS, OBJECT, OBJECT_LITERAL,
                                             INTERFACE, ENUM_CLASS, ENUM_ENTRY),
@@ -107,7 +107,7 @@ public object ModifierCheckerCore {
             COMPANION_KEYWORD to EnumSet.of(CLASS_ONLY, ENUM_CLASS, INTERFACE)
     )
 
-    val deprecatedParentTargetMap = mapOf<JetModifierKeywordToken, Set<KotlinTarget>>(
+    val deprecatedParentTargetMap = mapOf<KtModifierKeywordToken, Set<KotlinTarget>>(
             // Deprecated in M15
             FINAL_KEYWORD     to EnumSet.of(INTERFACE),
             PROTECTED_KEYWORD to EnumSet.of(OBJECT)
@@ -116,8 +116,8 @@ public object ModifierCheckerCore {
     // First modifier in pair should be also first in declaration
     private val mutualCompatibility = buildCompatibilityMap()
 
-    private fun buildCompatibilityMap(): Map<Pair<JetModifierKeywordToken, JetModifierKeywordToken>, Compatibility> {
-        val result = hashMapOf<Pair<JetModifierKeywordToken, JetModifierKeywordToken>, Compatibility>()
+    private fun buildCompatibilityMap(): Map<Pair<KtModifierKeywordToken, KtModifierKeywordToken>, Compatibility> {
+        val result = hashMapOf<Pair<KtModifierKeywordToken, KtModifierKeywordToken>, Compatibility>()
         // Variance: in + out are incompatible
         result += incompatibilityRegister(IN_KEYWORD, OUT_KEYWORD)
         // Visibilities: incompatible
@@ -149,17 +149,17 @@ public object ModifierCheckerCore {
     }
 
     private fun redundantRegister(
-            sufficient: JetModifierKeywordToken,
-            redundant: JetModifierKeywordToken
-    ): Map<Pair<JetModifierKeywordToken, JetModifierKeywordToken>, Compatibility> {
+            sufficient: KtModifierKeywordToken,
+            redundant: KtModifierKeywordToken
+    ): Map<Pair<KtModifierKeywordToken, KtModifierKeywordToken>, Compatibility> {
         return mapOf(Pair(sufficient, redundant) to Compatibility.REDUNDANT,
                      Pair(redundant, sufficient) to Compatibility.REVERSE_REDUNDANT)
     }
 
     private fun compatibilityRegister(
-            compatibility: Compatibility, vararg list: JetModifierKeywordToken
-    ): Map<Pair<JetModifierKeywordToken, JetModifierKeywordToken>, Compatibility> {
-        val result = hashMapOf<Pair<JetModifierKeywordToken, JetModifierKeywordToken>, Compatibility>()
+            compatibility: Compatibility, vararg list: KtModifierKeywordToken
+    ): Map<Pair<KtModifierKeywordToken, KtModifierKeywordToken>, Compatibility> {
+        val result = hashMapOf<Pair<KtModifierKeywordToken, KtModifierKeywordToken>, Compatibility>()
         for (first in list) {
             for (second in list) {
                 if (first != second) {
@@ -170,14 +170,14 @@ public object ModifierCheckerCore {
         return result
     }
 
-    private fun compatibilityForClassesRegister(vararg list: JetModifierKeywordToken) =
+    private fun compatibilityForClassesRegister(vararg list: KtModifierKeywordToken) =
             compatibilityRegister(Compatibility.COMPATIBLE_FOR_CLASSES_ONLY, *list)
 
-    private fun incompatibilityRegister(vararg list: JetModifierKeywordToken) = compatibilityRegister(Compatibility.INCOMPATIBLE, *list)
+    private fun incompatibilityRegister(vararg list: KtModifierKeywordToken) = compatibilityRegister(Compatibility.INCOMPATIBLE, *list)
 
-    private fun deprecationRegister(vararg list: JetModifierKeywordToken) = compatibilityRegister(Compatibility.DEPRECATED, *list)
+    private fun deprecationRegister(vararg list: KtModifierKeywordToken) = compatibilityRegister(Compatibility.DEPRECATED, *list)
 
-    private fun compatibility(first: JetModifierKeywordToken, second: JetModifierKeywordToken): Compatibility {
+    private fun compatibility(first: KtModifierKeywordToken, second: KtModifierKeywordToken): Compatibility {
         if (first == second) {
             return Compatibility.REPEATED
         }
@@ -191,8 +191,8 @@ public object ModifierCheckerCore {
                                    secondNode: ASTNode,
                                    owner: PsiElement,
                                    incorrectNodes: MutableSet<ASTNode>) {
-        val first = firstNode.elementType as JetModifierKeywordToken
-        val second = secondNode.elementType as JetModifierKeywordToken
+        val first = firstNode.elementType as KtModifierKeywordToken
+        val second = secondNode.elementType as KtModifierKeywordToken
         val compatibility = compatibility(first, second)
         when (compatibility) {
             Compatibility.COMPATIBLE -> {}
@@ -209,7 +209,7 @@ public object ModifierCheckerCore {
             }
             Compatibility.COMPATIBLE_FOR_CLASSES_ONLY, Compatibility.INCOMPATIBLE -> {
                 if (compatibility == Compatibility.COMPATIBLE_FOR_CLASSES_ONLY) {
-                    if (owner is JetClassOrObject) return
+                    if (owner is KtClassOrObject) return
                 }
                 if (incorrectNodes.add(firstNode)) {
                     trace.report(Errors.INCOMPATIBLE_MODIFIERS.on(firstNode.psi, first, second))
@@ -223,7 +223,7 @@ public object ModifierCheckerCore {
 
     // Should return false if error is reported, true otherwise
     private fun checkTarget(trace: BindingTrace, node: ASTNode, actualTargets: List<KotlinTarget>): Boolean {
-        val modifier = node.elementType as JetModifierKeywordToken
+        val modifier = node.elementType as KtModifierKeywordToken
         val possibleTargets = possibleTargetMap[modifier] ?: emptySet()
         if (!actualTargets.any { it in possibleTargets }) {
             trace.report(Errors.WRONG_MODIFIER_TARGET.on(node.psi, modifier, actualTargets.firstOrNull()?.description ?: "this"))
@@ -238,7 +238,7 @@ public object ModifierCheckerCore {
 
     // Should return false if error is reported, true otherwise
     private fun checkParent(trace: BindingTrace, node: ASTNode, parentDescriptor: DeclarationDescriptor?): Boolean {
-        val modifier = node.elementType as JetModifierKeywordToken
+        val modifier = node.elementType as KtModifierKeywordToken
         val actualParents: List<KotlinTarget> = when (parentDescriptor) {
             is ClassDescriptor -> KotlinTarget.classActualTargets(parentDescriptor)
             is FunctionDescriptor -> listOf(FUNCTION)
@@ -256,9 +256,9 @@ public object ModifierCheckerCore {
         return false
     }
 
-    private val MODIFIER_KEYWORD_SET = TokenSet.orSet(JetTokens.SOFT_KEYWORDS, TokenSet.create(JetTokens.IN_KEYWORD))
+    private val MODIFIER_KEYWORD_SET = TokenSet.orSet(KtTokens.SOFT_KEYWORDS, TokenSet.create(KtTokens.IN_KEYWORD))
 
-    private fun checkModifierList(list: JetModifierList, trace: BindingTrace, parentDescriptor: DeclarationDescriptor?, actualTargets: List<KotlinTarget>) {
+    private fun checkModifierList(list: KtModifierList, trace: BindingTrace, parentDescriptor: DeclarationDescriptor?, actualTargets: List<KotlinTarget>) {
         // It's a list of all nodes with error already reported
         // General strategy: report no more than one error but any number of warnings
         val incorrectNodes = hashSetOf<ASTNode>()
@@ -281,8 +281,8 @@ public object ModifierCheckerCore {
         }
     }
 
-    public fun check(listOwner: JetModifierListOwner, trace: BindingTrace, descriptor: DeclarationDescriptor?) {
-        if (listOwner is JetDeclarationWithBody) {
+    public fun check(listOwner: KtModifierListOwner, trace: BindingTrace, descriptor: DeclarationDescriptor?) {
+        if (listOwner is KtDeclarationWithBody) {
             // JetFunction or JetPropertyAccessor
             for (parameter in listOwner.valueParameters) {
                 if (!parameter.hasValOrVar()) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/NoSubpackagesInPackageScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/NoSubpackagesInPackageScope.kt
index 2b80c7de0a5..6732c1d80fc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/NoSubpackagesInPackageScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/NoSubpackagesInPackageScope.kt
@@ -21,10 +21,10 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.AbstractScopeAdapter
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 
 class NoSubpackagesInPackageScope(packageDescriptor: PackageViewDescriptor) : AbstractScopeAdapter() {
-    override val workerScope: JetScope = packageDescriptor.memberScope
+    override val workerScope: KtScope = packageDescriptor.memberScope
 
     override fun getPackage(name: Name): PackageViewDescriptor? = null
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ObservableBindingTrace.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ObservableBindingTrace.java
index 845ace54779..b5ccfa109fe 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ObservableBindingTrace.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ObservableBindingTrace.java
@@ -20,8 +20,8 @@ import com.intellij.util.SmartFMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice;
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
 
@@ -78,12 +78,12 @@ public class ObservableBindingTrace implements BindingTrace {
 
     @Nullable
     @Override
-    public JetType getType(@NotNull JetExpression expression) {
+    public KtType getType(@NotNull KtExpression expression) {
         return originalTrace.getType(expression);
     }
 
     @Override
-    public void recordType(@NotNull JetExpression expression, @Nullable JetType type) {
+    public void recordType(@NotNull KtExpression expression, @Nullable KtType type) {
         originalTrace.recordType(expression, type);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OperatorModifierChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OperatorModifierChecker.kt
index b1ba6eba4e0..f6d0db0b10c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OperatorModifierChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OperatorModifierChecker.kt
@@ -36,20 +36,20 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.util.OperatorChecks
 
 public class OperatorModifierChecker : DeclarationChecker {
     override fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext
     ) {
         val functionDescriptor = descriptor as? FunctionDescriptor ?: return
         if (!functionDescriptor.isOperator) return
-        val modifier = declaration.modifierList?.getModifier(JetTokens.OPERATOR_KEYWORD) ?: return
+        val modifier = declaration.modifierList?.getModifier(KtTokens.OPERATOR_KEYWORD) ?: return
 
         if (!OperatorChecks.canBeOperator(functionDescriptor)) {
             diagnosticHolder.report(Errors.INAPPLICABLE_OPERATOR_MODIFIER.on(modifier))
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java
index 7cf79102c32..21ad9c916a4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java
@@ -25,10 +25,10 @@ import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.idea.MainFunctionDetector;
 import org.jetbrains.kotlin.name.FqNameUnsafe;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetDeclaration;
-import org.jetbrains.kotlin.psi.JetObjectDeclaration;
-import org.jetbrains.kotlin.psi.JetSecondaryConstructor;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtObjectDeclaration;
+import org.jetbrains.kotlin.psi.KtSecondaryConstructor;
 
 import java.util.Collection;
 import java.util.Map;
@@ -54,7 +54,7 @@ public class OverloadResolver {
         MultiMap<FqNameUnsafe, ConstructorDescriptor> inPackages = MultiMap.create();
         fillGroupedConstructors(c, inClasses, inPackages);
 
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
+        for (Map.Entry<KtClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
             checkOverloadsInAClass(entry.getValue(), entry.getKey(), inClasses.get(entry.getValue()));
         }
         checkOverloadsInPackages(c, inPackages);
@@ -117,12 +117,12 @@ public class OverloadResolver {
         }
     }
 
-    private static String nameForErrorMessage(ClassDescriptor classDescriptor, JetClassOrObject jetClass) {
+    private static String nameForErrorMessage(ClassDescriptor classDescriptor, KtClassOrObject jetClass) {
         String name = jetClass.getName();
         if (name != null) {
             return name;
         }
-        if (jetClass instanceof JetObjectDeclaration) {
+        if (jetClass instanceof KtObjectDeclaration) {
             // must be companion object
             name = classDescriptor.getContainingDeclaration().getName().asString();
             return "companion object " + name;
@@ -132,7 +132,7 @@ public class OverloadResolver {
     }
 
     private void checkOverloadsInAClass(
-            ClassDescriptorWithResolutionScopes classDescriptor, JetClassOrObject klass,
+            ClassDescriptorWithResolutionScopes classDescriptor, KtClassOrObject klass,
             Collection<ConstructorDescriptor> nestedClassConstructors
     ) {
         MultiMap<Name, CallableMemberDescriptor> functionsByName = MultiMap.create();
@@ -162,8 +162,8 @@ public class OverloadResolver {
     }
 
     @NotNull
-    private Set<Pair<JetDeclaration, CallableMemberDescriptor>> findRedeclarations(@NotNull Collection<CallableMemberDescriptor> functions) {
-        Set<Pair<JetDeclaration, CallableMemberDescriptor>> redeclarations = Sets.newLinkedHashSet();
+    private Set<Pair<KtDeclaration, CallableMemberDescriptor>> findRedeclarations(@NotNull Collection<CallableMemberDescriptor> functions) {
+        Set<Pair<KtDeclaration, CallableMemberDescriptor>> redeclarations = Sets.newLinkedHashSet();
         for (CallableMemberDescriptor member : functions) {
             for (CallableMemberDescriptor member2 : functions) {
                 if (member == member2 || isConstructorsOfDifferentRedeclaredClasses(member, member2)) {
@@ -172,9 +172,9 @@ public class OverloadResolver {
 
                 OverloadUtil.OverloadCompatibilityInfo overloadable = OverloadUtil.isOverloadable(member, member2);
                 if (!overloadable.isSuccess() && member.getKind() != CallableMemberDescriptor.Kind.SYNTHESIZED) {
-                    JetDeclaration jetDeclaration = (JetDeclaration) DescriptorToSourceUtils.descriptorToDeclaration(member);
-                    if (jetDeclaration != null) {
-                        redeclarations.add(Pair.create(jetDeclaration, member));
+                    KtDeclaration ktDeclaration = (KtDeclaration) DescriptorToSourceUtils.descriptorToDeclaration(member);
+                    if (ktDeclaration != null) {
+                        redeclarations.add(Pair.create(ktDeclaration, member));
                     }
                 }
             }
@@ -195,21 +195,21 @@ public class OverloadResolver {
     }
 
     private void reportRedeclarations(@NotNull String functionContainer,
-            @NotNull Set<Pair<JetDeclaration, CallableMemberDescriptor>> redeclarations) {
-        for (Pair<JetDeclaration, CallableMemberDescriptor> redeclaration : redeclarations) {
+            @NotNull Set<Pair<KtDeclaration, CallableMemberDescriptor>> redeclarations) {
+        for (Pair<KtDeclaration, CallableMemberDescriptor> redeclaration : redeclarations) {
             CallableMemberDescriptor memberDescriptor = redeclaration.getSecond();
             if (DescriptorToSourceUtils.isTopLevelMainFunction(memberDescriptor, mainFunctionDetector)) return;
 
-            JetDeclaration jetDeclaration = redeclaration.getFirst();
+            KtDeclaration ktDeclaration = redeclaration.getFirst();
             if (memberDescriptor instanceof PropertyDescriptor) {
-                trace.report(Errors.REDECLARATION.on(jetDeclaration, memberDescriptor.getName().asString()));
+                trace.report(Errors.REDECLARATION.on(ktDeclaration, memberDescriptor.getName().asString()));
             }
             else {
-                String containingClassName = jetDeclaration instanceof JetSecondaryConstructor ?
-                                               ((JetSecondaryConstructor) jetDeclaration).getContainingClassOrObject().getName() : null;
+                String containingClassName = ktDeclaration instanceof KtSecondaryConstructor ?
+                                             ((KtSecondaryConstructor) ktDeclaration).getContainingClassOrObject().getName() : null;
 
                 trace.report(Errors.CONFLICTING_OVERLOADS.on(
-                        jetDeclaration, memberDescriptor,
+                        ktDeclaration, memberDescriptor,
                         containingClassName != null ? containingClassName : functionContainer));
             }
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadUtil.java
index 59bcd470ab4..ec7661c8348 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadUtil.java
@@ -21,9 +21,9 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor;
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeCapabilitiesKt;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.List;
 
@@ -65,13 +65,13 @@ public class OverloadUtil {
             return receiverAndParameterResult;
         }
 
-        List<JetType> superValueParameters = OverridingUtil.compiledValueParameters(superDescriptor);
-        List<JetType> subValueParameters = OverridingUtil.compiledValueParameters(subDescriptor);
+        List<KtType> superValueParameters = OverridingUtil.compiledValueParameters(superDescriptor);
+        List<KtType> subValueParameters = OverridingUtil.compiledValueParameters(subDescriptor);
 
         for (int i = 0; i < superValueParameters.size(); ++i) {
-            JetType superValueParameterType = OverridingUtil.getUpperBound(superValueParameters.get(i));
-            JetType subValueParameterType = OverridingUtil.getUpperBound(subValueParameters.get(i));
-            if (!JetTypeChecker.DEFAULT.equalTypes(superValueParameterType, subValueParameterType)
+            KtType superValueParameterType = OverridingUtil.getUpperBound(superValueParameters.get(i));
+            KtType subValueParameterType = OverridingUtil.getUpperBound(subValueParameters.get(i));
+            if (!KotlinTypeChecker.DEFAULT.equalTypes(superValueParameterType, subValueParameterType)
                 || TypeCapabilitiesKt.oneMoreSpecificThanAnother(subValueParameterType, superValueParameterType)) {
                 return OverridingUtil.OverrideCompatibilityInfo
                         .valueParameterTypeMismatch(superValueParameterType, subValueParameterType, INCOMPATIBLE);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java
index 06d55d2b298..f8bc205c459 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java
@@ -33,14 +33,14 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.ReadOnly;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilKt;
 import org.jetbrains.kotlin.resolve.dataClassUtils.DataClassUtilsKt;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.types.*;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.utils.HashSetUtil;
 
 import java.util.*;
@@ -111,8 +111,8 @@ public class OverrideResolver {
                 }
                 //noinspection ConstantConditions
                 PsiElement element = DescriptorToSourceUtils.descriptorToDeclaration(reportOn);
-                if (element instanceof JetDeclaration) {
-                    trace.report(CANNOT_INFER_VISIBILITY.on((JetDeclaration) element, descriptor));
+                if (element instanceof KtDeclaration) {
+                    trace.report(CANNOT_INFER_VISIBILITY.on((KtDeclaration) element, descriptor));
                 }
                 return Unit.INSTANCE$;
             }
@@ -235,13 +235,13 @@ public class OverrideResolver {
 
     private static List<CallableMemberDescriptor> getCallableMembersFromSupertypes(ClassDescriptor classDescriptor) {
         Set<CallableMemberDescriptor> r = Sets.newLinkedHashSet();
-        for (JetType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
+        for (KtType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
             r.addAll(getCallableMembersFromType(supertype));
         }
         return new ArrayList<CallableMemberDescriptor>(r);
     }
 
-    private static List<CallableMemberDescriptor> getCallableMembersFromType(JetType type) {
+    private static List<CallableMemberDescriptor> getCallableMembersFromType(KtType type) {
         List<CallableMemberDescriptor> r = Lists.newArrayList();
         for (DeclarationDescriptor decl : type.getMemberScope().getAllDescriptors()) {
             if (decl instanceof PropertyDescriptor || decl instanceof SimpleFunctionDescriptor) {
@@ -252,12 +252,12 @@ public class OverrideResolver {
     }
 
     private void checkOverrides(@NotNull TopDownAnalysisContext c) {
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
+        for (Map.Entry<KtClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
             checkOverridesInAClass(entry.getValue(), entry.getKey());
         }
     }
 
-    private void checkOverridesInAClass(@NotNull ClassDescriptorWithResolutionScopes classDescriptor, @NotNull JetClassOrObject klass) {
+    private void checkOverridesInAClass(@NotNull ClassDescriptorWithResolutionScopes classDescriptor, @NotNull KtClassOrObject klass) {
         // Check overrides for internal consistency
         for (CallableMemberDescriptor member : classDescriptor.getDeclaredCallableMembers()) {
             checkOverrideForMember(member);
@@ -574,13 +574,13 @@ public class OverrideResolver {
             return;
         }
 
-        final JetNamedDeclaration member = (JetNamedDeclaration) DescriptorToSourceUtils.descriptorToDeclaration(declared);
+        final KtNamedDeclaration member = (KtNamedDeclaration) DescriptorToSourceUtils.descriptorToDeclaration(declared);
         if (member == null) {
             throw new IllegalStateException("declared descriptor is not resolved to declaration: " + declared);
         }
 
-        JetModifierList modifierList = member.getModifierList();
-        boolean hasOverrideNode = modifierList != null && modifierList.hasModifier(JetTokens.OVERRIDE_KEYWORD);
+        KtModifierList modifierList = member.getModifierList();
+        boolean hasOverrideNode = modifierList != null && modifierList.hasModifier(KtTokens.OVERRIDE_KEYWORD);
         Collection<? extends CallableMemberDescriptor> overriddenDescriptors = declared.getOverriddenDescriptors();
 
         if (hasOverrideNode) {
@@ -687,16 +687,16 @@ public class OverrideResolver {
         TypeSubstitutor typeSubstitutor = prepareTypeSubstitutor(superDescriptor, subDescriptor);
         if (typeSubstitutor == null) return false;
 
-        JetType superReturnType = superDescriptor.getReturnType();
+        KtType superReturnType = superDescriptor.getReturnType();
         assert superReturnType != null;
 
-        JetType subReturnType = subDescriptor.getReturnType();
+        KtType subReturnType = subDescriptor.getReturnType();
         assert subReturnType != null;
 
-        JetType substitutedSuperReturnType = typeSubstitutor.substitute(superReturnType, Variance.OUT_VARIANCE);
+        KtType substitutedSuperReturnType = typeSubstitutor.substitute(superReturnType, Variance.OUT_VARIANCE);
         assert substitutedSuperReturnType != null;
 
-        return JetTypeChecker.DEFAULT.isSubtypeOf(subReturnType, substitutedSuperReturnType);
+        return KotlinTypeChecker.DEFAULT.isSubtypeOf(subReturnType, substitutedSuperReturnType);
     }
 
     @Nullable
@@ -725,9 +725,9 @@ public class OverrideResolver {
 
         if (!superDescriptor.isVar()) return true;
 
-        JetType substitutedSuperReturnType = typeSubstitutor.substitute(superDescriptor.getType(), Variance.OUT_VARIANCE);
+        KtType substitutedSuperReturnType = typeSubstitutor.substitute(superDescriptor.getType(), Variance.OUT_VARIANCE);
         assert substitutedSuperReturnType != null;
-        return JetTypeChecker.DEFAULT.equalTypes(subDescriptor.getType(), substitutedSuperReturnType);
+        return KotlinTypeChecker.DEFAULT.equalTypes(subDescriptor.getType(), substitutedSuperReturnType);
     }
 
     private void checkOverrideForComponentFunction(@NotNull final CallableMemberDescriptor componentFunction) {
@@ -776,9 +776,9 @@ public class OverrideResolver {
 
     @NotNull
     private static PsiElement findDataModifierForDataClass(@NotNull DeclarationDescriptor dataClass) {
-        JetClass classDeclaration = (JetClass) DescriptorToSourceUtils.getSourceFromDescriptor(dataClass);
+        KtClass classDeclaration = (KtClass) DescriptorToSourceUtils.getSourceFromDescriptor(dataClass);
         if (classDeclaration != null && classDeclaration.getModifierList() != null) {
-            PsiElement modifier = classDeclaration.getModifierList().getModifier(JetTokens.DATA_KEYWORD);
+            PsiElement modifier = classDeclaration.getModifierList().getModifier(KtTokens.DATA_KEYWORD);
             if (modifier != null) {
                 return modifier;
             }
@@ -792,7 +792,7 @@ public class OverrideResolver {
             @NotNull CallableMemberDescriptor declared,
             @NotNull ClassDescriptor declaringClass
     ) {
-        for (JetType supertype : declaringClass.getTypeConstructor().getSupertypes()) {
+        for (KtType supertype : declaringClass.getTypeConstructor().getSupertypes()) {
             Set<CallableMemberDescriptor> all = Sets.newLinkedHashSet();
             all.addAll(supertype.getMemberScope().getFunctions(declared.getName(), NoLookupLocation.UNSORTED));
             //noinspection unchecked
@@ -824,8 +824,8 @@ public class OverrideResolver {
         boolean isDeclaration = declared.getKind() == CallableMemberDescriptor.Kind.DECLARATION;
         if (isDeclaration) {
             // No check if the function is not marked as 'override'
-            JetModifierListOwner declaration = (JetModifierListOwner) DescriptorToSourceUtils.descriptorToDeclaration(declared);
-            if (declaration != null && !declaration.hasModifier(JetTokens.OVERRIDE_KEYWORD)) {
+            KtModifierListOwner declaration = (KtModifierListOwner) DescriptorToSourceUtils.descriptorToDeclaration(declared);
+            if (declaration != null && !declaration.hasModifier(KtTokens.OVERRIDE_KEYWORD)) {
                 return;
             }
         }
@@ -854,7 +854,7 @@ public class OverrideResolver {
     }
 
     private void checkNameAndDefaultForDeclaredParameter(@NotNull ValueParameterDescriptor descriptor, boolean multipleDefaultsInSuper) {
-        JetParameter parameter = (JetParameter) DescriptorToSourceUtils.descriptorToDeclaration(descriptor);
+        KtParameter parameter = (KtParameter) DescriptorToSourceUtils.descriptorToDeclaration(descriptor);
         assert parameter != null : "Declaration not found for parameter: " + descriptor;
 
         if (descriptor.declaresDefaultValue()) {
@@ -883,7 +883,7 @@ public class OverrideResolver {
             boolean multipleDefaultsInSuper
     ) {
         DeclarationDescriptor containingClass = containingFunction.getContainingDeclaration();
-        JetClassOrObject classElement = (JetClassOrObject) DescriptorToSourceUtils.descriptorToDeclaration(containingClass);
+        KtClassOrObject classElement = (KtClassOrObject) DescriptorToSourceUtils.descriptorToDeclaration(containingClass);
         assert classElement != null : "Declaration not found for class: " + containingClass;
 
         if (multipleDefaultsInSuper) {
@@ -915,12 +915,12 @@ public class OverrideResolver {
     }
 
     private void checkVisibility(@NotNull TopDownAnalysisContext c) {
-        for (Map.Entry<JetCallableDeclaration, CallableMemberDescriptor> entry : c.getMembers().entrySet()) {
+        for (Map.Entry<KtCallableDeclaration, CallableMemberDescriptor> entry : c.getMembers().entrySet()) {
             checkVisibilityForMember(entry.getKey(), entry.getValue());
         }
     }
 
-    private void checkVisibilityForMember(@NotNull JetDeclaration declaration, @NotNull CallableMemberDescriptor memberDescriptor) {
+    private void checkVisibilityForMember(@NotNull KtDeclaration declaration, @NotNull CallableMemberDescriptor memberDescriptor) {
         Visibility visibility = memberDescriptor.getVisibility();
         for (CallableMemberDescriptor descriptor : memberDescriptor.getOverriddenDescriptors()) {
             Integer compare = Visibilities.compare(visibility, descriptor.getVisibility());
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/PlatformTypesMappedToKotlinChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/PlatformTypesMappedToKotlinChecker.java
index 1a0242cff97..137118e8f79 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/PlatformTypesMappedToKotlinChecker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/PlatformTypesMappedToKotlinChecker.java
@@ -21,9 +21,9 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetImportDirective;
+import org.jetbrains.kotlin.psi.KtElement;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtImportDirective;
 
 import java.util.Collection;
 
@@ -34,10 +34,10 @@ public class PlatformTypesMappedToKotlinChecker {
     public static void checkPlatformTypesMappedToKotlin(
             @NotNull ModuleDescriptor module,
             @NotNull BindingTrace trace,
-            @NotNull JetImportDirective importDirective,
+            @NotNull KtImportDirective importDirective,
             @NotNull Collection<? extends DeclarationDescriptor> descriptors
     ) {
-        JetExpression importedReference = importDirective.getImportedReference();
+        KtExpression importedReference = importDirective.getImportedReference();
         if (importedReference != null) {
             for (DeclarationDescriptor descriptor : descriptors) {
                 reportPlatformClassMappedToKotlin(module, trace, importedReference, descriptor);
@@ -48,7 +48,7 @@ public class PlatformTypesMappedToKotlinChecker {
     public static void reportPlatformClassMappedToKotlin(
             @NotNull ModuleDescriptor module,
             @NotNull BindingTrace trace,
-            @NotNull JetElement element,
+            @NotNull KtElement element,
             @NotNull DeclarationDescriptor descriptor
     ) {
         if (!(descriptor instanceof ClassDescriptor)) return;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/PossiblyBareType.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/PossiblyBareType.java
index 0493186e1c6..f34b2b91f72 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/PossiblyBareType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/PossiblyBareType.java
@@ -48,15 +48,15 @@ public class PossiblyBareType {
     }
 
     @NotNull
-    public static PossiblyBareType type(@NotNull JetType actualType) {
+    public static PossiblyBareType type(@NotNull KtType actualType) {
         return new PossiblyBareType(actualType, null, false);
     }
 
-    private final JetType actualType;
+    private final KtType actualType;
     private final TypeConstructor bareTypeConstructor;
     private final boolean nullable;
 
-    private PossiblyBareType(@Nullable JetType actualType, @Nullable TypeConstructor bareTypeConstructor, boolean nullable) {
+    private PossiblyBareType(@Nullable KtType actualType, @Nullable TypeConstructor bareTypeConstructor, boolean nullable) {
         this.actualType = actualType;
         this.bareTypeConstructor = bareTypeConstructor;
         this.nullable = nullable;
@@ -67,7 +67,7 @@ public class PossiblyBareType {
     }
 
     @NotNull
-    public JetType getActualType() {
+    public KtType getActualType() {
         //noinspection ConstantConditions
         return actualType;
     }
@@ -95,18 +95,18 @@ public class PossiblyBareType {
     }
 
     @NotNull
-    public TypeReconstructionResult reconstruct(@NotNull JetType subjectType) {
+    public TypeReconstructionResult reconstruct(@NotNull KtType subjectType) {
         if (!isBare()) return new TypeReconstructionResult(getActualType(), true);
 
         TypeReconstructionResult reconstructionResult = CastDiagnosticsUtil.findStaticallyKnownSubtype(
                 TypeUtils.makeNotNullable(subjectType),
                 getBareTypeConstructor()
         );
-        JetType type = reconstructionResult.getResultingType();
+        KtType type = reconstructionResult.getResultingType();
         // No need to make an absent type nullable
         if (type == null) return reconstructionResult;
 
-        JetType resultingType = TypeUtils.makeNullableAsSpecified(type, isBareTypeNullable());
+        KtType resultingType = TypeUtils.makeNullableAsSpecified(type, isBareTypeNullable());
         return new TypeReconstructionResult(resultingType, reconstructionResult.isAllArgumentsInferred());
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt
index d1669536885..48743d47bbf 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
-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.resolve.scopes.receivers.QualifierReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
@@ -37,7 +37,7 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
 
 
     public fun resolvePackageHeader(
-            packageDirective: JetPackageDirective,
+            packageDirective: KtPackageDirective,
             module: ModuleDescriptor,
             trace: BindingTrace
     ) {
@@ -49,7 +49,7 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
     }
 
     public fun resolveDescriptorForUserType(
-            userType: JetUserType,
+            userType: KtUserType,
             scope: LexicalScope,
             trace: BindingTrace
     ): ClassifierDescriptor? {
@@ -86,7 +86,7 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
         return classifier
     }
 
-    private val JetUserType.startWithPackage: Boolean
+    private val KtUserType.startWithPackage: Boolean
         get() {
             var firstPart = this
             while (firstPart.qualifier != null) {
@@ -96,10 +96,10 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
         }
 
 
-    private fun JetUserType.asQualifierPartList(): Pair<List<QualifierPart>, Boolean> {
+    private fun KtUserType.asQualifierPartList(): Pair<List<QualifierPart>, Boolean> {
         var hasError = false
         val result = SmartList<QualifierPart>()
-        var userType: JetUserType? = this
+        var userType: KtUserType? = this
         while (userType != null) {
             val referenceExpression = userType.referenceExpression
             if (referenceExpression != null) {
@@ -114,11 +114,11 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
     }
 
     public fun processImportReference(
-            importDirective: JetImportDirective,
+            importDirective: KtImportDirective,
             moduleDescriptor: ModuleDescriptor,
             trace: BindingTrace,
             packageFragmentForVisibilityCheck: PackageFragmentDescriptor?
-    ): JetScope? { // null if some error happened
+    ): KtScope? { // null if some error happened
         val importedReference = importDirective.importedReference ?: return null
         val path = importedReference.asQualifierPartList(trace)
         val lastPart = path.lastOrNull() ?: return null
@@ -135,10 +135,10 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
 }
 
     private fun processSingleImport(
-            moduleDescriptor: ModuleDescriptor, trace: BindingTrace, importDirective: JetImportDirective,
+            moduleDescriptor: ModuleDescriptor, trace: BindingTrace, importDirective: KtImportDirective,
             path: List<QualifierPart>, lastPart: QualifierPart, packageFragmentForVisibilityCheck: PackageFragmentDescriptor?
     ): SingleImportScope? {
-        val aliasName = JetPsiUtil.getAliasName(importDirective)
+        val aliasName = KtPsiUtil.getAliasName(importDirective)
         if (aliasName == null) {
             // import kotlin.
             resolveToPackageOrClass(path, moduleDescriptor, trace, packageFragmentForVisibilityCheck, scopeForFirstPart = null, inImport = true)
@@ -232,21 +232,21 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
         storeResult(trace, lastPart.expression, descriptors, shouldBeVisibleFrom = null, inImport = true, isQualifier = false)
     }
 
-    private fun JetExpression.asQualifierPartList(trace: BindingTrace): List<QualifierPart> {
+    private fun KtExpression.asQualifierPartList(trace: BindingTrace): List<QualifierPart> {
         val result = SmartList<QualifierPart>()
-        var expression: JetExpression? = this
+        var expression: KtExpression? = this
         loop@ while (expression != null) {
             when (expression) {
-                is JetSimpleNameExpression -> {
+                is KtSimpleNameExpression -> {
                     result add QualifierPart(expression.getReferencedNameAsName(), expression)
                     break@loop
                 }
-                is JetQualifiedExpression -> {
-                    (expression.selectorExpression as? JetSimpleNameExpression)?.let {
+                is KtQualifiedExpression -> {
+                    (expression.selectorExpression as? KtSimpleNameExpression)?.let {
                         result add QualifierPart(it.getReferencedNameAsName(), it)
                     }
                     expression = expression.receiverExpression
-                    if (expression is JetSafeQualifiedExpression) {
+                    if (expression is KtSafeQualifiedExpression) {
                         trace.report(Errors.SAFE_CALL_IN_QUALIFIER.on(expression.operationTokenNode.psi))
                     }
                 }
@@ -258,8 +258,8 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
 
     private data class QualifierPart(
             val name: Name,
-            val expression: JetSimpleNameExpression,
-            val typeArguments: JetTypeArgumentList? = null
+            val expression: KtSimpleNameExpression,
+            val typeArguments: KtTypeArgumentList? = null
     ) {
         val location = KotlinLookupLocation(expression)
     }
@@ -355,7 +355,7 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
 
     private fun storeResult(
             trace: BindingTrace,
-            referenceExpression: JetSimpleNameExpression,
+            referenceExpression: KtSimpleNameExpression,
             descriptors: Collection<DeclarationDescriptor>,
             shouldBeVisibleFrom: DeclarationDescriptor?,
             inImport: Boolean,
@@ -381,7 +381,7 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
 
     private fun storeResult(
             trace: BindingTrace,
-            referenceExpression: JetSimpleNameExpression,
+            referenceExpression: KtSimpleNameExpression,
             descriptor: DeclarationDescriptor?,
             shouldBeVisibleFrom: DeclarationDescriptor?,
             inImport: Boolean,
@@ -407,7 +407,7 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
         }
     }
 
-    private fun storageQualifier(trace: BindingTrace, referenceExpression: JetSimpleNameExpression, descriptor: DeclarationDescriptor) {
+    private fun storageQualifier(trace: BindingTrace, referenceExpression: KtSimpleNameExpression, descriptor: DeclarationDescriptor) {
         if (descriptor is PackageViewDescriptor || descriptor is ClassifierDescriptor) {
             val qualifier = QualifierReceiver(referenceExpression, descriptor as? PackageViewDescriptor, descriptor as? ClassifierDescriptor)
             trace.record(BindingContext.QUALIFIER, qualifier.expression, qualifier)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java
index db6bba7772d..2d4cb7f15e5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java
@@ -18,11 +18,11 @@ package org.jetbrains.kotlin.resolve;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor;
-import org.jetbrains.kotlin.psi.JetScript;
+import org.jetbrains.kotlin.psi.KtScript;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.expressions.CoercionStrategy;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
@@ -45,15 +45,15 @@ public class ScriptBodyResolver {
     }
 
     public void resolveScriptBodies(@NotNull BodiesResolveContext c) {
-        for (Map.Entry<JetScript, ScriptDescriptor> e : c.getScripts().entrySet()) {
+        for (Map.Entry<KtScript, ScriptDescriptor> e : c.getScripts().entrySet()) {
             ScriptDescriptor descriptor = e.getValue();
             ForceResolveUtil.forceResolveAllContents(descriptor);
         }
     }
 
     @NotNull
-    public JetType resolveScriptReturnType(
-            @NotNull JetScript script,
+    public KtType resolveScriptReturnType(
+            @NotNull KtScript script,
             @NotNull ScriptDescriptor scriptDescriptor,
             @NotNull BindingTrace trace
     ) {
@@ -65,7 +65,7 @@ public class ScriptBodyResolver {
                 NO_EXPECTED_TYPE
         );
         PreliminaryDeclarationVisitor.Companion.createForDeclaration(script, trace);
-        JetType returnType = expressionTypingServices.getBlockReturnedType(script.getBlockExpression(), CoercionStrategy.NO_COERCION, context).getType();
+        KtType returnType = expressionTypingServices.getBlockReturnedType(script.getBlockExpression(), CoercionStrategy.NO_COERCION, context).getType();
         if (returnType == null) {
             returnType = ErrorUtils.createErrorType("getBlockReturnedType returned null");
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptNameUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptNameUtil.java
index 732867e785f..835f5f3c026 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptNameUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptNameUtil.java
@@ -20,17 +20,17 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.parsing.JetScriptDefinition;
 import org.jetbrains.kotlin.parsing.JetScriptDefinitionProvider;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetPackageDirective;
-import org.jetbrains.kotlin.psi.JetScript;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtPackageDirective;
+import org.jetbrains.kotlin.psi.KtScript;
 
 public class ScriptNameUtil {
     private ScriptNameUtil() {
     }
 
     @NotNull
-    public static FqName classNameForScript(JetScript script) {
-        JetFile file = script.getContainingJetFile();
+    public static FqName classNameForScript(KtScript script) {
+        KtFile file = script.getContainingJetFile();
         JetScriptDefinition scriptDefinition = JetScriptDefinitionProvider.getInstance(file.getProject()).findScriptDefinition(file);
 
         String name = file.getName();
@@ -46,7 +46,7 @@ public class ScriptNameUtil {
         }
         name = Character.toUpperCase(name.charAt(0)) + (name.length() == 0 ? "" : name.substring(1));
         name = name.replace('.', '_');
-        JetPackageDirective directive = file.getPackageDirective();
+        KtPackageDirective directive = file.getPackageDirective();
         if(directive != null && directive.getQualifiedName().length() > 0) {
             name = directive.getQualifiedName() + "." + name;
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptPriorities.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptPriorities.java
index d332e5c4065..6720d1a7504 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptPriorities.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptPriorities.java
@@ -18,14 +18,14 @@ package org.jetbrains.kotlin.resolve;
 
 import com.intellij.openapi.util.Key;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetScript;
+import org.jetbrains.kotlin.psi.KtScript;
 
 // SCRIPT: Resolve declarations in scripts
 public class ScriptPriorities {
 
-    public static final Key<Integer> PRIORITY_KEY = Key.create(JetScript.class.getName() + ".priority");
+    public static final Key<Integer> PRIORITY_KEY = Key.create(KtScript.class.getName() + ".priority");
 
-    public static int getScriptPriority(@NotNull JetScript script) {
+    public static int getScriptPriority(@NotNull KtScript script) {
         Integer priority = script.getUserData(PRIORITY_KEY);
         return priority == null ? 0 : priority;
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/SingleImportScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/SingleImportScope.kt
index c2826efb0f2..3fb5b046454 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/SingleImportScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/SingleImportScope.kt
@@ -19,11 +19,11 @@ package org.jetbrains.kotlin.resolve
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
+import org.jetbrains.kotlin.resolve.scopes.KtScopeImpl
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.utils.Printer
 
-class SingleImportScope(private val aliasName: Name, private val descriptors: Collection<DeclarationDescriptor>) : JetScopeImpl() {
+class SingleImportScope(private val aliasName: Name, private val descriptors: Collection<DeclarationDescriptor>) : KtScopeImpl() {
     override fun getClassifier(name: Name, location: LookupLocation)
             = if (name == aliasName) descriptors.filterIsInstance<ClassifierDescriptor>().singleOrNull() else null
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/StatementFilter.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/StatementFilter.kt
index ae948e3519b..363d6403a5f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/StatementFilter.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/StatementFilter.kt
@@ -16,14 +16,14 @@
 
 package org.jetbrains.kotlin.resolve
 
-import org.jetbrains.kotlin.psi.JetBlockExpression
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetPsiUtil
+import org.jetbrains.kotlin.psi.KtBlockExpression
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtPsiUtil
 
 public open class StatementFilter {
 
-    public open val filter: ((JetExpression) -> Boolean)?
+    public open val filter: ((KtExpression) -> Boolean)?
         get() = null
 
     companion object {
@@ -31,9 +31,9 @@ public open class StatementFilter {
     }
 }
 
-fun StatementFilter.filterStatements(block: JetBlockExpression): List<JetExpression> {
-    if (filter == null || block is JetPsiUtil.JetExpressionWrapper) return block.getStatements()
+fun StatementFilter.filterStatements(block: KtBlockExpression): List<KtExpression> {
+    if (filter == null || block is KtPsiUtil.KtExpressionWrapper) return block.getStatements()
     return block.getStatements().filter { filter!!(it) }
 }
 
-fun StatementFilter.getLastStatementInABlock(block: JetBlockExpression) = filterStatements(block).lastOrNull()
\ No newline at end of file
+fun StatementFilter.getLastStatementInABlock(block: KtBlockExpression) = filterStatements(block).lastOrNull()
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java
index 6d20f164c4c..db1053a3984 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java
@@ -37,17 +37,17 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
 
     private final DataFlowInfo outerDataFlowInfo;
 
-    private final Map<JetClassOrObject, ClassDescriptorWithResolutionScopes> classes = Maps.newLinkedHashMap();
-    private final Map<JetClassInitializer, ClassDescriptorWithResolutionScopes> anonymousInitializers = Maps.newLinkedHashMap();
-    private final Set<JetFile> files = new LinkedHashSet<JetFile>();
-    private final Map<JetSecondaryConstructor, ConstructorDescriptor> secondaryConstructors = Maps.newLinkedHashMap();
+    private final Map<KtClassOrObject, ClassDescriptorWithResolutionScopes> classes = Maps.newLinkedHashMap();
+    private final Map<KtClassInitializer, ClassDescriptorWithResolutionScopes> anonymousInitializers = Maps.newLinkedHashMap();
+    private final Set<KtFile> files = new LinkedHashSet<KtFile>();
+    private final Map<KtSecondaryConstructor, ConstructorDescriptor> secondaryConstructors = Maps.newLinkedHashMap();
 
-    private final Map<JetNamedFunction, SimpleFunctionDescriptor> functions = Maps.newLinkedHashMap();
-    private final Map<JetProperty, PropertyDescriptor> properties = Maps.newLinkedHashMap();
-    private final Map<JetParameter, PropertyDescriptor> primaryConstructorParameterProperties = Maps.newHashMap();
-    private Map<JetCallableDeclaration, CallableMemberDescriptor> members = null;
+    private final Map<KtNamedFunction, SimpleFunctionDescriptor> functions = Maps.newLinkedHashMap();
+    private final Map<KtProperty, PropertyDescriptor> properties = Maps.newLinkedHashMap();
+    private final Map<KtParameter, PropertyDescriptor> primaryConstructorParameterProperties = Maps.newHashMap();
+    private Map<KtCallableDeclaration, CallableMemberDescriptor> members = null;
 
-    private final Map<JetScript, ScriptDescriptor> scripts = Maps.newLinkedHashMap();
+    private final Map<KtScript, ScriptDescriptor> scripts = Maps.newLinkedHashMap();
 
     private final TopDownAnalysisMode topDownAnalysisMode;
     private final DeclarationScopeProvider declarationScopeProvider;
@@ -90,57 +90,57 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
     }
 
     @Override
-    public Map<JetClassOrObject, ClassDescriptorWithResolutionScopes> getDeclaredClasses() {
+    public Map<KtClassOrObject, ClassDescriptorWithResolutionScopes> getDeclaredClasses() {
         return classes;
     }
 
     @Override
-    public Map<JetClassInitializer, ClassDescriptorWithResolutionScopes> getAnonymousInitializers() {
+    public Map<KtClassInitializer, ClassDescriptorWithResolutionScopes> getAnonymousInitializers() {
         return anonymousInitializers;
     }
 
     @Override
-    public Map<JetSecondaryConstructor, ConstructorDescriptor> getSecondaryConstructors() {
+    public Map<KtSecondaryConstructor, ConstructorDescriptor> getSecondaryConstructors() {
         return secondaryConstructors;
     }
 
     @Override
-    public Collection<JetFile> getFiles() {
+    public Collection<KtFile> getFiles() {
         return files;
     }
 
-    public void addFile(@NotNull JetFile file) {
+    public void addFile(@NotNull KtFile file) {
         files.add(file);
     }
 
     @Override
     @NotNull
-    public Map<JetScript, ScriptDescriptor> getScripts() {
+    public Map<KtScript, ScriptDescriptor> getScripts() {
         return scripts;
     }
 
-    public Map<JetParameter, PropertyDescriptor> getPrimaryConstructorParameterProperties() {
+    public Map<KtParameter, PropertyDescriptor> getPrimaryConstructorParameterProperties() {
         return primaryConstructorParameterProperties;
     }
 
     @Override
-    public Map<JetProperty, PropertyDescriptor> getProperties() {
+    public Map<KtProperty, PropertyDescriptor> getProperties() {
         return properties;
     }
 
     @Nullable
     @Override
-    public LexicalScope getDeclaringScope(@NotNull JetDeclaration declaration) {
+    public LexicalScope getDeclaringScope(@NotNull KtDeclaration declaration) {
         return declarationScopeProvider.getResolutionScopeForDeclaration(declaration);
     }
 
     @Override
-    public Map<JetNamedFunction, SimpleFunctionDescriptor> getFunctions() {
+    public Map<KtNamedFunction, SimpleFunctionDescriptor> getFunctions() {
         return functions;
     }
 
     @NotNull
-    public Map<JetCallableDeclaration, CallableMemberDescriptor> getMembers() {
+    public Map<KtCallableDeclaration, CallableMemberDescriptor> getMembers() {
         if (members == null) {
             members = Maps.newLinkedHashMap();
             members.putAll(functions);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeBinding.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeBinding.kt
index a0c3b046902..c3e2a420d94 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeBinding.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeBinding.kt
@@ -16,13 +16,13 @@
 
 package org.jetbrains.kotlin.resolve.typeBinding
 
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetTypeElement
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
+import org.jetbrains.kotlin.psi.KtTypeElement
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.psi.JetTypeReference
+import org.jetbrains.kotlin.psi.KtTypeReference
 import org.jetbrains.kotlin.types.TypeProjection
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.types.TypeProjectionImpl
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.types.TypeProjectionImpl
 
 interface TypeBinding<out P : PsiElement> {
     val psiElement: P
-    val jetType: JetType
+    val jetType: KtType
     fun getArgumentBindings(): List<TypeArgumentBinding<P>?>
 }
 
@@ -40,7 +40,7 @@ interface TypeArgumentBinding<out P: PsiElement> {
     val typeBinding: TypeBinding<P>
 }
 
-fun JetTypeReference.createTypeBinding(trace: BindingContext): TypeBinding<JetTypeElement>? {
+fun KtTypeReference.createTypeBinding(trace: BindingContext): TypeBinding<KtTypeElement>? {
     val jetType = trace[BindingContext.TYPE, this]
     val psiElement = typeElement
     if (jetType == null || psiElement == null) {
@@ -51,7 +51,7 @@ fun JetTypeReference.createTypeBinding(trace: BindingContext): TypeBinding<JetTy
     }
 }
 
-fun JetCallableDeclaration.createTypeBindingForReturnType(trace: BindingContext): TypeBinding<PsiElement>?  {
+fun KtCallableDeclaration.createTypeBindingForReturnType(trace: BindingContext): TypeBinding<PsiElement>?  {
     val jetTypeReference = getTypeReference()
     if (jetTypeReference != null) return jetTypeReference.createTypeBinding(trace)
 
@@ -69,11 +69,11 @@ private class TypeArgumentBindingImpl<out P: PsiElement>(
 
 private class ExplicitTypeBinding(
         private val trace: BindingContext,
-        override val psiElement: JetTypeElement,
-        override val jetType: JetType
-) : TypeBinding<JetTypeElement> {
+        override val psiElement: KtTypeElement,
+        override val jetType: KtType
+) : TypeBinding<KtTypeElement> {
 
-    override fun getArgumentBindings(): List<TypeArgumentBinding<JetTypeElement>?> {
+    override fun getArgumentBindings(): List<TypeArgumentBinding<KtTypeElement>?> {
         val psiTypeArguments = psiElement.getTypeArgumentsAsTypes()
         val isErrorBinding = run {
             val sizeIsEqual = psiTypeArguments.size() == jetType.getArguments().size()
@@ -111,7 +111,7 @@ private class ExplicitTypeBinding(
 private class NoTypeElementBinding<out P : PsiElement>(
         private val trace: BindingContext,
         override val psiElement: P,
-        override val jetType: JetType
+        override val jetType: KtType
 ): TypeBinding<P> {
 
     override fun getArgumentBindings(): List<TypeArgumentBinding<P>?> {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt
index 569fc7679d3..c5c268f3a51 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.diagnostics.Errors.*
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.codeFragmentUtil.debugTypeInfo
 import org.jetbrains.kotlin.psi.debugText.getDebugText
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.resolve.bindingContextUtil.recordScope
 import org.jetbrains.kotlin.resolve.calls.tasks.DynamicCallableDescriptors
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
 import org.jetbrains.kotlin.resolve.lazy.LazyEntity
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.LazyScopeAdapter
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
@@ -62,17 +62,17 @@ public class TypeResolver(
         }
     }
 
-    public fun resolveType(scope: LexicalScope, typeReference: JetTypeReference, trace: BindingTrace, checkBounds: Boolean): JetType {
+    public fun resolveType(scope: LexicalScope, typeReference: KtTypeReference, trace: BindingTrace, checkBounds: Boolean): KtType {
         // bare types are not allowed
         return resolveType(TypeResolutionContext(scope, trace, checkBounds, false), typeReference)
     }
 
-    private fun resolveType(c: TypeResolutionContext, typeReference: JetTypeReference): JetType {
+    private fun resolveType(c: TypeResolutionContext, typeReference: KtTypeReference): KtType {
         assert(!c.allowBareTypes) { "Use resolvePossiblyBareType() when bare types are allowed" }
         return resolvePossiblyBareType(c, typeReference).getActualType()
     }
 
-    public fun resolvePossiblyBareType(c: TypeResolutionContext, typeReference: JetTypeReference): PossiblyBareType {
+    public fun resolvePossiblyBareType(c: TypeResolutionContext, typeReference: KtTypeReference): PossiblyBareType {
         val cachedType = c.trace.getBindingContext().get(BindingContext.TYPE, typeReference)
         if (cachedType != null) return type(cachedType)
 
@@ -106,7 +106,7 @@ public class TypeResolver(
         return type
     }
 
-    private fun doResolvePossiblyBareType(c: TypeResolutionContext, typeReference: JetTypeReference): PossiblyBareType {
+    private fun doResolvePossiblyBareType(c: TypeResolutionContext, typeReference: KtTypeReference): PossiblyBareType {
         val annotations = annotationResolver.resolveAnnotationsWithoutArguments(c.scope, typeReference.getAnnotationEntries(), c.trace)
 
         val typeElement = typeReference.typeElement
@@ -136,7 +136,7 @@ public class TypeResolver(
      *
      *  todo: find another way after release
      */
-    private fun forceResolveTypeContents(type: JetType) {
+    private fun forceResolveTypeContents(type: KtType) {
         type.annotations // force read type annotations
         if (type.isFlexible()) {
             forceResolveTypeContents(type.flexibility().lowerBound)
@@ -152,10 +152,10 @@ public class TypeResolver(
         }
     }
 
-    private fun resolveTypeElement(c: TypeResolutionContext, annotations: Annotations, typeElement: JetTypeElement?): PossiblyBareType {
+    private fun resolveTypeElement(c: TypeResolutionContext, annotations: Annotations, typeElement: KtTypeElement?): PossiblyBareType {
         var result: PossiblyBareType? = null
-        typeElement?.accept(object : JetVisitorVoid() {
-            override fun visitUserType(type: JetUserType) {
+        typeElement?.accept(object : KtVisitorVoid() {
+            override fun visitUserType(type: KtUserType) {
                 val classifierDescriptor = resolveClass(c.scope, type, c.trace)
                 if (classifierDescriptor == null) {
                     val arguments = resolveTypeProjections(c, ErrorUtils.createErrorType("No type").getConstructor(), type.getTypeArguments())
@@ -180,7 +180,7 @@ public class TypeResolver(
                         result = if (scopeForTypeParameter is ErrorUtils.ErrorScope)
                                     type(ErrorUtils.createErrorType("?"))
                                  else
-                                    type(JetTypeImpl.create(
+                                    type(KtTypeImpl.create(
                                             annotations,
                                             classifierDescriptor.getTypeConstructor(),
                                             TypeUtils.hasNullableLowerBound(classifierDescriptor),
@@ -234,7 +234,7 @@ public class TypeResolver(
                                     )
                                     return
                                 }
-                                val resultingType = JetTypeImpl.create(annotations, classifierDescriptor, false, arguments)
+                                val resultingType = KtTypeImpl.create(annotations, classifierDescriptor, false, arguments)
                                 result = type(resultingType)
                                 if (c.checkBounds) {
                                     val substitutor = TypeSubstitutor.create(resultingType)
@@ -254,16 +254,16 @@ public class TypeResolver(
                 }
             }
 
-            override fun visitNullableType(nullableType: JetNullableType) {
+            override fun visitNullableType(nullableType: KtNullableType) {
                 val innerType = nullableType.getInnerType()
                 val baseType = resolveTypeElement(c, annotations, innerType)
-                if (baseType.isNullable() || innerType is JetNullableType || innerType is JetDynamicType) {
+                if (baseType.isNullable() || innerType is KtNullableType || innerType is KtDynamicType) {
                     c.trace.report(REDUNDANT_NULLABLE.on(nullableType))
                 }
                 result = baseType.makeNullable()
             }
 
-            override fun visitFunctionType(type: JetFunctionType) {
+            override fun visitFunctionType(type: KtFunctionType) {
                 val receiverTypeRef = type.getReceiverTypeReference()
                 type.parameters.forEach { identifierChecker.checkDeclaration(it, c.trace) }
                 val receiverType = if (receiverTypeRef == null) null else resolveType(c.noBareTypes(), receiverTypeRef)
@@ -278,22 +278,22 @@ public class TypeResolver(
                 result = type(moduleDescriptor.builtIns.getFunctionType(annotations, receiverType, parameterTypes, returnType))
             }
 
-            override fun visitDynamicType(type: JetDynamicType) {
+            override fun visitDynamicType(type: KtDynamicType) {
                 result = type(dynamicCallableDescriptors.dynamicType)
                 if (!dynamicTypesSettings.dynamicTypesAllowed) {
                     c.trace.report(UNSUPPORTED.on(type, "Dynamic types are not supported in this context"))
                 }
             }
 
-            override fun visitSelfType(type: JetSelfType) {
+            override fun visitSelfType(type: KtSelfType) {
                 c.trace.report(UNSUPPORTED.on(type, "Self-types are not supported"))
             }
 
-            override fun visitJetElement(element: JetElement) {
+            override fun visitJetElement(element: KtElement) {
                 c.trace.report(UNSUPPORTED.on(element, "Self-types are not supported yet"))
             }
 
-            private fun checkParameterInFunctionType(param: JetParameter) {
+            private fun checkParameterInFunctionType(param: KtParameter) {
                 if (param.hasDefaultValue()) {
                     c.trace.report(Errors.UNSUPPORTED.on(param.defaultValue!!, "default value of parameter in function type"))
                 }
@@ -306,7 +306,7 @@ public class TypeResolver(
 
                 val modifierList = param.modifierList
                 if (modifierList != null) {
-                    JetTokens.MODIFIER_KEYWORDS_ARRAY
+                    KtTokens.MODIFIER_KEYWORDS_ARRAY
                             .map { modifierList.getModifier(it) }
                             .filterNotNull()
                             .forEach { c.trace.report(Errors.UNSUPPORTED.on(it, "modifier on parameter in function type"))
@@ -322,7 +322,7 @@ public class TypeResolver(
         return result ?: type(ErrorUtils.createErrorType(typeElement?.getDebugText() ?: "No type element"))
     }
 
-    private fun getScopeForTypeParameter(c: TypeResolutionContext, typeParameterDescriptor: TypeParameterDescriptor): JetScope {
+    private fun getScopeForTypeParameter(c: TypeResolutionContext, typeParameterDescriptor: TypeParameterDescriptor): KtScope {
         if (c.checkBounds) {
             return typeParameterDescriptor.getUpperBoundsAsType().getMemberScope()
         }
@@ -333,12 +333,12 @@ public class TypeResolver(
         }
     }
 
-    private fun resolveTypeProjections(c: TypeResolutionContext, constructor: TypeConstructor, argumentElements: List<JetTypeProjection>): List<TypeProjection> {
+    private fun resolveTypeProjections(c: TypeResolutionContext, constructor: TypeConstructor, argumentElements: List<KtTypeProjection>): List<TypeProjection> {
         return argumentElements.mapIndexed { i, argumentElement ->
 
             val projectionKind = argumentElement.getProjectionKind()
             ModifierCheckerCore.check(argumentElement, c.trace, null)
-            if (projectionKind == JetProjectionKind.STAR) {
+            if (projectionKind == KtProjectionKind.STAR) {
                 val parameters = constructor.getParameters()
                 if (parameters.size() > i) {
                     val parameterDescriptor = parameters[i]
@@ -368,7 +368,7 @@ public class TypeResolver(
         }
     }
 
-    public fun resolveClass(scope: LexicalScope, userType: JetUserType, trace: BindingTrace): ClassifierDescriptor? {
+    public fun resolveClass(scope: LexicalScope, userType: KtUserType, trace: BindingTrace): ClassifierDescriptor? {
         if (userType.qualifier != null) { // we must resolve all type references in arguments of qualifier type
             for (typeArgument in userType.qualifier!!.typeArguments) {
                 typeArgument.typeReference?.let {
@@ -386,11 +386,11 @@ public class TypeResolver(
 
     companion object {
         @JvmStatic
-        public fun resolveProjectionKind(projectionKind: JetProjectionKind): Variance {
+        public fun resolveProjectionKind(projectionKind: KtProjectionKind): Variance {
             return when (projectionKind) {
-                JetProjectionKind.IN -> IN_VARIANCE
-                JetProjectionKind.OUT -> OUT_VARIANCE
-                JetProjectionKind.NONE -> INVARIANT
+                KtProjectionKind.IN -> IN_VARIANCE
+                KtProjectionKind.OUT -> OUT_VARIANCE
+                KtProjectionKind.NONE -> INVARIANT
                 else -> // NOTE: Star projections must be handled before this method is called
                     throw IllegalStateException("Illegal projection kind:" + projectionKind)
             }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/UnderscoreChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/UnderscoreChecker.kt
index 8c4bcc024c2..4295bf2db75 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/UnderscoreChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/UnderscoreChecker.kt
@@ -20,10 +20,10 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
-import org.jetbrains.kotlin.psi.JetTypeParameterListOwner
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
+import org.jetbrains.kotlin.psi.KtTypeParameterListOwner
 
 object UnderscoreChecker : DeclarationChecker {
 
@@ -34,27 +34,27 @@ object UnderscoreChecker : DeclarationChecker {
         }
     }
 
-    fun checkNamed(declaration: JetNamedDeclaration, diagnosticHolder: DiagnosticSink) {
+    fun checkNamed(declaration: KtNamedDeclaration, diagnosticHolder: DiagnosticSink) {
         checkIdentifier(declaration.nameIdentifier, diagnosticHolder)
     }
 
     override fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext
     ) {
-        if (declaration is JetCallableDeclaration) {
+        if (declaration is KtCallableDeclaration) {
             for (parameter in declaration.valueParameters) {
                 checkNamed(parameter, diagnosticHolder)
             }
         }
-        if (declaration is JetTypeParameterListOwner) {
+        if (declaration is KtTypeParameterListOwner) {
             for (typeParameter in declaration.typeParameters) {
                 checkNamed(typeParameter, diagnosticHolder)
             }
         }
-        if (declaration !is JetNamedDeclaration) return
+        if (declaration !is KtNamedDeclaration) return
         checkNamed(declaration, diagnosticHolder)
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt
index 323f3c2a3cb..57e158c3c63 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt
@@ -29,12 +29,12 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.resolve.typeBinding.createTypeBinding
 import org.jetbrains.kotlin.resolve.typeBinding.createTypeBindingForReturnType
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.resolve.TopDownAnalysisContext
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetTypeReference
+import org.jetbrains.kotlin.types.KtType
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtTypeReference
 import org.jetbrains.kotlin.types.Variance.*
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
 import org.jetbrains.kotlin.descriptors.impl.PropertyAccessorDescriptorImpl
 import org.jetbrains.kotlin.resolve.source.getPsi
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
-import org.jetbrains.kotlin.psi.JetTypeParameterListOwner
+import org.jetbrains.kotlin.psi.KtTypeParameterListOwner
 import org.jetbrains.kotlin.resolve.BindingContext
 
 
@@ -56,7 +56,7 @@ class VarianceChecker(private val trace: BindingTrace) {
 
     private fun checkClasses(c: TopDownAnalysisContext) {
         for (jetClassOrObject in c.getDeclaredClasses()!!.keySet()) {
-            if (jetClassOrObject is JetClass) {
+            if (jetClassOrObject is KtClass) {
                 for (specifier in jetClassOrObject.getDelegationSpecifiers()) {
                     specifier.getTypeReference()?.checkTypePosition(trace.getBindingContext(), OUT_VARIANCE, trace)
                 }
@@ -74,7 +74,7 @@ class VarianceChecker(private val trace: BindingTrace) {
     }
 
     class VarianceConflictDiagnosticData(
-            val containingType: JetType,
+            val containingType: KtType,
             val typeParameter: TypeParameterDescriptor,
             val occurrencePosition: Variance
     )
@@ -85,7 +85,7 @@ class VarianceChecker(private val trace: BindingTrace) {
             if (isIrrelevant(descriptor) || descriptor.getVisibility() != Visibilities.PRIVATE) return
 
             val psiElement = descriptor.getSource().getPsi()
-            if (psiElement !is JetCallableDeclaration) return
+            if (psiElement !is KtCallableDeclaration) return
 
             if (!checkCallableDeclaration(trace.getBindingContext(), psiElement, descriptor, DiagnosticSink.DO_NOTHING)) {
                 recordPrivateToThis(descriptor)
@@ -116,7 +116,7 @@ class VarianceChecker(private val trace: BindingTrace) {
 
         private fun checkCallableDeclaration(
                 trace: BindingContext,
-                declaration: JetCallableDeclaration,
+                declaration: KtCallableDeclaration,
                 descriptor: CallableDescriptor,
                 diagnosticSink: DiagnosticSink
         ): Boolean {
@@ -137,7 +137,7 @@ class VarianceChecker(private val trace: BindingTrace) {
             return noError
         }
 
-        private fun JetTypeParameterListOwner.checkTypeParameters(
+        private fun KtTypeParameterListOwner.checkTypeParameters(
                 trace: BindingContext,
                 typePosition: Variance,
                 diagnosticSink: DiagnosticSink
@@ -152,13 +152,13 @@ class VarianceChecker(private val trace: BindingTrace) {
             return noError
         }
 
-        private fun JetTypeReference.checkTypePosition(trace: BindingContext, position: Variance, diagnosticSink: DiagnosticSink)
+        private fun KtTypeReference.checkTypePosition(trace: BindingContext, position: Variance, diagnosticSink: DiagnosticSink)
                 = createTypeBinding(trace)?.checkTypePosition(position, diagnosticSink)
 
         private fun TypeBinding<PsiElement>.checkTypePosition(position: Variance, diagnosticSink: DiagnosticSink)
                 = checkTypePosition(jetType, position, diagnosticSink)
 
-        private fun TypeBinding<PsiElement>.checkTypePosition(containingType: JetType, position: Variance, diagnosticSink: DiagnosticSink): Boolean {
+        private fun TypeBinding<PsiElement>.checkTypePosition(containingType: KtType, position: Variance, diagnosticSink: DiagnosticSink): Boolean {
             val classifierDescriptor = jetType.getConstructor().getDeclarationDescriptor()
             if (classifierDescriptor is TypeParameterDescriptor) {
                 val declarationVariance = classifierDescriptor.getVariance()
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/callableReferences/CallableReferencesResolutionUtils.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/callableReferences/CallableReferencesResolutionUtils.kt
index 341072fc9fc..13943fe6010 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/callableReferences/CallableReferencesResolutionUtils.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/callableReferences/CallableReferencesResolutionUtils.kt
@@ -26,9 +26,9 @@ import org.jetbrains.kotlin.diagnostics.Errors.CALLABLE_REFERENCE_LHS_NOT_A_CLAS
 import org.jetbrains.kotlin.diagnostics.Errors.EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED
 import org.jetbrains.kotlin.diagnostics.Errors.UNSUPPORTED
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetCallableReferenceExpression
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.ValueArgument
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.CallResolver
@@ -40,22 +40,22 @@ import org.jetbrains.kotlin.resolve.calls.context.TemporaryTraceAndCache
 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults
 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsUtil
 import org.jetbrains.kotlin.resolve.calls.util.CallMaker
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver
 import org.jetbrains.kotlin.resolve.scopes.utils.memberScopeAsFileScope
 import org.jetbrains.kotlin.resolve.source.toSourceElement
 import org.jetbrains.kotlin.types.FunctionPlaceholders
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
 import org.jetbrains.kotlin.utils.ThrowingList
 
 public fun resolveCallableReferenceReceiverType(
-        callableReferenceExpression: JetCallableReferenceExpression,
+        callableReferenceExpression: KtCallableReferenceExpression,
         context: ResolutionContext<*>,
         typeResolver: TypeResolver
-): JetType? =
+): KtType? =
         callableReferenceExpression.typeReference?.let {
             typeResolver.resolveType(context.scope, it, context.trace, false)
         }
@@ -70,7 +70,7 @@ private fun <D : CallableDescriptor> ResolveArgumentsMode.acceptResolution(resul
 }
 
 private fun resolvePossiblyAmbiguousCallableReference(
-        reference: JetSimpleNameExpression,
+        reference: KtSimpleNameExpression,
         receiver: ReceiverValue,
         context: ResolutionContext<*>,
         resolutionMode: ResolveArgumentsMode,
@@ -92,15 +92,15 @@ private fun resolvePossiblyAmbiguousCallableReference(
 private fun OverloadResolutionResults<*>.isSomething(): Boolean = !isNothing()
 
 public fun resolvePossiblyAmbiguousCallableReference(
-        callableReferenceExpression: JetCallableReferenceExpression,
-        lhsType: JetType?,
+        callableReferenceExpression: KtCallableReferenceExpression,
+        lhsType: KtType?,
         context: ResolutionContext<*>,
         resolutionMode: ResolveArgumentsMode,
         callResolver: CallResolver
 ): OverloadResolutionResults<CallableDescriptor>? {
     val reference = callableReferenceExpression.getCallableReference()
 
-    fun resolveInScope(traceTitle: String, staticScope: JetScope): OverloadResolutionResults<CallableDescriptor> {
+    fun resolveInScope(traceTitle: String, staticScope: KtScope): OverloadResolutionResults<CallableDescriptor> {
         val temporaryTraceAndCache = TemporaryTraceAndCache.create(context, traceTitle, reference)
         val newContext = context.replaceTraceAndCache(temporaryTraceAndCache).replaceScope(staticScope.memberScopeAsFileScope())
         val results = resolvePossiblyAmbiguousCallableReference(reference, ReceiverValue.NO_RECEIVER, newContext, resolutionMode, callResolver)
@@ -141,8 +141,8 @@ public fun resolvePossiblyAmbiguousCallableReference(
 }
 
 public fun resolveCallableReferenceTarget(
-        callableReferenceExpression: JetCallableReferenceExpression,
-        lhsType: JetType?,
+        callableReferenceExpression: KtCallableReferenceExpression,
+        lhsType: KtType?,
         context: ResolutionContext<*>,
         resolvedToSomething: BooleanArray,
         callResolver: CallResolver
@@ -164,9 +164,9 @@ public fun resolveCallableReferenceTarget(
 
 private fun createReflectionTypeForFunction(
         descriptor: FunctionDescriptor,
-        receiverType: JetType?,
+        receiverType: KtType?,
         reflectionTypes: ReflectionTypes
-): JetType? {
+): KtType? {
     val returnType = descriptor.getReturnType() ?: return null
     val valueParametersTypes = ExpressionTypingUtils.getValueParametersTypes(descriptor.getValueParameters())
     return reflectionTypes.getKFunctionType(Annotations.EMPTY, receiverType, valueParametersTypes, returnType)
@@ -174,13 +174,13 @@ private fun createReflectionTypeForFunction(
 
 private fun createReflectionTypeForProperty(
         descriptor: PropertyDescriptor,
-        receiverType: JetType?,
+        receiverType: KtType?,
         reflectionTypes: ReflectionTypes
-): JetType {
+): KtType {
     return reflectionTypes.getKPropertyType(Annotations.EMPTY, receiverType, descriptor.getType(), descriptor.isVar())
 }
 
-private fun bindFunctionReference(expression: JetCallableReferenceExpression, referenceType: JetType, context: ResolutionContext<*>) {
+private fun bindFunctionReference(expression: KtCallableReferenceExpression, referenceType: KtType, context: ResolutionContext<*>) {
     val functionDescriptor = AnonymousFunctionDescriptor(
             context.scope.ownerDescriptor,
             Annotations.EMPTY,
@@ -192,7 +192,7 @@ private fun bindFunctionReference(expression: JetCallableReferenceExpression, re
     context.trace.record(BindingContext.FUNCTION, expression, functionDescriptor)
 }
 
-private fun bindPropertyReference(expression: JetCallableReferenceExpression, referenceType: JetType, context: ResolutionContext<*>) {
+private fun bindPropertyReference(expression: KtCallableReferenceExpression, referenceType: KtType, context: ResolutionContext<*>) {
     val localVariable = LocalVariableDescriptor(context.scope.ownerDescriptor, Annotations.EMPTY, Name.special("<anonymous>"),
                                                 referenceType, /* mutable = */ false, expression.toSourceElement())
 
@@ -201,11 +201,11 @@ private fun bindPropertyReference(expression: JetCallableReferenceExpression, re
 
 private fun createReflectionTypeForCallableDescriptor(
         descriptor: CallableDescriptor,
-        lhsType: JetType?,
+        lhsType: KtType?,
         reflectionTypes: ReflectionTypes,
         trace: BindingTrace?,
-        reportOn: JetExpression?
-): JetType? {
+        reportOn: KtExpression?
+): KtType? {
     val extensionReceiver = descriptor.extensionReceiverParameter
     val dispatchReceiver = descriptor.dispatchReceiverParameter?.let { dispatchReceiver ->
         // See CallableDescriptor#getOwnerForEffectiveDispatchReceiverParameter
@@ -245,16 +245,16 @@ private fun createReflectionTypeForCallableDescriptor(
 public fun getReflectionTypeForCandidateDescriptor(
         descriptor: CallableDescriptor,
         reflectionTypes: ReflectionTypes
-): JetType? =
+): KtType? =
         createReflectionTypeForCallableDescriptor(descriptor, null, reflectionTypes, null, null)
 
 public fun createReflectionTypeForResolvedCallableReference(
-        reference: JetCallableReferenceExpression,
-        lhsType: JetType?,
+        reference: KtCallableReferenceExpression,
+        lhsType: KtType?,
         descriptor: CallableDescriptor,
         context: ResolutionContext<*>,
         reflectionTypes: ReflectionTypes
-): JetType? {
+): KtType? {
     val type = createReflectionTypeForCallableDescriptor(
             descriptor, lhsType, reflectionTypes, context.trace, reference.getCallableReference()
     ) ?: return null
@@ -270,15 +270,15 @@ public fun createReflectionTypeForResolvedCallableReference(
 }
 
 public fun getResolvedCallableReferenceShapeType(
-        reference: JetCallableReferenceExpression,
-        lhsType: JetType?,
+        reference: KtCallableReferenceExpression,
+        lhsType: KtType?,
         overloadResolutionResults: OverloadResolutionResults<CallableDescriptor>?,
         context: ResolutionContext<*>,
         expectedTypeUnknown: Boolean,
         reflectionTypes: ReflectionTypes,
         builtIns: KotlinBuiltIns,
         functionPlaceholders: FunctionPlaceholders
-): JetType? =
+): KtType? =
         when {
             overloadResolutionResults == null ->
                 null
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java
index fdb35ed910d..a25288a5978 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java
@@ -47,9 +47,9 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.QualifierReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.types.FunctionPlaceholders;
 import org.jetbrains.kotlin.types.FunctionPlaceholdersKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
 import org.jetbrains.kotlin.types.expressions.JetTypeInfo;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt;
@@ -57,7 +57,7 @@ import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt;
 import java.util.Collections;
 import java.util.List;
 
-import static org.jetbrains.kotlin.psi.JetPsiUtil.getLastElementDeparenthesized;
+import static org.jetbrains.kotlin.psi.KtPsiUtil.getLastElementDeparenthesized;
 import static org.jetbrains.kotlin.resolve.BindingContextUtils.getRecordedTypeInfo;
 import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS;
 import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS;
@@ -94,14 +94,14 @@ public class ArgumentTypeResolver {
     }
 
     public static boolean isSubtypeOfForArgumentType(
-            @NotNull JetType actualType,
-            @NotNull JetType expectedType
+            @NotNull KtType actualType,
+            @NotNull KtType expectedType
     ) {
         if (FunctionPlaceholdersKt.isFunctionPlaceholder(actualType)) {
-            JetType functionType = ConstraintSystemImplKt.createTypeForFunctionPlaceholder(actualType, expectedType);
-            return JetTypeChecker.DEFAULT.isSubtypeOf(functionType, expectedType);
+            KtType functionType = ConstraintSystemImplKt.createTypeForFunctionPlaceholder(actualType, expectedType);
+            return KotlinTypeChecker.DEFAULT.isSubtypeOf(functionType, expectedType);
         }
-        return JetTypeChecker.DEFAULT.isSubtypeOf(actualType, expectedType);
+        return KotlinTypeChecker.DEFAULT.isSubtypeOf(actualType, expectedType);
     }
 
     public void checkTypesWithNoCallee(@NotNull CallResolutionContext<?> context) {
@@ -115,8 +115,8 @@ public class ArgumentTypeResolver {
         if (context.checkArguments != CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS) return;
 
         for (ValueArgument valueArgument : context.call.getValueArguments()) {
-            JetExpression argumentExpression = valueArgument.getArgumentExpression();
-            if (argumentExpression != null && !(argumentExpression instanceof JetFunctionLiteralExpression)) {
+            KtExpression argumentExpression = valueArgument.getArgumentExpression();
+            if (argumentExpression != null && !(argumentExpression instanceof KtFunctionLiteralExpression)) {
                 checkArgumentTypeWithNoCallee(context, argumentExpression);
             }
         }
@@ -125,8 +125,8 @@ public class ArgumentTypeResolver {
             checkTypesForFunctionArgumentsWithNoCallee(context);
         }
 
-        for (JetTypeProjection typeProjection : context.call.getTypeArguments()) {
-            JetTypeReference typeReference = typeProjection.getTypeReference();
+        for (KtTypeProjection typeProjection : context.call.getTypeArguments()) {
+            KtTypeReference typeReference = typeProjection.getTypeReference();
             if (typeReference == null) {
                 context.trace.report(Errors.PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT.on(typeProjection));
             }
@@ -140,27 +140,27 @@ public class ArgumentTypeResolver {
         if (context.checkArguments != CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS) return;
 
         for (ValueArgument valueArgument : context.call.getValueArguments()) {
-            JetExpression argumentExpression = valueArgument.getArgumentExpression();
+            KtExpression argumentExpression = valueArgument.getArgumentExpression();
             if (argumentExpression != null && isFunctionLiteralArgument(argumentExpression, context)) {
                 checkArgumentTypeWithNoCallee(context, argumentExpression);
             }
         }
     }
 
-    private void checkArgumentTypeWithNoCallee(CallResolutionContext<?> context, JetExpression argumentExpression) {
+    private void checkArgumentTypeWithNoCallee(CallResolutionContext<?> context, KtExpression argumentExpression) {
         expressionTypingServices.getTypeInfo(argumentExpression, context.replaceExpectedType(NO_EXPECTED_TYPE));
         updateResultArgumentTypeIfNotDenotable(context, argumentExpression);
     }
 
     public static boolean isFunctionLiteralArgument(
-            @NotNull JetExpression expression, @NotNull ResolutionContext context
+            @NotNull KtExpression expression, @NotNull ResolutionContext context
     ) {
         return getFunctionLiteralArgumentIfAny(expression, context) != null;
     }
 
     @NotNull
-    public static JetFunction getFunctionLiteralArgument(
-            @NotNull JetExpression expression, @NotNull ResolutionContext context
+    public static KtFunction getFunctionLiteralArgument(
+            @NotNull KtExpression expression, @NotNull ResolutionContext context
     ) {
         assert isFunctionLiteralArgument(expression, context);
         //noinspection ConstantConditions
@@ -168,34 +168,34 @@ public class ArgumentTypeResolver {
     }
 
     @Nullable
-    public static JetFunction getFunctionLiteralArgumentIfAny(
-            @NotNull JetExpression expression, @NotNull ResolutionContext context
+    public static KtFunction getFunctionLiteralArgumentIfAny(
+            @NotNull KtExpression expression, @NotNull ResolutionContext context
     ) {
-        JetExpression deparenthesizedExpression = getLastElementDeparenthesized(expression, context.statementFilter);
-        if (deparenthesizedExpression instanceof JetFunctionLiteralExpression) {
-            return ((JetFunctionLiteralExpression) deparenthesizedExpression).getFunctionLiteral();
+        KtExpression deparenthesizedExpression = getLastElementDeparenthesized(expression, context.statementFilter);
+        if (deparenthesizedExpression instanceof KtFunctionLiteralExpression) {
+            return ((KtFunctionLiteralExpression) deparenthesizedExpression).getFunctionLiteral();
         }
-        if (deparenthesizedExpression instanceof JetFunction) {
-            return (JetFunction) deparenthesizedExpression;
+        if (deparenthesizedExpression instanceof KtFunction) {
+            return (KtFunction) deparenthesizedExpression;
         }
         return null;
     }
 
     @Nullable
-    public static JetCallableReferenceExpression getCallableReferenceExpressionIfAny(
-            @NotNull JetExpression expression,
+    public static KtCallableReferenceExpression getCallableReferenceExpressionIfAny(
+            @NotNull KtExpression expression,
             @NotNull CallResolutionContext<?> context
     ) {
-        JetExpression deparenthesizedExpression = getLastElementDeparenthesized(expression, context.statementFilter);
-        if (deparenthesizedExpression instanceof JetCallableReferenceExpression) {
-            return (JetCallableReferenceExpression) deparenthesizedExpression;
+        KtExpression deparenthesizedExpression = getLastElementDeparenthesized(expression, context.statementFilter);
+        if (deparenthesizedExpression instanceof KtCallableReferenceExpression) {
+            return (KtCallableReferenceExpression) deparenthesizedExpression;
         }
         return null;
     }
 
     @NotNull
     public JetTypeInfo getArgumentTypeInfo(
-            @Nullable JetExpression expression,
+            @Nullable KtExpression expression,
             @NotNull CallResolutionContext<?> context,
             @NotNull ResolveArgumentsMode resolveArgumentsMode
     ) {
@@ -203,12 +203,12 @@ public class ArgumentTypeResolver {
             return TypeInfoFactoryKt.noTypeInfo(context);
         }
 
-        JetFunction functionLiteralArgument = getFunctionLiteralArgumentIfAny(expression, context);
+        KtFunction functionLiteralArgument = getFunctionLiteralArgumentIfAny(expression, context);
         if (functionLiteralArgument != null) {
             return getFunctionLiteralTypeInfo(expression, functionLiteralArgument, context, resolveArgumentsMode);
         }
 
-        JetCallableReferenceExpression callableReferenceExpression = getCallableReferenceExpressionIfAny(expression, context);
+        KtCallableReferenceExpression callableReferenceExpression = getCallableReferenceExpressionIfAny(expression, context);
         if (callableReferenceExpression != null) {
             return getCallableReferenceTypeInfo(expression, callableReferenceExpression, context, resolveArgumentsMode);
         }
@@ -225,25 +225,25 @@ public class ArgumentTypeResolver {
 
     @NotNull
     public JetTypeInfo getCallableReferenceTypeInfo(
-            @NotNull JetExpression expression,
-            @NotNull JetCallableReferenceExpression callableReferenceExpression,
+            @NotNull KtExpression expression,
+            @NotNull KtCallableReferenceExpression callableReferenceExpression,
             @NotNull CallResolutionContext<?> context,
             @NotNull ResolveArgumentsMode resolveArgumentsMode
     ) {
         if (resolveArgumentsMode == SHAPE_FUNCTION_ARGUMENTS) {
-            JetType type = getShapeTypeOfCallableReference(callableReferenceExpression, context, true);
+            KtType type = getShapeTypeOfCallableReference(callableReferenceExpression, context, true);
             return TypeInfoFactoryKt.createTypeInfo(type);
         }
         return expressionTypingServices.getTypeInfo(expression, context.replaceContextDependency(INDEPENDENT));
     }
 
     @Nullable
-    public JetType getShapeTypeOfCallableReference(
-            @NotNull JetCallableReferenceExpression callableReferenceExpression,
+    public KtType getShapeTypeOfCallableReference(
+            @NotNull KtCallableReferenceExpression callableReferenceExpression,
             @NotNull CallResolutionContext<?> context,
             boolean expectedTypeIsUnknown
     ) {
-        JetType receiverType =
+        KtType receiverType =
                 CallableReferencesResolutionUtilsKt.resolveCallableReferenceReceiverType(callableReferenceExpression, context, typeResolver);
         OverloadResolutionResults<CallableDescriptor> overloadResolutionResults =
                 CallableReferencesResolutionUtilsKt.resolvePossiblyAmbiguousCallableReference(
@@ -256,42 +256,42 @@ public class ArgumentTypeResolver {
 
     @NotNull
     public JetTypeInfo getFunctionLiteralTypeInfo(
-            @NotNull JetExpression expression,
-            @NotNull JetFunction functionLiteral,
+            @NotNull KtExpression expression,
+            @NotNull KtFunction functionLiteral,
             @NotNull CallResolutionContext<?> context,
             @NotNull ResolveArgumentsMode resolveArgumentsMode
     ) {
         if (resolveArgumentsMode == SHAPE_FUNCTION_ARGUMENTS) {
-            JetType type = getShapeTypeOfFunctionLiteral(functionLiteral, context.scope, context.trace, true);
+            KtType type = getShapeTypeOfFunctionLiteral(functionLiteral, context.scope, context.trace, true);
             return TypeInfoFactoryKt.createTypeInfo(type, context);
         }
         return expressionTypingServices.getTypeInfo(expression, context.replaceContextDependency(INDEPENDENT));
     }
 
     @Nullable
-    public JetType getShapeTypeOfFunctionLiteral(
-            @NotNull JetFunction function,
+    public KtType getShapeTypeOfFunctionLiteral(
+            @NotNull KtFunction function,
             @NotNull LexicalScope scope,
             @NotNull BindingTrace trace,
             boolean expectedTypeIsUnknown
     ) {
-        boolean isFunctionLiteral = function instanceof JetFunctionLiteral;
+        boolean isFunctionLiteral = function instanceof KtFunctionLiteral;
         if (function.getValueParameterList() == null && isFunctionLiteral) {
             return expectedTypeIsUnknown
                    ? functionPlaceholders
-                           .createFunctionPlaceholderType(Collections.<JetType>emptyList(), /* hasDeclaredArguments = */ false)
-                   : builtIns.getFunctionType(Annotations.Companion.getEMPTY(), null, Collections.<JetType>emptyList(), DONT_CARE);
+                           .createFunctionPlaceholderType(Collections.<KtType>emptyList(), /* hasDeclaredArguments = */ false)
+                   : builtIns.getFunctionType(Annotations.Companion.getEMPTY(), null, Collections.<KtType>emptyList(), DONT_CARE);
         }
-        List<JetParameter> valueParameters = function.getValueParameters();
+        List<KtParameter> valueParameters = function.getValueParameters();
         TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(
                 trace, "trace to resolve function literal parameter types");
-        List<JetType> parameterTypes = Lists.newArrayList();
-        for (JetParameter parameter : valueParameters) {
+        List<KtType> parameterTypes = Lists.newArrayList();
+        for (KtParameter parameter : valueParameters) {
             parameterTypes.add(resolveTypeRefWithDefault(parameter.getTypeReference(), scope, temporaryTrace, DONT_CARE));
         }
-        JetType returnType = resolveTypeRefWithDefault(function.getTypeReference(), scope, temporaryTrace, DONT_CARE);
+        KtType returnType = resolveTypeRefWithDefault(function.getTypeReference(), scope, temporaryTrace, DONT_CARE);
         assert returnType != null;
-        JetType receiverType = resolveTypeRefWithDefault(function.getReceiverTypeReference(), scope, temporaryTrace, null);
+        KtType receiverType = resolveTypeRefWithDefault(function.getReceiverTypeReference(), scope, temporaryTrace, null);
 
         return expectedTypeIsUnknown && isFunctionLiteral
                ? functionPlaceholders.createFunctionPlaceholderType(parameterTypes, /* hasDeclaredArguments = */ true)
@@ -299,11 +299,11 @@ public class ArgumentTypeResolver {
     }
 
     @Nullable
-    public JetType resolveTypeRefWithDefault(
-            @Nullable JetTypeReference returnTypeRef,
+    public KtType resolveTypeRefWithDefault(
+            @Nullable KtTypeReference returnTypeRef,
             @NotNull LexicalScope scope,
             @NotNull BindingTrace trace,
-            @Nullable JetType defaultValue
+            @Nullable KtType defaultValue
     ) {
         if (returnTypeRef != null) {
             return typeResolver.resolveType(scope, returnTypeRef, trace, true);
@@ -336,7 +336,7 @@ public class ArgumentTypeResolver {
         infoForArguments.setInitialDataFlowInfo(initialDataFlowInfo);
 
         for (ValueArgument argument : call.getValueArguments()) {
-            JetExpression expression = argument.getArgumentExpression();
+            KtExpression expression = argument.getArgumentExpression();
             if (expression == null) continue;
 
             CallResolutionContext<?> newContext = context.replaceDataFlowInfo(infoForArguments.getInfo(argument));
@@ -347,15 +347,15 @@ public class ArgumentTypeResolver {
     }
 
     @Nullable
-    public JetType updateResultArgumentTypeIfNotDenotable(
+    public KtType updateResultArgumentTypeIfNotDenotable(
             @NotNull ResolutionContext context,
-            @NotNull JetExpression expression
+            @NotNull KtExpression expression
     ) {
-        JetType type = context.trace.getType(expression);
+        KtType type = context.trace.getType(expression);
         if (type != null && !type.getConstructor().isDenotable()) {
             if (type.getConstructor() instanceof IntegerValueTypeConstructor) {
                 IntegerValueTypeConstructor constructor = (IntegerValueTypeConstructor) type.getConstructor();
-                JetType primitiveType = TypeUtils.getPrimitiveNumberType(constructor, context.expectedType);
+                KtType primitiveType = TypeUtils.getPrimitiveNumberType(constructor, context.expectedType);
                 constantExpressionEvaluator.updateNumberType(primitiveType, expression, context.statementFilter, context.trace);
                 return primitiveType;
             }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt
index 2d8ba239f55..daa23d184ed 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt
@@ -42,7 +42,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy
 import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.expressions.DataFlowAnalyzer
 import java.util.*
@@ -136,7 +136,7 @@ public class CallCompleter(
     }
 
     private fun <D : CallableDescriptor> MutableResolvedCall<D>.completeConstraintSystem(
-            expectedType: JetType,
+            expectedType: KtType,
             trace: BindingTrace
     ) {
         fun updateSystemIfSuccessful(update: (ConstraintSystemImpl) -> Boolean) {
@@ -237,10 +237,10 @@ public class CallCompleter(
         if (valueArgument.isExternal()) return
 
         val expression = valueArgument.getArgumentExpression() ?: return
-        val deparenthesized = JetPsiUtil.getLastElementDeparenthesized(expression, context.statementFilter) ?: return
+        val deparenthesized = KtPsiUtil.getLastElementDeparenthesized(expression, context.statementFilter) ?: return
 
         val recordedType = expression.let { context.trace.getType(it) }
-        var updatedType: JetType? = recordedType
+        var updatedType: KtType? = recordedType
 
         val results = completeCallForArgument(deparenthesized, context)
         if (results != null && results.isSingleResult()) {
@@ -273,7 +273,7 @@ public class CallCompleter(
     }
 
     private fun completeCallForArgument(
-            expression: JetExpression,
+            expression: KtExpression,
             context: BasicCallResolutionContext
     ): OverloadResolutionResultsImpl<*>? {
         val cachedData = getResolutionResultsCachedData(expression, context) ?: return null
@@ -288,24 +288,24 @@ public class CallCompleter(
     }
 
     private fun updateRecordedTypeForArgument(
-            updatedType: JetType?,
-            recordedType: JetType?,
-            argumentExpression: JetExpression,
+            updatedType: KtType?,
+            recordedType: KtType?,
+            argumentExpression: KtExpression,
             trace: BindingTrace
-    ): JetType? {
+    ): KtType? {
         //workaround for KT-8218
         if ((!ErrorUtils.containsErrorType(recordedType) && recordedType == updatedType) || updatedType == null) return updatedType
 
-        fun deparenthesizeOrGetSelector(expression: JetExpression?): JetExpression? {
-            val deparenthesized = JetPsiUtil.deparenthesizeOnce(expression)
+        fun deparenthesizeOrGetSelector(expression: KtExpression?): KtExpression? {
+            val deparenthesized = KtPsiUtil.deparenthesizeOnce(expression)
             if (deparenthesized != expression) return deparenthesized
 
-            if (expression is JetQualifiedExpression) return expression.getSelectorExpression()
+            if (expression is KtQualifiedExpression) return expression.getSelectorExpression()
             return null
         }
 
-        val expressions = ArrayList<JetExpression>()
-        var expression: JetExpression? = argumentExpression
+        val expressions = ArrayList<KtExpression>()
+        var expression: KtExpression? = argumentExpression
         while (expression != null) {
             expressions.add(expression)
             expression = deparenthesizeOrGetSelector(expression)
@@ -313,7 +313,7 @@ public class CallCompleter(
 
         var shouldBeMadeNullable: Boolean = false
         expressions.asReversed().forEach { expression ->
-            if (!(expression is JetParenthesizedExpression || expression is JetLabeledExpression || expression is JetAnnotatedExpression)) {
+            if (!(expression is KtParenthesizedExpression || expression is KtLabeledExpression || expression is KtAnnotatedExpression)) {
                 shouldBeMadeNullable = hasNecessarySafeCall(expression, trace)
             }
             BindingContextUtils.updateRecordedType(updatedType, expression, trace, shouldBeMadeNullable)
@@ -321,12 +321,12 @@ public class CallCompleter(
         return trace.getType(argumentExpression)
     }
 
-    private fun hasNecessarySafeCall(expression: JetExpression, trace: BindingTrace): Boolean {
+    private fun hasNecessarySafeCall(expression: KtExpression, trace: BindingTrace): Boolean {
         // We are interested in type of the last call:
         // 'a.b?.foo()' is safe call, but 'a?.b.foo()' is not.
         // Since receiver is 'a.b' and selector is 'foo()',
         // we can only check if an expression is safe call.
-        if (expression !is JetSafeQualifiedExpression) return false
+        if (expression !is KtSafeQualifiedExpression) return false
 
         //If a receiver type is not null, then this safe expression is useless, and we don't need to make the result type nullable.
         val expressionType = trace.getType(expression.getReceiverExpression())
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java
index 23ee1153f4c..0c9787d86da 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java
@@ -22,7 +22,7 @@ import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluat
 import org.jetbrains.kotlin.resolve.scopes.receivers.*;
 import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.kotlin.types.expressions.DataFlowAnalyzer;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
@@ -88,7 +88,7 @@ public class CallExpressionResolver {
 
     @Nullable
     public ResolvedCall<FunctionDescriptor> getResolvedCallForFunction(
-            @NotNull Call call, @NotNull JetExpression callExpression,
+            @NotNull Call call, @NotNull KtExpression callExpression,
             @NotNull ResolutionContext context, @NotNull CheckArgumentTypesMode checkArguments,
             @NotNull boolean[] result
     ) {
@@ -103,8 +103,8 @@ public class CallExpressionResolver {
     }
 
     @Nullable
-    private JetType getVariableType(
-            @NotNull JetSimpleNameExpression nameExpression, @NotNull ReceiverValue receiver,
+    private KtType getVariableType(
+            @NotNull KtSimpleNameExpression nameExpression, @NotNull ReceiverValue receiver,
             @Nullable ASTNode callOperationNode, @NotNull ExpressionTypingContext context, @NotNull boolean[] result
     ) {
         TemporaryTraceAndCache temporaryForVariable = TemporaryTraceAndCache.create(
@@ -116,7 +116,7 @@ public class CallExpressionResolver {
         OverloadResolutionResults<VariableDescriptor> resolutionResult = callResolver.resolveSimpleProperty(contextForVariable);
 
         // if the expression is a receiver in a qualified expression, it should be resolved after the selector is resolved
-        boolean isLHSOfDot = JetPsiUtil.isLHSOfDot(nameExpression);
+        boolean isLHSOfDot = KtPsiUtil.isLHSOfDot(nameExpression);
         if (!resolutionResult.isNothing() && resolutionResult.getResultCode() != OverloadResolutionResults.Code.CANDIDATES_WITH_WRONG_RECEIVER) {
             boolean isQualifier = isLHSOfDot && resolutionResult.isSingleResult()
                                   && resolutionResult.getResultingDescriptor() instanceof FakeCallableDescriptorForObject;
@@ -142,14 +142,14 @@ public class CallExpressionResolver {
 
     @NotNull
     public JetTypeInfo getSimpleNameExpressionTypeInfo(
-            @NotNull JetSimpleNameExpression nameExpression, @NotNull ReceiverValue receiver,
+            @NotNull KtSimpleNameExpression nameExpression, @NotNull ReceiverValue receiver,
             @Nullable ASTNode callOperationNode, @NotNull ExpressionTypingContext context
     ) {
         boolean[] result = new boolean[1];
 
         TemporaryTraceAndCache temporaryForVariable = TemporaryTraceAndCache.create(
                 context, "trace to resolve as variable", nameExpression);
-        JetType type =
+        KtType type =
                 getVariableType(nameExpression, receiver, callOperationNode, context.replaceTraceAndCache(temporaryForVariable), result);
         // TODO: for a safe call, it's necessary to set receiver != null here, as inside ArgumentTypeResolver.analyzeArgumentsAndRecordTypes
         // Unfortunately it provokes problems with x?.y!!.foo() with the following x!!.bar():
@@ -181,7 +181,7 @@ public class CallExpressionResolver {
 
     @NotNull
     public JetTypeInfo getCallExpressionTypeInfo(
-            @NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver,
+            @NotNull KtCallExpression callExpression, @NotNull ReceiverValue receiver,
             @Nullable ASTNode callOperationNode, @NotNull ExpressionTypingContext context
     ) {
         JetTypeInfo typeInfo = getCallExpressionTypeInfoWithoutFinalTypeCheck(callExpression, receiver, callOperationNode, context);
@@ -197,7 +197,7 @@ public class CallExpressionResolver {
      */
     @NotNull
     public JetTypeInfo getCallExpressionTypeInfoWithoutFinalTypeCheck(
-            @NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver,
+            @NotNull KtCallExpression callExpression, @NotNull ReceiverValue receiver,
             @Nullable ASTNode callOperationNode, @NotNull ExpressionTypingContext context
     ) {
         boolean[] result = new boolean[1];
@@ -236,7 +236,7 @@ public class CallExpressionResolver {
                 }
             }
 
-            JetType type = functionDescriptor.getReturnType();
+            KtType type = functionDescriptor.getReturnType();
             // Extracting jump out possible and jump point flow info from arguments, if any
             List<? extends ValueArgument> arguments = callExpression.getValueArguments();
             DataFlowInfo resultFlowInfo = resolvedCall.getDataFlowInfoForArguments().getResultInfo();
@@ -253,12 +253,12 @@ public class CallExpressionResolver {
             return TypeInfoFactoryKt.createTypeInfo(type, resultFlowInfo, jumpOutPossible, jumpFlowInfo);
         }
 
-        JetExpression calleeExpression = callExpression.getCalleeExpression();
-        if (calleeExpression instanceof JetSimpleNameExpression && callExpression.getTypeArgumentList() == null) {
+        KtExpression calleeExpression = callExpression.getCalleeExpression();
+        if (calleeExpression instanceof KtSimpleNameExpression && callExpression.getTypeArgumentList() == null) {
             TemporaryTraceAndCache temporaryForVariable = TemporaryTraceAndCache.create(
                     context, "trace to resolve as variable with 'invoke' call", callExpression);
-            JetType type = getVariableType((JetSimpleNameExpression) calleeExpression, receiver, callOperationNode,
-                                           context.replaceTraceAndCache(temporaryForVariable), result);
+            KtType type = getVariableType((KtSimpleNameExpression) calleeExpression, receiver, callOperationNode,
+                                          context.replaceTraceAndCache(temporaryForVariable), result);
             Qualifier qualifier = temporaryForVariable.trace.get(BindingContext.QUALIFIER, calleeExpression);
             if (result[0] && (qualifier == null || qualifier.getPackageView() == null)) {
                 temporaryForVariable.commit();
@@ -271,16 +271,16 @@ public class CallExpressionResolver {
         return TypeInfoFactoryKt.noTypeInfo(context);
     }
 
-    private static boolean canInstantiateAnnotationClass(@NotNull JetCallExpression expression, @NotNull BindingTrace trace) {
+    private static boolean canInstantiateAnnotationClass(@NotNull KtCallExpression expression, @NotNull BindingTrace trace) {
         //noinspection unchecked
-        PsiElement parent = PsiTreeUtil.getParentOfType(expression, JetValueArgument.class, JetParameter.class);
-        if (parent instanceof JetValueArgument) {
-            return PsiTreeUtil.getParentOfType(parent, JetAnnotationEntry.class) != null;
+        PsiElement parent = PsiTreeUtil.getParentOfType(expression, KtValueArgument.class, KtParameter.class);
+        if (parent instanceof KtValueArgument) {
+            return PsiTreeUtil.getParentOfType(parent, KtAnnotationEntry.class) != null;
         }
-        else if (parent instanceof JetParameter) {
-            JetClass jetClass = PsiTreeUtil.getParentOfType(parent, JetClass.class);
-            if (jetClass != null) {
-                DeclarationDescriptor descriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, jetClass);
+        else if (parent instanceof KtParameter) {
+            KtClass ktClass = PsiTreeUtil.getParentOfType(parent, KtClass.class);
+            if (ktClass != null) {
+                DeclarationDescriptor descriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, ktClass);
                 return DescriptorUtils.isAnnotationClass(descriptor);
             }
         }
@@ -291,15 +291,15 @@ public class CallExpressionResolver {
     private JetTypeInfo getSelectorReturnTypeInfo(
             @NotNull ReceiverValue receiver,
             @Nullable ASTNode callOperationNode,
-            @Nullable JetExpression selectorExpression,
+            @Nullable KtExpression selectorExpression,
             @NotNull ExpressionTypingContext context
     ) {
-        if (selectorExpression instanceof JetCallExpression) {
-            return getCallExpressionTypeInfoWithoutFinalTypeCheck((JetCallExpression) selectorExpression, receiver,
+        if (selectorExpression instanceof KtCallExpression) {
+            return getCallExpressionTypeInfoWithoutFinalTypeCheck((KtCallExpression) selectorExpression, receiver,
                                                                   callOperationNode, context);
         }
-        else if (selectorExpression instanceof JetSimpleNameExpression) {
-            return getSimpleNameExpressionTypeInfo((JetSimpleNameExpression) selectorExpression, receiver, callOperationNode, context);
+        else if (selectorExpression instanceof KtSimpleNameExpression) {
+            return getSimpleNameExpressionTypeInfo((KtSimpleNameExpression) selectorExpression, receiver, callOperationNode, context);
         }
         else if (selectorExpression != null) {
             context.trace.report(ILLEGAL_SELECTOR.on(selectorExpression, selectorExpression.getText()));
@@ -339,18 +339,18 @@ public class CallExpressionResolver {
      */
     @NotNull
     public JetTypeInfo getQualifiedExpressionTypeInfo(
-            @NotNull JetQualifiedExpression expression, @NotNull ExpressionTypingContext context
+            @NotNull KtQualifiedExpression expression, @NotNull ExpressionTypingContext context
     ) {
         // TODO : functions as values
-        JetExpression selectorExpression = expression.getSelectorExpression();
-        JetExpression receiverExpression = expression.getReceiverExpression();
-        boolean safeCall = (expression.getOperationSign() == JetTokens.SAFE_ACCESS);
+        KtExpression selectorExpression = expression.getSelectorExpression();
+        KtExpression receiverExpression = expression.getReceiverExpression();
+        boolean safeCall = (expression.getOperationSign() == KtTokens.SAFE_ACCESS);
         ResolutionContext contextForReceiver = context.replaceExpectedType(NO_EXPECTED_TYPE).
                 replaceContextDependency(INDEPENDENT).
                 replaceInsideCallChain(true); // Enter call chain
         // Visit receiver (x in x.y or x?.z) here. Recursion is possible.
         JetTypeInfo receiverTypeInfo = expressionTypingServices.getTypeInfo(receiverExpression, contextForReceiver);
-        JetType receiverType = receiverTypeInfo.getType();
+        KtType receiverType = receiverTypeInfo.getType();
         QualifierReceiver qualifierReceiver = (QualifierReceiver) context.trace.get(BindingContext.QUALIFIER, receiverExpression);
 
         if (receiverType == null) receiverType = ErrorUtils.createErrorType("Type for " + expression.getText());
@@ -363,7 +363,7 @@ public class CallExpressionResolver {
         // Visit selector (y in x.y) here. Recursion is also possible.
         JetTypeInfo selectorReturnTypeInfo = getSelectorReturnTypeInfo(
                 receiver, expression.getOperationTokenNode(), selectorExpression, context);
-        JetType selectorReturnType = selectorReturnTypeInfo.getType();
+        KtType selectorReturnType = selectorReturnTypeInfo.getType();
 
         resolveDeferredReceiverInQualifiedExpression(qualifierReceiver, expression, context);
         checkNestedClassAccess(expression, context);
@@ -436,23 +436,23 @@ public class CallExpressionResolver {
 
     private void resolveDeferredReceiverInQualifiedExpression(
             @Nullable QualifierReceiver qualifierReceiver,
-            @NotNull JetQualifiedExpression qualifiedExpression,
+            @NotNull KtQualifiedExpression qualifiedExpression,
             @NotNull ExpressionTypingContext context
     ) {
         if (qualifierReceiver == null) return;
-        JetExpression calleeExpression =
-                JetPsiUtil.deparenthesize(CallUtilKt.getCalleeExpressionIfAny(qualifiedExpression.getSelectorExpression()));
+        KtExpression calleeExpression =
+                KtPsiUtil.deparenthesize(CallUtilKt.getCalleeExpressionIfAny(qualifiedExpression.getSelectorExpression()));
         DeclarationDescriptor selectorDescriptor =
-                calleeExpression instanceof JetReferenceExpression
-                ? context.trace.get(BindingContext.REFERENCE_TARGET, (JetReferenceExpression) calleeExpression) : null;
+                calleeExpression instanceof KtReferenceExpression
+                ? context.trace.get(BindingContext.REFERENCE_TARGET, (KtReferenceExpression) calleeExpression) : null;
         QualifierKt.resolveAsReceiverInQualifiedExpression(qualifierReceiver, context, symbolUsageValidator, selectorDescriptor);
     }
 
     private static void checkNestedClassAccess(
-            @NotNull JetQualifiedExpression expression,
+            @NotNull KtQualifiedExpression expression,
             @NotNull ExpressionTypingContext context
     ) {
-        JetExpression selectorExpression = expression.getSelectorExpression();
+        KtExpression selectorExpression = expression.getSelectorExpression();
         if (selectorExpression == null) return;
 
         // A.B - if B is a nested class accessed by outer class, 'A' and 'A.B' were marked as qualifiers
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
index 9d7de869589..2161ecd824a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
@@ -26,7 +26,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
 import org.jetbrains.kotlin.psi.*;
@@ -51,7 +51,7 @@ import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
@@ -137,12 +137,12 @@ public class CallResolver {
 
     @NotNull
     public OverloadResolutionResults<VariableDescriptor> resolveSimpleProperty(@NotNull BasicCallResolutionContext context) {
-        JetExpression calleeExpression = context.call.getCalleeExpression();
-        assert calleeExpression instanceof JetSimpleNameExpression;
-        JetSimpleNameExpression nameExpression = (JetSimpleNameExpression) calleeExpression;
+        KtExpression calleeExpression = context.call.getCalleeExpression();
+        assert calleeExpression instanceof KtSimpleNameExpression;
+        KtSimpleNameExpression nameExpression = (KtSimpleNameExpression) calleeExpression;
         Name referencedName = nameExpression.getReferencedNameAsName();
         CallableDescriptorCollectors<VariableDescriptor> callableDescriptorCollectors;
-        if (nameExpression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER) {
+        if (nameExpression.getReferencedNameElementType() == KtTokens.FIELD_IDENTIFIER) {
             referencedName = Name.identifier(referencedName.asString().substring(1));
             callableDescriptorCollectors = CallableDescriptorCollectors.PROPERTIES;
         }
@@ -156,7 +156,7 @@ public class CallResolver {
 
     @NotNull
     public OverloadResolutionResults<CallableDescriptor> resolveCallForMember(
-            @NotNull JetSimpleNameExpression nameExpression,
+            @NotNull KtSimpleNameExpression nameExpression,
             @NotNull BasicCallResolutionContext context
     ) {
         return computeTasksAndResolveCall(
@@ -168,7 +168,7 @@ public class CallResolver {
     public OverloadResolutionResults<FunctionDescriptor> resolveCallWithGivenName(
             @NotNull ExpressionTypingContext context,
             @NotNull Call call,
-            @NotNull JetReferenceExpression functionReference,
+            @NotNull KtReferenceExpression functionReference,
             @NotNull Name name
     ) {
         BasicCallResolutionContext callResolutionContext = BasicCallResolutionContext.create(context, call, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS);
@@ -191,7 +191,7 @@ public class CallResolver {
     private <D extends CallableDescriptor, F extends D> OverloadResolutionResults<F> computeTasksAndResolveCall(
             @NotNull BasicCallResolutionContext context,
             @NotNull Name name,
-            @NotNull JetReferenceExpression referenceExpression,
+            @NotNull KtReferenceExpression referenceExpression,
             @NotNull CallableDescriptorCollectors<D> collectors,
             @NotNull CallTransformer<D, F> callTransformer
     ) {
@@ -219,7 +219,7 @@ public class CallResolver {
     @NotNull
     private <D extends CallableDescriptor, F extends D> OverloadResolutionResults<F> computeTasksFromCandidatesAndResolvedCall(
             @NotNull BasicCallResolutionContext context,
-            @NotNull JetReferenceExpression referenceExpression,
+            @NotNull KtReferenceExpression referenceExpression,
             @NotNull Collection<ResolutionCandidate<D>> candidates,
             @NotNull CallTransformer<D, F> callTransformer
     ) {
@@ -248,7 +248,7 @@ public class CallResolver {
     public OverloadResolutionResults<FunctionDescriptor> resolveBinaryCall(
             ExpressionTypingContext context,
             ExpressionReceiver receiver,
-            JetBinaryExpression binaryExpression,
+            KtBinaryExpression binaryExpression,
             Name name
     ) {
         return resolveCallWithGivenName(
@@ -264,7 +264,7 @@ public class CallResolver {
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull Call call,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull DataFlowInfo dataFlowInfo,
             boolean isAnnotationContext
     ) {
@@ -283,27 +283,27 @@ public class CallResolver {
         Call.CallType callType = context.call.getCallType();
         if (callType == Call.CallType.ARRAY_GET_METHOD || callType == Call.CallType.ARRAY_SET_METHOD) {
             Name name = Name.identifier(callType == Call.CallType.ARRAY_GET_METHOD ? "get" : "set");
-            JetArrayAccessExpression arrayAccessExpression = (JetArrayAccessExpression) context.call.getCallElement();
+            KtArrayAccessExpression arrayAccessExpression = (KtArrayAccessExpression) context.call.getCallElement();
             return computeTasksAndResolveCall(
                     context, name, arrayAccessExpression,
                     CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, CallTransformer.FUNCTION_CALL_TRANSFORMER);
         }
 
-        JetExpression calleeExpression = context.call.getCalleeExpression();
-        if (calleeExpression instanceof JetSimpleNameExpression) {
-            JetSimpleNameExpression expression = (JetSimpleNameExpression) calleeExpression;
+        KtExpression calleeExpression = context.call.getCalleeExpression();
+        if (calleeExpression instanceof KtSimpleNameExpression) {
+            KtSimpleNameExpression expression = (KtSimpleNameExpression) calleeExpression;
             return computeTasksAndResolveCall(
                     context, expression.getReferencedNameAsName(), expression,
                     CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, CallTransformer.FUNCTION_CALL_TRANSFORMER);
         }
-        else if (calleeExpression instanceof JetConstructorCalleeExpression) {
-            return resolveCallForConstructor(context, (JetConstructorCalleeExpression) calleeExpression);
+        else if (calleeExpression instanceof KtConstructorCalleeExpression) {
+            return resolveCallForConstructor(context, (KtConstructorCalleeExpression) calleeExpression);
         }
-        else if (calleeExpression instanceof JetConstructorDelegationReferenceExpression) {
-            JetConstructorDelegationCall delegationCall = (JetConstructorDelegationCall) context.call.getCallElement();
+        else if (calleeExpression instanceof KtConstructorDelegationReferenceExpression) {
+            KtConstructorDelegationCall delegationCall = (KtConstructorDelegationCall) context.call.getCallElement();
             DeclarationDescriptor container = context.scope.getOwnerDescriptor();
             assert container instanceof ConstructorDescriptor : "Trying to resolve JetConstructorDelegationCall not in constructor. scope.ownerDescriptor = " + container;
-            return resolveConstructorDelegationCall(context, delegationCall, (JetConstructorDelegationReferenceExpression) calleeExpression,
+            return resolveConstructorDelegationCall(context, delegationCall, (KtConstructorDelegationReferenceExpression) calleeExpression,
                                                     (ConstructorDescriptor) container);
         }
         else if (calleeExpression == null) {
@@ -311,16 +311,16 @@ public class CallResolver {
         }
 
         // Here we handle the case where the callee expression must be something of type function, e.g. (foo.bar())(1, 2)
-        JetType expectedType = NO_EXPECTED_TYPE;
-        if (calleeExpression instanceof JetFunctionLiteralExpression) {
-            int parameterNumber = ((JetFunctionLiteralExpression) calleeExpression).getValueParameters().size();
-            List<JetType> parameterTypes = new ArrayList<JetType>(parameterNumber);
+        KtType expectedType = NO_EXPECTED_TYPE;
+        if (calleeExpression instanceof KtFunctionLiteralExpression) {
+            int parameterNumber = ((KtFunctionLiteralExpression) calleeExpression).getValueParameters().size();
+            List<KtType> parameterTypes = new ArrayList<KtType>(parameterNumber);
             for (int i = 0; i < parameterNumber; i++) {
                 parameterTypes.add(NO_EXPECTED_TYPE);
             }
             expectedType = builtIns.getFunctionType(Annotations.Companion.getEMPTY(), null, parameterTypes, context.expectedType);
         }
-        JetType calleeType = expressionTypingServices.safeGetType(
+        KtType calleeType = expressionTypingServices.safeGetType(
                 context.scope, calleeExpression, expectedType, context.dataFlowInfo, context.trace);
         ExpressionReceiver expressionReceiver = new ExpressionReceiver(calleeExpression, calleeType);
 
@@ -331,19 +331,19 @@ public class CallResolver {
 
     private OverloadResolutionResults<FunctionDescriptor> resolveCallForConstructor(
             @NotNull BasicCallResolutionContext context,
-            @NotNull JetConstructorCalleeExpression expression
+            @NotNull KtConstructorCalleeExpression expression
     ) {
         assert !context.call.getExplicitReceiver().exists() :
                 "Constructor can't be invoked with explicit receiver: " + context.call.getCallElement().getText();
 
         context.trace.record(BindingContext.LEXICAL_SCOPE, context.call.getCallElement(), context.scope);
 
-        JetReferenceExpression functionReference = expression.getConstructorReferenceExpression();
-        JetTypeReference typeReference = expression.getTypeReference();
+        KtReferenceExpression functionReference = expression.getConstructorReferenceExpression();
+        KtTypeReference typeReference = expression.getTypeReference();
         if (functionReference == null || typeReference == null) {
             return checkArgumentTypesAndFail(context); // No type there
         }
-        JetType constructedType = typeResolver.resolveType(context.scope, typeReference, context.trace, true);
+        KtType constructedType = typeResolver.resolveType(context.scope, typeReference, context.trace, true);
         if (constructedType.isError()) {
             return checkArgumentTypesAndFail(context);
         }
@@ -369,7 +369,7 @@ public class CallResolver {
     public OverloadResolutionResults<FunctionDescriptor> resolveConstructorDelegationCall(
             @NotNull BindingTrace trace, @NotNull LexicalScope scope, @NotNull DataFlowInfo dataFlowInfo,
             @NotNull ConstructorDescriptor constructorDescriptor,
-            @NotNull JetConstructorDelegationCall call, @NotNull CallChecker callChecker
+            @NotNull KtConstructorDelegationCall call, @NotNull CallChecker callChecker
     ) {
         // Method returns `null` when there is nothing to resolve in trivial cases like `null` call expression or
         // when super call should be conventional enum constructor and super call should be empty
@@ -398,8 +398,8 @@ public class CallResolver {
     @NotNull
     private OverloadResolutionResults<FunctionDescriptor> resolveConstructorDelegationCall(
             @NotNull BasicCallResolutionContext context,
-            @NotNull JetConstructorDelegationCall call,
-            @NotNull JetConstructorDelegationReferenceExpression calleeExpression,
+            @NotNull KtConstructorDelegationCall call,
+            @NotNull KtConstructorDelegationReferenceExpression calleeExpression,
             @NotNull ConstructorDescriptor calleeConstructor
     ) {
         context.trace.record(BindingContext.LEXICAL_SCOPE, call, context.scope);
@@ -420,7 +420,7 @@ public class CallResolver {
             if (DescriptorUtils.canHaveDeclaredConstructors(currentClassDescriptor)) {
                 // Diagnostic is meaningless when reporting on interfaces and object
                 context.trace.report(PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED.on(
-                        (JetConstructorDelegationCall) calleeExpression.getParent()
+                        (KtConstructorDelegationCall) calleeExpression.getParent()
                 ));
             }
             if (call.isImplicit()) return OverloadResolutionResultsImpl.nameNotFound();
@@ -436,9 +436,9 @@ public class CallResolver {
                                                     ((ClassDescriptor) delegateClassDescriptor.getContainingDeclaration()).
                                                             getThisAsReceiverParameter().getValue();
 
-        JetType expectedType = isThisCall ?
-                               calleeConstructor.getContainingDeclaration().getDefaultType() :
-                               DescriptorUtils.getSuperClassType(currentClassDescriptor);
+        KtType expectedType = isThisCall ?
+                              calleeConstructor.getContainingDeclaration().getDefaultType() :
+                              DescriptorUtils.getSuperClassType(currentClassDescriptor);
 
         TypeSubstitutor knownTypeParametersSubstitutor = TypeSubstitutor.create(expectedType);
         for (CallableDescriptor descriptor : constructors) {
@@ -559,13 +559,13 @@ public class CallResolver {
             argumentTypeResolver.analyzeArgumentsAndRecordTypes(context);
         }
 
-        List<JetTypeProjection> typeArguments = context.call.getTypeArguments();
-        for (JetTypeProjection projection : typeArguments) {
-            if (projection.getProjectionKind() != JetProjectionKind.NONE) {
+        List<KtTypeProjection> typeArguments = context.call.getTypeArguments();
+        for (KtTypeProjection projection : typeArguments) {
+            if (projection.getProjectionKind() != KtProjectionKind.NONE) {
                 context.trace.report(PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT.on(projection));
                 ModifierCheckerCore.INSTANCE.check(projection, context.trace, null);
             }
-            JetType type = argumentTypeResolver.resolveTypeRefWithDefault(
+            KtType type = argumentTypeResolver.resolveTypeRefWithDefault(
                     projection.getTypeReference(), context.scope, context.trace,
                     null);
             if (type != null) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt
index 89768a1e665..ed8abb2691e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt
@@ -40,19 +40,19 @@ public enum class ResolveArgumentsMode {
 }
 
 
-public fun hasUnknownFunctionParameter(type: JetType): Boolean {
+public fun hasUnknownFunctionParameter(type: KtType): Boolean {
     assert(ReflectionTypes.isCallableType(type)) { "type $type is not a function or property" }
     return getParameterArgumentsOfCallableType(type).any {
         TypeUtils.containsSpecialType(it.getType(), DONT_CARE) || ErrorUtils.containsUninferredParameter(it.getType())
     }
 }
 
-public fun hasUnknownReturnType(type: JetType): Boolean {
+public fun hasUnknownReturnType(type: KtType): Boolean {
     assert(ReflectionTypes.isCallableType(type)) { "type $type is not a function or property" }
     return ErrorUtils.containsErrorType(getReturnTypeForCallable(type))
 }
 
-public fun replaceReturnTypeByUnknown(type: JetType): JetType {
+public fun replaceReturnTypeByUnknown(type: KtType): KtType {
     assert(ReflectionTypes.isCallableType(type)) { "type $type is not a function or property" }
     val newArguments = Lists.newArrayList<TypeProjection>()
     newArguments.addAll(getParameterArgumentsOfCallableType(type))
@@ -60,13 +60,13 @@ public fun replaceReturnTypeByUnknown(type: JetType): JetType {
     return replaceTypeArguments(type, newArguments)
 }
 
-private fun replaceTypeArguments(type: JetType, newArguments: List<TypeProjection>) =
-        JetTypeImpl.create(type.getAnnotations(), type.getConstructor(), type.isMarkedNullable(), newArguments, type.getMemberScope())
+private fun replaceTypeArguments(type: KtType, newArguments: List<TypeProjection>) =
+        KtTypeImpl.create(type.getAnnotations(), type.getConstructor(), type.isMarkedNullable(), newArguments, type.getMemberScope())
 
-private fun getParameterArgumentsOfCallableType(type: JetType) =
+private fun getParameterArgumentsOfCallableType(type: KtType) =
         type.getArguments().dropLast(1)
 
-private fun getReturnTypeForCallable(type: JetType) =
+private fun getReturnTypeForCallable(type: KtType) =
         type.getArguments().last().getType()
 
 private fun CallableDescriptor.hasReturnTypeDependentOnUninferredParams(constraintSystem: ConstraintSystem): Boolean {
@@ -86,7 +86,7 @@ public fun CallableDescriptor.hasInferredReturnType(constraintSystem: Constraint
     return true
 }
 
-public fun getErasedReceiverType(receiverParameterDescriptor: ReceiverParameterDescriptor, descriptor: CallableDescriptor): JetType {
+public fun getErasedReceiverType(receiverParameterDescriptor: ReceiverParameterDescriptor, descriptor: CallableDescriptor): KtType {
     var receiverType = receiverParameterDescriptor.getType()
     for (typeParameter in descriptor.getTypeParameters()) {
         if (typeParameter.getTypeConstructor() == receiverType.getConstructor()) {
@@ -97,7 +97,7 @@ public fun getErasedReceiverType(receiverParameterDescriptor: ReceiverParameterD
     for (typeProjection in receiverType.getArguments()) {
         fakeTypeArguments.add(TypeProjectionImpl(typeProjection.getProjectionKind(), DONT_CARE))
     }
-    return JetTypeImpl.create(receiverType.getAnnotations(), receiverType.getConstructor(), receiverType.isMarkedNullable(), fakeTypeArguments,
+    return KtTypeImpl.create(receiverType.getAnnotations(), receiverType.getConstructor(), receiverType.isMarkedNullable(), fakeTypeArguments,
                        ErrorUtils.createErrorScope("Error scope for erased receiver type", /*throwExceptions=*/true))
 }
 
@@ -117,14 +117,14 @@ public fun isOrOverridesSynthesized(descriptor: CallableMemberDescriptor): Boole
 fun isConventionCall(call: Call): Boolean {
     if (call is CallTransformer.CallForImplicitInvoke) return true
     val callElement = call.callElement
-    if (callElement is JetArrayAccessExpression || callElement is JetMultiDeclarationEntry) return true
-    val calleeExpression = call.calleeExpression as? JetOperationReferenceExpression ?: return false
+    if (callElement is KtArrayAccessExpression || callElement is KtMultiDeclarationEntry) return true
+    val calleeExpression = call.calleeExpression as? KtOperationReferenceExpression ?: return false
     return calleeExpression.getNameForConventionalOperation() != null
 }
 
 fun getUnaryPlusOrMinusOperatorFunctionName(call: Call): Name? {
-    if (call.callElement !is JetPrefixExpression) return null
-    val calleeExpression = call.calleeExpression as? JetOperationReferenceExpression ?: return null
+    if (call.callElement !is KtPrefixExpression) return null
+    val calleeExpression = call.calleeExpression as? KtOperationReferenceExpression ?: return null
     val name = calleeExpression.getNameForConventionalOperation(unaryOperations = true, binaryOperations = false)
     return if (name == OperatorNameConventions.UNARY_PLUS || name == OperatorNameConventions.UNARY_MINUS) name else null
 }
@@ -134,7 +134,7 @@ public fun isInvokeCallOnVariable(call: Call): Boolean {
     val dispatchReceiver = call.getDispatchReceiver()
     //calleeExpressionAsDispatchReceiver for invoke is always ExpressionReceiver, see CallForImplicitInvoke
     val expression = (dispatchReceiver as ExpressionReceiver).getExpression()
-    return expression is JetSimpleNameExpression
+    return expression is KtSimpleNameExpression
 }
 
 public fun isInvokeCallOnExpressionWithBothReceivers(call: Call): Boolean {
@@ -142,11 +142,11 @@ public fun isInvokeCallOnExpressionWithBothReceivers(call: Call): Boolean {
     return call.getExplicitReceiver().exists() && call.getDispatchReceiver().exists()
 }
 
-public fun getSuperCallExpression(call: Call): JetSuperExpression? {
-    return (call.getExplicitReceiver() as? ExpressionReceiver)?.getExpression() as? JetSuperExpression
+public fun getSuperCallExpression(call: Call): KtSuperExpression? {
+    return (call.getExplicitReceiver() as? ExpressionReceiver)?.getExpression() as? KtSuperExpression
 }
 
-public fun getEffectiveExpectedType(parameterDescriptor: ValueParameterDescriptor, argument: ValueArgument): JetType {
+public fun getEffectiveExpectedType(parameterDescriptor: ValueParameterDescriptor, argument: ValueArgument): KtType {
     if (argument.getSpreadElement() != null) {
         if (parameterDescriptor.getVarargElementType() == null) {
             // Spread argument passed to a non-vararg parameter, an error is already reported by ValueArgumentsToParametersMapper
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java
index c8d45a5d2f7..4c9e7d67576 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategyForInvoke;
 import org.jetbrains.kotlin.resolve.calls.util.DelegatingCall;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
 
 import java.util.Collection;
@@ -158,7 +158,7 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
         private Call stripCallArguments(@NotNull Call call) {
             return new DelegatingCall(call) {
                 @Override
-                public JetValueArgumentList getValueArgumentList() {
+                public KtValueArgumentList getValueArgumentList() {
                     return null;
                 }
 
@@ -176,19 +176,19 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
 
                 @NotNull
                 @Override
-                public List<JetTypeProjection> getTypeArguments() {
+                public List<KtTypeProjection> getTypeArguments() {
                     return Collections.emptyList();
                 }
 
                 @Override
-                public JetTypeArgumentList getTypeArgumentList() {
+                public KtTypeArgumentList getTypeArgumentList() {
                     return null;
                 }
 
                 @NotNull
                 @Override
-                public JetElement getCallElement() {
-                    JetExpression calleeExpression = getCalleeExpression();
+                public KtElement getCallElement() {
+                    KtExpression calleeExpression = getCalleeExpression();
                     assert calleeExpression != null : "No callee expression: " + getCallElement().getText();
 
                     return calleeExpression;
@@ -225,14 +225,14 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
             }
 
             assert descriptor instanceof VariableDescriptor;
-            JetType returnType = descriptor.getReturnType();
+            KtType returnType = descriptor.getReturnType();
             if (returnType == null) {
                 return Collections.emptyList();
             }
 
             final MutableResolvedCall<VariableDescriptor> variableResolvedCall = (MutableResolvedCall)context.candidateCall;
 
-            JetExpression calleeExpression = task.call.getCalleeExpression();
+            KtExpression calleeExpression = task.call.getCalleeExpression();
             if (calleeExpression == null) return Collections.emptyList();
 
             ExpressionReceiver variableReceiver = new ExpressionReceiver(calleeExpression, variableResolvedCall.getResultingDescriptor().getType());
@@ -263,7 +263,7 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
         private final Call outerCall;
         private final ReceiverValue explicitExtensionReceiver;
         private final ExpressionReceiver calleeExpressionAsDispatchReceiver;
-        private final JetSimpleNameExpression fakeInvokeExpression;
+        private final KtSimpleNameExpression fakeInvokeExpression;
 
         public CallForImplicitInvoke(
                 @NotNull ReceiverValue explicitExtensionReceiver,
@@ -275,7 +275,7 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
             this.explicitExtensionReceiver = explicitExtensionReceiver;
             this.calleeExpressionAsDispatchReceiver = calleeExpressionAsDispatchReceiver;
             this.fakeInvokeExpression =
-                    (JetSimpleNameExpression) JetPsiFactoryKt.JetPsiFactory(call.getCallElement())
+                    (KtSimpleNameExpression) KtPsiFactoryKt.KtPsiFactory(call.getCallElement())
                             .createExpression(OperatorNameConventions.INVOKE.asString());
         }
 
@@ -301,7 +301,7 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
         }
 
         @Override
-        public JetExpression getCalleeExpression() {
+        public KtExpression getCalleeExpression() {
             return fakeInvokeExpression;
         }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt
index 7b8ccafbb53..557044010c4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt
@@ -49,7 +49,7 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.TypeUtils.noExpectedType
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
 import java.util.*
 
@@ -114,7 +114,7 @@ public class CandidateResolver(
         if (!jetTypeArguments.isEmpty()) {
             // Explicit type arguments passed
 
-            val typeArguments = ArrayList<JetType>()
+            val typeArguments = ArrayList<KtType>()
             for (projection in jetTypeArguments) {
                 val type = projection.typeReference?.let { trace.bindingContext.get(BindingContext.TYPE, it) }
                         ?: ErrorUtils.createErrorType("Star projection in a call")
@@ -159,7 +159,7 @@ public class CandidateResolver(
                     val candidate = candidateCall.getCandidateDescriptor()
                     val candidateReflectionType = getReflectionTypeForCandidateDescriptor(candidate, reflectionTypes);
                     if (candidateReflectionType != null) {
-                        if (!JetTypeChecker.DEFAULT.isSubtypeOf(candidateReflectionType, expectedType)) {
+                        if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(candidateReflectionType, expectedType)) {
                             candidateCall.addStatus(OTHER_ERROR)
                         }
                     }
@@ -187,7 +187,7 @@ public class CandidateResolver(
         }
         else if (receiverParameter == null && receiverArgument.exists()) {
             tracing.noReceiverAllowed(candidateCall.getTrace())
-            if (call.getCalleeExpression() is JetSimpleNameExpression) {
+            if (call.getCalleeExpression() is KtSimpleNameExpression) {
                 RECEIVER_PRESENCE_ERROR
             }
             else {
@@ -239,7 +239,7 @@ public class CandidateResolver(
         val descriptor = candidateDescriptor
         val expression = candidateCall.getCall().getCalleeExpression()
 
-        if (expression is JetSimpleNameExpression) {
+        if (expression is KtSimpleNameExpression) {
             // 'B' in 'class A: B()' is JetConstructorCalleeExpression
             if (descriptor is ConstructorDescriptor) {
                 val modality = descriptor.getContainingDeclaration().getModality()
@@ -281,10 +281,10 @@ public class CandidateResolver(
         SUCCESS
     }
 
-    private fun getReceiverSuper(receiver: ReceiverValue): JetSuperExpression? {
+    private fun getReceiverSuper(receiver: ReceiverValue): KtSuperExpression? {
         if (receiver is ExpressionReceiver) {
             val expression = receiver.getExpression()
-            if (expression is JetSuperExpression) {
+            if (expression is KtSuperExpression) {
                 return expression
             }
         }
@@ -312,7 +312,7 @@ public class CandidateResolver(
             candidateCall: MutableResolvedCall<D>,
             resolveFunctionArgumentBodies: ResolveArgumentsMode): ValueArgumentsCheckingResult {
         var resultStatus = SUCCESS
-        val argumentTypes = Lists.newArrayList<JetType>()
+        val argumentTypes = Lists.newArrayList<KtType>()
         val infoForArguments = candidateCall.getDataFlowInfoForArguments()
         for (entry in candidateCall.getValueArguments().entrySet()) {
             val parameterDescriptor = entry.getKey()
@@ -331,7 +331,7 @@ public class CandidateResolver(
                 infoForArguments.updateInfo(argument, typeInfoForCall.dataFlowInfo)
 
                 var matchStatus = ArgumentMatchStatus.SUCCESS
-                var resultingType: JetType? = type
+                var resultingType: KtType? = type
                 if (type == null || (type.isError() && !type.isFunctionPlaceholder)) {
                     matchStatus = ArgumentMatchStatus.ARGUMENT_HAS_NO_TYPE
                 }
@@ -358,14 +358,14 @@ public class CandidateResolver(
     }
 
     private fun smartCastValueArgumentTypeIfPossible(
-            expression: JetExpression,
-            expectedType: JetType,
-            actualType: JetType,
-            context: ResolutionContext<*>): JetType? {
-        val receiverToCast = ExpressionReceiver(JetPsiUtil.safeDeparenthesize(expression), actualType)
+            expression: KtExpression,
+            expectedType: KtType,
+            actualType: KtType,
+            context: ResolutionContext<*>): KtType? {
+        val receiverToCast = ExpressionReceiver(KtPsiUtil.safeDeparenthesize(expression), actualType)
         val variants = smartCastManager.getSmartCastVariantsExcludingReceiver(context, receiverToCast)
         for (possibleType in variants) {
-            if (JetTypeChecker.DEFAULT.isSubtypeOf(possibleType, expectedType)) {
+            if (KotlinTypeChecker.DEFAULT.isSubtypeOf(possibleType, expectedType)) {
                 return possibleType
             }
         }
@@ -482,11 +482,11 @@ public class CandidateResolver(
         return SUCCESS
     }
 
-    public inner class ValueArgumentsCheckingResult(public val status: ResolutionStatus, public val argumentTypes: List<JetType>)
+    public inner class ValueArgumentsCheckingResult(public val status: ResolutionStatus, public val argumentTypes: List<KtType>)
 
     private fun checkGenericBoundsInAFunctionCall(
-            jetTypeArguments: List<JetTypeProjection>,
-            typeArguments: List<JetType>,
+            jetTypeArguments: List<KtTypeProjection>,
+            typeArguments: List<KtType>,
             functionDescriptor: CallableDescriptor,
             substitutor: TypeSubstitutor,
             trace: BindingTrace) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt
index c477c1a5ae1..ac2ad623e95 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt
@@ -44,7 +44,7 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.TypeUtils.DONT_CARE
 import org.jetbrains.kotlin.types.TypeUtils.makeConstantSubstitutor
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
 
 
@@ -94,7 +94,7 @@ class GenericCandidateResolver(
         val receiverArgument = candidateCall.getExtensionReceiver()
         val receiverParameter = candidate.getExtensionReceiverParameter()
         if (receiverArgument.exists() && receiverParameter != null) {
-            var receiverType: JetType? = if (context.candidateCall.isSafeCall())
+            var receiverType: KtType? = if (context.candidateCall.isSafeCall())
                 TypeUtils.makeNotNullable(receiverArgument.getType())
             else
                 receiverArgument.getType()
@@ -140,11 +140,11 @@ class GenericCandidateResolver(
     }
 
     private fun addConstraintForNestedCall(
-            argumentExpression: JetExpression?,
+            argumentExpression: KtExpression?,
             constraintPosition: ConstraintPosition,
             constraintSystem: ConstraintSystem,
             context: CallCandidateResolutionContext<*>,
-            effectiveExpectedType: JetType
+            effectiveExpectedType: KtType
     ): Boolean {
         val resolutionResults = getResolutionResultsCachedData(argumentExpression, context)?.resolutionResults
         if (resolutionResults == null || !resolutionResults.isSingleResult()) return false
@@ -175,11 +175,11 @@ class GenericCandidateResolver(
     }
 
     private fun updateResultTypeForSmartCasts(
-            type: JetType?,
-            argumentExpression: JetExpression?,
+            type: KtType?,
+            argumentExpression: KtExpression?,
             context: ResolutionContext<*>
-    ): JetType? {
-        val deparenthesizedArgument = JetPsiUtil.getLastElementDeparenthesized(argumentExpression, context.statementFilter)
+    ): KtType? {
+        val deparenthesizedArgument = KtPsiUtil.getLastElementDeparenthesized(argumentExpression, context.statementFilter)
         if (deparenthesizedArgument == null || type == null) return type
 
         val dataFlowValue = DataFlowValueFactory.createDataFlowValue(deparenthesizedArgument, type, context)
@@ -188,7 +188,7 @@ class GenericCandidateResolver(
         val possibleTypes = context.dataFlowInfo.getPossibleTypes(dataFlowValue)
         if (possibleTypes.isEmpty()) return type
 
-        return TypeIntersector.intersectTypes(JetTypeChecker.DEFAULT, possibleTypes)
+        return TypeIntersector.intersectTypes(KotlinTypeChecker.DEFAULT, possibleTypes)
     }
 
     public fun <D : CallableDescriptor> completeTypeInferenceDependentOnFunctionArgumentsForCall(
@@ -218,7 +218,7 @@ class GenericCandidateResolver(
     }
 
     private fun <D : CallableDescriptor> addConstraintForFunctionLiteral(
-            functionLiteral: JetFunction,
+            functionLiteral: KtFunction,
             valueArgument: ValueArgument,
             valueParameterDescriptor: ValueParameterDescriptor,
             constraintSystem: ConstraintSystem,
@@ -245,7 +245,7 @@ class GenericCandidateResolver(
             val temporaryToResolveFunctionLiteral = TemporaryTraceAndCache.create(
                     context, "trace to resolve function literal with expected return type", argumentExpression)
 
-            val statementExpression = JetPsiUtil.getExpressionOrLastStatementInBlock(functionLiteral.getBodyExpression()) ?: return
+            val statementExpression = KtPsiUtil.getExpressionOrLastStatementInBlock(functionLiteral.getBodyExpression()) ?: return
             val mismatch = BooleanArray(1)
             val errorInterceptingTrace = ExpressionTypingUtils.makeTraceInterceptingTypeMismatch(
                     temporaryToResolveFunctionLiteral.trace, statementExpression, mismatch)
@@ -268,7 +268,7 @@ class GenericCandidateResolver(
     }
 
     private fun <D : CallableDescriptor> addConstraintForCallableReference(
-            callableReference: JetCallableReferenceExpression,
+            callableReference: KtCallableReferenceExpression,
             valueArgument: ValueArgument,
             valueParameterDescriptor: ValueParameterDescriptor,
             constraintSystem: ConstraintSystem,
@@ -284,11 +284,11 @@ class GenericCandidateResolver(
     }
 
     private fun <D : CallableDescriptor> getExpectedTypeForCallableReference(
-            callableReference: JetCallableReferenceExpression,
+            callableReference: KtCallableReferenceExpression,
             constraintSystem: ConstraintSystem,
             context: CallCandidateResolutionContext<D>,
-            effectiveExpectedType: JetType
-    ): JetType? {
+            effectiveExpectedType: KtType
+    ): KtType? {
         val substitutedType = constraintSystem.getCurrentSubstitutor().substitute(effectiveExpectedType, Variance.INVARIANT)
         if (substitutedType != null && !TypeUtils.isDontCarePlaceholder(substitutedType))
             return substitutedType
@@ -301,11 +301,11 @@ class GenericCandidateResolver(
     }
 
     private fun <D : CallableDescriptor> getResolvedTypeForCallableReference(
-            callableReference: JetCallableReferenceExpression,
+            callableReference: KtCallableReferenceExpression,
             context: CallCandidateResolutionContext<D>,
-            expectedType: JetType,
+            expectedType: KtType,
             valueArgument: ValueArgument
-    ): JetType? {
+    ): KtType? {
         val dataFlowInfoForArgument = context.candidateCall.getDataFlowInfoForArguments().getInfo(valueArgument)
         val expectedTypeWithoutReturnType = if (!hasUnknownReturnType(expectedType)) replaceReturnTypeByUnknown(expectedType) else expectedType
         val newContext = context
@@ -319,7 +319,7 @@ class GenericCandidateResolver(
     }
 }
 
-fun getResolutionResultsCachedData(expression: JetExpression?, context: ResolutionContext<*>): ResolutionResultsCache.CachedData? {
+fun getResolutionResultsCachedData(expression: KtExpression?, context: ResolutionContext<*>): ResolutionResultsCache.CachedData? {
     if (!ExpressionTypingUtils.dependsOnExpectedType(expression)) return null
     val argumentCall = expression?.getCall(context.trace.getBindingContext()) ?: return null
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ValueArgumentsToParametersMapper.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ValueArgumentsToParametersMapper.java
index c8f70061f68..d886a0e44e1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ValueArgumentsToParametersMapper.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ValueArgumentsToParametersMapper.java
@@ -170,7 +170,7 @@ public class ValueArgumentsToParametersMapper {
                 ValueArgumentName argumentName = argument.getArgumentName();
                 assert argumentName != null;
                 ValueParameterDescriptor valueParameterDescriptor = parameterByName.get(argumentName.getAsName());
-                JetReferenceExpression nameReference = argumentName.getReferenceExpression();
+                KtReferenceExpression nameReference = argumentName.getReferenceExpression();
                 if (!candidate.hasStableParameterNames() && nameReference != null) {
                     report(NAMED_ARGUMENTS_NOT_ALLOWED.on(
                             nameReference,
@@ -259,7 +259,7 @@ public class ValueArgumentsToParametersMapper {
             List<? extends FunctionLiteralArgument> functionLiteralArguments = call.getFunctionLiteralArguments();
             if (!functionLiteralArguments.isEmpty()) {
                 FunctionLiteralArgument functionLiteralArgument = functionLiteralArguments.get(0);
-                JetExpression possiblyLabeledFunctionLiteral = functionLiteralArgument.getArgumentExpression();
+                KtExpression possiblyLabeledFunctionLiteral = functionLiteralArgument.getArgumentExpression();
 
                 if (valueParameters.isEmpty()) {
                     report(TOO_MANY_ARGUMENTS.on(possiblyLabeledFunctionLiteral, candidate));
@@ -283,7 +283,7 @@ public class ValueArgumentsToParametersMapper {
                 }
 
                 for (int i = 1; i < functionLiteralArguments.size(); i++) {
-                    JetExpression argument = functionLiteralArguments.get(i).getArgumentExpression();
+                    KtExpression argument = functionLiteralArguments.get(i).getArgumentExpression();
                     report(MANY_FUNCTION_LITERAL_ARGUMENTS.on(argument));
                     setStatus(WEAK_ERROR);
                 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/AdditionalTypeChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/AdditionalTypeChecker.kt
index 7acb8b0e4ab..9a4dd80170b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/AdditionalTypeChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/AdditionalTypeChecker.kt
@@ -17,14 +17,14 @@
 package org.jetbrains.kotlin.resolve.calls.checkers
 
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 public interface AdditionalTypeChecker {
-    fun checkType(expression: JetExpression, expressionType: JetType, expressionTypeWithSmartCast: JetType, c: ResolutionContext<*>)
+    fun checkType(expression: KtExpression, expressionType: KtType, expressionTypeWithSmartCast: KtType, c: ResolutionContext<*>)
     fun checkReceiver(
             receiverParameter: ReceiverParameterDescriptor,
             receiverArgument: ReceiverValue,
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CapturingInClosureChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CapturingInClosureChecker.kt
index 3a2b78e04a7..fc24f464d34 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CapturingInClosureChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CapturingInClosureChecker.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.resolve.calls.checkers
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.psi.JetFunction
+import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingContext.CAPTURED_IN_CLOSURE
 import org.jetbrains.kotlin.resolve.BindingTrace
@@ -67,7 +67,7 @@ class CapturingInClosureChecker : CallChecker {
         val scopeDeclaration = DescriptorToSourceUtils.descriptorToDeclaration(scopeContainer)
         if (!InlineUtil.canBeInlineArgument(scopeDeclaration)) return false
 
-        if (InlineUtil.isInlinedArgument(scopeDeclaration as JetFunction, context, false)) {
+        if (InlineUtil.isInlinedArgument(scopeDeclaration as KtFunction, context, false)) {
             val scopeContainerParent = scopeContainer.getContainingDeclaration()
             assert(scopeContainerParent != null) { "parent is null for " + scopeContainer }
             return !isCapturedVariable(variableParent, scopeContainerParent!!) || isCapturedInInline(context, scopeContainerParent, variableParent)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java
index 8500f120023..65e2f3e7ef5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java
@@ -21,8 +21,8 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.diagnostics.Errors;
-import org.jetbrains.kotlin.lexer.JetToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
@@ -74,7 +74,7 @@ class InlineChecker implements CallChecker {
 
     @Override
     public <F extends CallableDescriptor> void check(@NotNull ResolvedCall<F> resolvedCall, @NotNull BasicCallResolutionContext context) {
-        JetExpression expression = context.call.getCalleeExpression();
+        KtExpression expression = context.call.getCalleeExpression();
         if (expression == null) {
             return;
         }
@@ -104,11 +104,11 @@ class InlineChecker implements CallChecker {
         checkRecursion(context, targetDescriptor, expression);
     }
 
-    private static boolean isInsideCall(JetExpression expression) {
-        JetElement parent = JetPsiUtil.getParentCallIfPresent(expression);
-        if (parent instanceof JetBinaryExpression) {
-            JetToken token = JetPsiUtil.getOperationToken((JetOperationExpression) parent);
-            if (token == JetTokens.EQ || token == JetTokens.ANDAND || token == JetTokens.OROR) {
+    private static boolean isInsideCall(KtExpression expression) {
+        KtElement parent = KtPsiUtil.getParentCallIfPresent(expression);
+        if (parent instanceof KtBinaryExpression) {
+            KtToken token = KtPsiUtil.getOperationToken((KtOperationExpression) parent);
+            if (token == KtTokens.EQ || token == KtTokens.ANDAND || token == KtTokens.OROR) {
                 //assignment
                 return false;
             }
@@ -125,7 +125,7 @@ class InlineChecker implements CallChecker {
             @NotNull ValueArgument targetArgument,
             @NotNull ValueParameterDescriptor targetParameterDescriptor
     ) {
-        JetExpression argumentExpression = targetArgument.getArgumentExpression();
+        KtExpression argumentExpression = targetArgument.getArgumentExpression();
         if (argumentExpression == null) {
             return;
         }
@@ -152,12 +152,12 @@ class InlineChecker implements CallChecker {
             @NotNull BasicCallResolutionContext context,
             @NotNull CallableDescriptor targetDescriptor,
             @NotNull ReceiverValue receiver,
-            @Nullable JetExpression expression
+            @Nullable KtExpression expression
     ) {
         if (!receiver.exists()) return;
 
         CallableDescriptor varDescriptor = null;
-        JetExpression receiverExpression = null;
+        KtExpression receiverExpression = null;
         if (receiver instanceof ExpressionReceiver) {
             receiverExpression = ((ExpressionReceiver) receiver).getExpression();
             varDescriptor = getCalleeDescriptor(context, receiverExpression, true);
@@ -181,10 +181,10 @@ class InlineChecker implements CallChecker {
     @Nullable
     private static CallableDescriptor getCalleeDescriptor(
             @NotNull BasicCallResolutionContext context,
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             boolean unwrapVariableAsFunction
     ) {
-        if (!(expression instanceof JetSimpleNameExpression || expression instanceof JetThisExpression)) return null;
+        if (!(expression instanceof KtSimpleNameExpression || expression instanceof KtThisExpression)) return null;
 
         ResolvedCall<?> thisCall = CallUtilKt.getResolvedCall(expression, context.trace.getBindingContext());
         if (unwrapVariableAsFunction && thisCall instanceof VariableAsFunctionResolvedCall) {
@@ -197,7 +197,7 @@ class InlineChecker implements CallChecker {
             @NotNull BasicCallResolutionContext context,
             @NotNull CallableDescriptor lambdaDescriptor,
             @NotNull CallableDescriptor callDescriptor,
-            @NotNull JetExpression receiverExpression
+            @NotNull KtExpression receiverExpression
     ) {
         boolean inlinableCall = isInvokeOrInlineExtension(callDescriptor);
         if (!inlinableCall) {
@@ -211,7 +211,7 @@ class InlineChecker implements CallChecker {
     public void checkRecursion(
             @NotNull BasicCallResolutionContext context,
             @NotNull CallableDescriptor targetDescriptor,
-            @NotNull JetElement expression
+            @NotNull KtElement expression
     ) {
         if (targetDescriptor.getOriginal() == descriptor) {
             context.trace.report(Errors.RECURSION_IN_INLINE.on(expression, expression, descriptor));
@@ -235,7 +235,7 @@ class InlineChecker implements CallChecker {
         return isInvoke || InlineUtil.isInline(descriptor);
     }
 
-    private void checkVisibility(@NotNull CallableDescriptor declarationDescriptor, @NotNull JetElement expression, @NotNull BasicCallResolutionContext context){
+    private void checkVisibility(@NotNull CallableDescriptor declarationDescriptor, @NotNull KtElement expression, @NotNull BasicCallResolutionContext context){
         boolean declarationDescriptorIsPublicApi = DescriptorUtilsKt.isEffectivelyPublicApi(declarationDescriptor) || isDefinedInInlineFunction(declarationDescriptor);
         if (isEffectivelyPublicApiFunction && !declarationDescriptorIsPublicApi && declarationDescriptor.getVisibility() != Visibilities.LOCAL) {
             context.trace.report(Errors.INVISIBLE_MEMBER_FROM_INLINE.on(expression, declarationDescriptor, descriptor));
@@ -257,7 +257,7 @@ class InlineChecker implements CallChecker {
     private void checkNonLocalReturn(
             @NotNull BasicCallResolutionContext context,
             @NotNull CallableDescriptor inlinableParameterDescriptor,
-            @NotNull JetExpression parameterUsage
+            @NotNull KtExpression parameterUsage
     ) {
         if (!allowsNonLocalReturns(inlinableParameterDescriptor)) return;
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ReifiedTypeParameterSubstitutionChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ReifiedTypeParameterSubstitutionChecker.java
index 21b011e32a1..9478c71ce3b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ReifiedTypeParameterSubstitutionChecker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ReifiedTypeParameterSubstitutionChecker.java
@@ -22,10 +22,10 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.diagnostics.Errors;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.typeUtil.TypeUtilsKt;
 
 import java.util.Map;
@@ -35,10 +35,10 @@ public class ReifiedTypeParameterSubstitutionChecker implements CallChecker {
     public <F extends CallableDescriptor> void check(
             @NotNull ResolvedCall<F> resolvedCall, @NotNull BasicCallResolutionContext context
     ) {
-        Map<TypeParameterDescriptor, JetType> typeArguments = resolvedCall.getTypeArguments();
-        for (Map.Entry<TypeParameterDescriptor, JetType> entry : typeArguments.entrySet()) {
+        Map<TypeParameterDescriptor, KtType> typeArguments = resolvedCall.getTypeArguments();
+        for (Map.Entry<TypeParameterDescriptor, KtType> entry : typeArguments.entrySet()) {
             TypeParameterDescriptor parameter = entry.getKey();
-            JetType argument = entry.getValue();
+            KtType argument = entry.getValue();
             ClassifierDescriptor argumentDeclarationDescription = argument.getConstructor().getDeclarationDescriptor();
 
             if (parameter.isReified()) {
@@ -58,7 +58,7 @@ public class ReifiedTypeParameterSubstitutionChecker implements CallChecker {
 
     @NotNull
     private static PsiElement getCallElement(@NotNull BasicCallResolutionContext context) {
-        JetExpression callee = context.call.getCalleeExpression();
+        KtExpression callee = context.call.getCalleeExpression();
         return callee != null ? callee : context.call.getCallElement();
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/SafeCallChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/SafeCallChecker.kt
index aff3d8481a4..6412b56ad60 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/SafeCallChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/SafeCallChecker.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve.calls.checkers
 
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
@@ -27,7 +27,7 @@ public class SafeCallChecker : CallChecker {
     override fun <F : CallableDescriptor> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
         val operationNode = resolvedCall.call.callOperationNode ?: return
 
-        if (operationNode.elementType == JetTokens.SAFE_ACCESS && resolvedCall.explicitReceiverKind == ExplicitReceiverKind.NO_EXPLICIT_RECEIVER) {
+        if (operationNode.elementType == KtTokens.SAFE_ACCESS && resolvedCall.explicitReceiverKind == ExplicitReceiverKind.NO_EXPLICIT_RECEIVER) {
             context.trace.report(Errors.UNEXPECTED_SAFE_CALL.on(operationNode.psi))
         }
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/BasicCallResolutionContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/BasicCallResolutionContext.java
index ede19911fc2..69c2261ff1a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/BasicCallResolutionContext.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/BasicCallResolutionContext.java
@@ -26,14 +26,14 @@ import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public class BasicCallResolutionContext extends CallResolutionContext<BasicCallResolutionContext> {
     private BasicCallResolutionContext(
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull Call call,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull ContextDependency contextDependency,
             @NotNull CheckArgumentTypesMode checkArguments,
@@ -54,7 +54,7 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull Call call,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull ContextDependency contextDependency,
             @NotNull CheckArgumentTypesMode checkArguments,
@@ -90,7 +90,7 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
             @NotNull StatementFilter statementFilter,
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallCandidateResolutionContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallCandidateResolutionContext.java
index 8da0467c2dd..db17e9249ae 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallCandidateResolutionContext.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallCandidateResolutionContext.java
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public final class CallCandidateResolutionContext<D extends CallableDescriptor> extends CallResolutionContext<CallCandidateResolutionContext<D>> {
     @NotNull
@@ -47,7 +47,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull Call call,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull ContextDependency contextDependency,
             @NotNull CheckArgumentTypesMode checkArguments,
@@ -99,7 +99,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
             @NotNull StatementFilter statementFilter,
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallResolutionContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallResolutionContext.java
index 72c57a0ab7a..71b33e253dd 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallResolutionContext.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallResolutionContext.java
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.resolve.calls.model.DataFlowInfoForArgumentsImpl;
 import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public abstract class CallResolutionContext<Context extends CallResolutionContext<Context>> extends ResolutionContext<Context> {
     @NotNull
@@ -40,7 +40,7 @@ public abstract class CallResolutionContext<Context extends CallResolutionContex
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull Call call,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull ContextDependency contextDependency,
             @NotNull CheckArgumentTypesMode checkArguments,
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/ResolutionContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/ResolutionContext.java
index 8eefc49badb..f58fd33649c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/ResolutionContext.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/ResolutionContext.java
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.resolve.StatementFilter;
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 
 /**
@@ -38,7 +38,7 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
     @NotNull
     public final LexicalScope scope;
     @NotNull
-    public final JetType expectedType;
+    public final KtType expectedType;
     @NotNull
     public final DataFlowInfo dataFlowInfo;
     @NotNull
@@ -60,7 +60,7 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
     protected ResolutionContext(
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
@@ -87,7 +87,7 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
             @NotNull StatementFilter statementFilter,
@@ -116,7 +116,7 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
     }
 
     @NotNull
-    public Context replaceExpectedType(@Nullable JetType newExpectedType) {
+    public Context replaceExpectedType(@Nullable KtType newExpectedType) {
         if (newExpectedType == null) return replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE);
         if (expectedType == newExpectedType) return self();
         return create(trace, scope, dataFlowInfo, newExpectedType, contextDependency, resolutionResultsCache, statementFilter,
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/TemporaryTraceAndCache.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/TemporaryTraceAndCache.java
index 83ea8c04b87..46e09d87d44 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/TemporaryTraceAndCache.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/TemporaryTraceAndCache.java
@@ -16,19 +16,19 @@
 
 package org.jetbrains.kotlin.resolve.calls.context;
 
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.resolve.TemporaryBindingTrace;
 
 public class TemporaryTraceAndCache {
     public final TemporaryBindingTrace trace;
     public final TemporaryResolutionResultsCache cache;
 
-    public TemporaryTraceAndCache(ResolutionContext context, String debugName, JetExpression expression) {
+    public TemporaryTraceAndCache(ResolutionContext context, String debugName, KtExpression expression) {
         trace = TemporaryBindingTrace.create(context.trace, debugName, expression);
         cache = new TemporaryResolutionResultsCache(context.resolutionResultsCache);
     }
 
-    public static TemporaryTraceAndCache create(ResolutionContext context, String debugName, JetExpression expression) {
+    public static TemporaryTraceAndCache create(ResolutionContext context, String debugName, KtExpression expression) {
         return new TemporaryTraceAndCache(context, debugName, expression);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintType.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintType.java
index 8dc204449b3..210046a9870 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintType.java
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.resolve.calls.inference;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.text.MessageFormat;
 
@@ -40,7 +40,7 @@ public enum ConstraintType implements Comparable<ConstraintType> {
     }
 
     @NotNull
-    public SubtypingConstraint assertSubtyping(@NotNull JetType subtype, @NotNull JetType supertype) {
+    public SubtypingConstraint assertSubtyping(@NotNull KtType subtype, @NotNull KtType supertype) {
         return new SubtypingConstraint(this, subtype, supertype);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintsUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintsUtil.java
index 756da0bfb49..e28abefcd9d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintsUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintsUtil.java
@@ -22,7 +22,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.types.*;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
@@ -45,10 +45,10 @@ public class ConstraintsUtil {
         TypeParameterDescriptor firstConflictingParameter = getFirstConflictingParameter(constraintSystem);
         if (firstConflictingParameter == null) return Collections.emptyList();
 
-        Collection<JetType> conflictingTypes = constraintSystem.getTypeBounds(firstConflictingParameter).getValues();
+        Collection<KtType> conflictingTypes = constraintSystem.getTypeBounds(firstConflictingParameter).getValues();
 
         List<Map<TypeConstructor, TypeProjection>> substitutionContexts = Lists.newArrayList();
-        for (JetType type : conflictingTypes) {
+        for (KtType type : conflictingTypes) {
             Map<TypeConstructor, TypeProjection> context = Maps.newLinkedHashMap();
             context.put(firstConflictingParameter.getTypeConstructor(), new TypeProjectionImpl(type));
             substitutionContexts.add(context);
@@ -57,7 +57,7 @@ public class ConstraintsUtil {
         for (TypeParameterDescriptor typeParameter : constraintSystem.getTypeVariables()) {
             if (typeParameter == firstConflictingParameter) continue;
 
-            JetType safeType = getSafeValue(constraintSystem, typeParameter);
+            KtType safeType = getSafeValue(constraintSystem, typeParameter);
             for (Map<TypeConstructor, TypeProjection> context : substitutionContexts) {
                 TypeProjection typeProjection = new TypeProjectionImpl(safeType);
                 context.put(typeParameter.getTypeConstructor(), typeProjection);
@@ -71,8 +71,8 @@ public class ConstraintsUtil {
     }
 
     @NotNull
-    public static JetType getSafeValue(@NotNull ConstraintSystem constraintSystem, @NotNull TypeParameterDescriptor typeParameter) {
-        JetType type = constraintSystem.getTypeBounds(typeParameter).getValue();
+    public static KtType getSafeValue(@NotNull ConstraintSystem constraintSystem, @NotNull TypeParameterDescriptor typeParameter) {
+        KtType type = constraintSystem.getTypeBounds(typeParameter).getValue();
         if (type != null) {
             return type;
         }
@@ -85,16 +85,16 @@ public class ConstraintsUtil {
             @NotNull TypeParameterDescriptor typeParameter,
             boolean substituteOtherTypeParametersInBound
     ) {
-        JetType type = constraintSystem.getTypeBounds(typeParameter).getValue();
+        KtType type = constraintSystem.getTypeBounds(typeParameter).getValue();
         if (type == null) return true;
-        for (JetType upperBound : typeParameter.getUpperBounds()) {
+        for (KtType upperBound : typeParameter.getUpperBounds()) {
             if (!substituteOtherTypeParametersInBound && TypeUtils.dependsOnTypeParameters(upperBound, constraintSystem.getTypeVariables())) {
                 continue;
             }
-            JetType substitutedUpperBound = constraintSystem.getResultingSubstitutor().substitute(upperBound, Variance.INVARIANT);
+            KtType substitutedUpperBound = constraintSystem.getResultingSubstitutor().substitute(upperBound, Variance.INVARIANT);
 
             assert substitutedUpperBound != null : "We wanted to substitute projections as a result for " + typeParameter;
-            if (!JetTypeChecker.DEFAULT.isSubtypeOf(type, substitutedUpperBound)) {
+            if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(type, substitutedUpperBound)) {
                 return false;
             }
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/InferenceErrorData.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/InferenceErrorData.java
index 2a8b49aeab6..d2d0f3a7b79 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/InferenceErrorData.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/InferenceErrorData.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve.calls.inference;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.List;
 
@@ -29,16 +29,16 @@ public class InferenceErrorData {
     @NotNull
     public final ConstraintSystem constraintSystem;
     @Nullable
-    public final JetType receiverArgumentType;
+    public final KtType receiverArgumentType;
     @NotNull
-    public final JetType expectedType;
+    public final KtType expectedType;
     @NotNull
-    public final List<JetType> valueArgumentsTypes;
+    public final List<KtType> valueArgumentsTypes;
 
 
     private InferenceErrorData(
             @NotNull CallableDescriptor descriptor, @NotNull ConstraintSystem constraintSystem,
-            @NotNull List<JetType> valueArgumentsTypes, @Nullable JetType receiverArgumentType, @NotNull JetType expectedType
+            @NotNull List<KtType> valueArgumentsTypes, @Nullable KtType receiverArgumentType, @NotNull KtType expectedType
     ) {
         this.descriptor = descriptor;
         this.constraintSystem = constraintSystem;
@@ -49,7 +49,7 @@ public class InferenceErrorData {
 
     @NotNull
     public static InferenceErrorData create(@NotNull CallableDescriptor descriptor, @NotNull ConstraintSystem constraintSystem,
-            @NotNull List<JetType> valueArgumentsTypes, @Nullable JetType receiverArgumentType, @NotNull JetType expectedType) {
+            @NotNull List<KtType> valueArgumentsTypes, @Nullable KtType receiverArgumentType, @NotNull KtType expectedType) {
         return new InferenceErrorData(descriptor, constraintSystem, valueArgumentsTypes, receiverArgumentType, expectedType);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/SubtypingConstraint.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/SubtypingConstraint.java
index d78c86cac5a..2a8591bbc8e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/SubtypingConstraint.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/SubtypingConstraint.java
@@ -17,26 +17,26 @@
 package org.jetbrains.kotlin.resolve.calls.inference;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public class SubtypingConstraint {
     private final ConstraintType type;
-    private final JetType subtype;
-    private final JetType supertype;
+    private final KtType subtype;
+    private final KtType supertype;
 
-    public SubtypingConstraint(@NotNull ConstraintType type, @NotNull JetType subtype, @NotNull JetType supertype) {
+    public SubtypingConstraint(@NotNull ConstraintType type, @NotNull KtType subtype, @NotNull KtType supertype) {
         this.type = type;
         this.subtype = subtype;
         this.supertype = supertype;
     }
 
     @NotNull
-    public JetType getSubtype() {
+    public KtType getSubtype() {
         return subtype;
     }
 
     @NotNull
-    public JetType getSupertype() {
+    public KtType getSupertype() {
         return supertype;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/DelegatingResolvedCall.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/DelegatingResolvedCall.java
index 5fec5890d10..304aab9907d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/DelegatingResolvedCall.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/DelegatingResolvedCall.java
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.psi.ValueArgument;
 import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus;
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.List;
 import java.util.Map;
@@ -100,7 +100,7 @@ public abstract class DelegatingResolvedCall<D extends CallableDescriptor> imple
 
     @NotNull
     @Override
-    public Map<TypeParameterDescriptor, JetType> getTypeArguments() {
+    public Map<TypeParameterDescriptor, KtType> getTypeArguments() {
         return resolvedCall.getTypeArguments();
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ExpressionValueArgument.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ExpressionValueArgument.java
index 157c307eaf6..f4b820fb8e4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ExpressionValueArgument.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ExpressionValueArgument.java
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve.calls.model;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.psi.ValueArgument;
 
 import java.util.Collections;
@@ -46,7 +46,7 @@ public class ExpressionValueArgument implements ResolvedValueArgument {
 
     @Override
     public String toString() {
-        JetExpression expression = valueArgument.getArgumentExpression();
+        KtExpression expression = valueArgument.getArgumentExpression();
         return expression == null ? "no expression" : expression.getText();
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCall.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCall.java
index 36b40bf9d1e..5f7e98eb4bc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCall.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCall.java
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.psi.ValueArgument;
 import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus;
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.List;
 import java.util.Map;
@@ -73,7 +73,7 @@ public interface ResolvedCall<D extends CallableDescriptor> {
 
     /** What's substituted for type parameters */
     @NotNull
-    Map<TypeParameterDescriptor, JetType> getTypeArguments();
+    Map<TypeParameterDescriptor, KtType> getTypeArguments();
 
     /** Data flow info for each argument and the result data flow info */
     @NotNull
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java
index 1ba6307f000..dea7e12ded9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind;
 import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionCandidate;
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeProjection;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 
@@ -81,7 +81,7 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
     private final ExplicitReceiverKind explicitReceiverKind;
     private final TypeSubstitutor knownTypeParametersSubstitutor;
 
-    private final Map<TypeParameterDescriptor, JetType> typeArguments = Maps.newLinkedHashMap();
+    private final Map<TypeParameterDescriptor, KtType> typeArguments = Maps.newLinkedHashMap();
     private final Map<ValueParameterDescriptor, ResolvedValueArgument> valueArguments = Maps.newLinkedHashMap();
     private final MutableDataFlowInfoForArguments dataFlowInfoForArguments;
     private final Map<ValueArgument, ArgumentMatchImpl> argumentToParameterMap = Maps.newHashMap();
@@ -287,7 +287,7 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
 
     @NotNull
     @Override
-    public Map<TypeParameterDescriptor, JetType> getTypeArguments() {
+    public Map<TypeParameterDescriptor, KtType> getTypeArguments() {
         return typeArguments;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/VarargValueArgument.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/VarargValueArgument.java
index e77a7cf71c0..f733d82ce8a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/VarargValueArgument.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/VarargValueArgument.java
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve.calls.model;
 
 import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.psi.ValueArgument;
 
 import java.util.Iterator;
@@ -42,7 +42,7 @@ public class VarargValueArgument implements ResolvedValueArgument {
         StringBuilder builder = new StringBuilder("vararg:{");
         for (Iterator<ValueArgument> iterator = arguments.iterator(); iterator.hasNext(); ) {
             ValueArgument valueArgument = iterator.next();
-            JetExpression expression = valueArgument.getArgumentExpression();
+            KtExpression expression = valueArgument.getArgumentExpression();
             builder.append(expression == null ? "no expression" : expression.getText());
             if (iterator.hasNext()) {
                 builder.append(", ");
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt
index 28cac09d9c1..ca126fdd7b1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt
@@ -20,9 +20,9 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.psi.JetPsiUtil
-import org.jetbrains.kotlin.psi.JetSuperExpression
-import org.jetbrains.kotlin.psi.JetThisExpression
+import org.jetbrains.kotlin.psi.KtPsiUtil
+import org.jetbrains.kotlin.psi.KtSuperExpression
+import org.jetbrains.kotlin.psi.KtThisExpression
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
@@ -58,8 +58,8 @@ private fun ResolvedCall<*>.hasThisOrNoDispatchReceiver(
         dispatchReceiverDescriptor = dispatchReceiverValue.getDeclarationDescriptor()
     }
     else if (dispatchReceiverValue is ExpressionReceiver && considerExplicitReceivers) {
-        val expression = JetPsiUtil.deparenthesize(dispatchReceiverValue.getExpression())
-        if (expression is JetThisExpression) {
+        val expression = KtPsiUtil.deparenthesize(dispatchReceiverValue.getExpression())
+        if (expression is KtThisExpression) {
             // this.foo() -- explicit receiver
             dispatchReceiverDescriptor = context.get(BindingContext.REFERENCE_TARGET, expression.getInstanceReference())
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadResolutionResultsUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadResolutionResultsUtil.java
index 0e2f28a547e..b8156a52f5f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadResolutionResultsUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadResolutionResultsUtil.java
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.resolve.calls.context.ContextDependency;
 import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collection;
 
@@ -37,7 +37,7 @@ public class OverloadResolutionResultsUtil {
     }
 
     @Nullable
-    public static <D extends CallableDescriptor> JetType getResultingType(
+    public static <D extends CallableDescriptor> KtType getResultingType(
             @NotNull OverloadResolutionResults<D> results,
             @NotNull ContextDependency contextDependency
     ) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.java
index 0692a83d1bb..1ea81e096ae 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.java
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall;
 import org.jetbrains.kotlin.types.*;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.List;
 import java.util.Set;
@@ -164,8 +164,8 @@ public class OverloadingConflictResolver {
                 ValueParameterDescriptor fParam = fParams.get(i);
                 ValueParameterDescriptor gParam = gParams.get(i);
 
-                JetType fParamType = fParam.getType();
-                JetType gParamType = gParam.getType();
+                KtType fParamType = fParam.getType();
+                KtType gParamType = gParam.getType();
 
                 if (!typeMoreSpecific(fParamType, gParamType)) {
                     return false;
@@ -180,8 +180,8 @@ public class OverloadingConflictResolver {
                 ValueParameterDescriptor fParam = fParams.get(i);
                 ValueParameterDescriptor gParam = gParams.get(i);
 
-                JetType fParamType = fParam.getType();
-                JetType gParamType = gParam.getType();
+                KtType fParamType = fParam.getType();
+                KtType gParamType = gParam.getType();
 
                 if (!typeMoreSpecific(fParamType, gParamType)) {
                     return false;
@@ -195,7 +195,7 @@ public class OverloadingConflictResolver {
             // here we check that typeOf(a) < elementTypeOf(vf) and elementTypeOf(vg) < elementTypeOf(vf)
             if (fSize < gSize) {
                 ValueParameterDescriptor fParam = fParams.get(fSize - 1);
-                JetType fParamType = fParam.getVarargElementType();
+                KtType fParamType = fParam.getVarargElementType();
                 assert fParamType != null : "fIsVararg guarantees this";
                 for (int i = fSize - 1; i < gSize; i++) {
                     ValueParameterDescriptor gParam = gParams.get(i);
@@ -206,7 +206,7 @@ public class OverloadingConflictResolver {
             }
             else {
                 ValueParameterDescriptor gParam = gParams.get(gSize - 1);
-                JetType gParamType = gParam.getVarargElementType();
+                KtType gParamType = gParam.getVarargElementType();
                 assert gParamType != null : "gIsVararg guarantees this";
                 for (int i = gSize - 1; i < fSize; i++) {
                     ValueParameterDescriptor fParam = fParams.get(i);
@@ -221,8 +221,8 @@ public class OverloadingConflictResolver {
     }
 
     @NotNull
-    private static JetType getVarargElementTypeOrType(@NotNull ValueParameterDescriptor parameterDescriptor) {
-        JetType varargElementType = parameterDescriptor.getVarargElementType();
+    private static KtType getVarargElementTypeOrType(@NotNull ValueParameterDescriptor parameterDescriptor) {
+        KtType varargElementType = parameterDescriptor.getVarargElementType();
         if (varargElementType != null) {
             return varargElementType;
         }
@@ -238,9 +238,9 @@ public class OverloadingConflictResolver {
         return !f.getOriginal().getTypeParameters().isEmpty();
     }
 
-    private boolean typeMoreSpecific(@NotNull JetType specific, @NotNull JetType general) {
-        boolean isSubtype = JetTypeChecker.DEFAULT.isSubtypeOf(specific, general) ||
-                    numericTypeMoreSpecific(specific, general);
+    private boolean typeMoreSpecific(@NotNull KtType specific, @NotNull KtType general) {
+        boolean isSubtype = KotlinTypeChecker.DEFAULT.isSubtypeOf(specific, general) ||
+                            numericTypeMoreSpecific(specific, general);
 
         if (!isSubtype) return false;
 
@@ -253,13 +253,13 @@ public class OverloadingConflictResolver {
         return true;
     }
 
-    private boolean numericTypeMoreSpecific(@NotNull JetType specific, @NotNull JetType general) {
-        JetType _double = builtIns.getDoubleType();
-        JetType _float = builtIns.getFloatType();
-        JetType _long = builtIns.getLongType();
-        JetType _int = builtIns.getIntType();
-        JetType _byte = builtIns.getByteType();
-        JetType _short = builtIns.getShortType();
+    private boolean numericTypeMoreSpecific(@NotNull KtType specific, @NotNull KtType general) {
+        KtType _double = builtIns.getDoubleType();
+        KtType _float = builtIns.getFloatType();
+        KtType _long = builtIns.getLongType();
+        KtType _int = builtIns.getIntType();
+        KtType _byte = builtIns.getByteType();
+        KtType _short = builtIns.getShortType();
 
         if (TypeUtils.equalTypes(specific, _double) && TypeUtils.equalTypes(general, _float)) return true;
         if (TypeUtils.equalTypes(specific, _int)) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowInfo.java
index 261d3db669d..e01bd5aa59a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowInfo.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowInfo.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve.calls.smartcasts;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.SetMultimap;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Map;
 import java.util.Set;
@@ -35,7 +35,7 @@ public interface DataFlowInfo {
     Map<DataFlowValue, Nullability> getCompleteNullabilityInfo();
 
     @NotNull
-    SetMultimap<DataFlowValue, JetType> getCompleteTypeInfo();
+    SetMultimap<DataFlowValue, KtType> getCompleteTypeInfo();
 
     @NotNull
     Nullability getNullability(@NotNull DataFlowValue key);
@@ -45,7 +45,7 @@ public interface DataFlowInfo {
      * are NOT included. So it's quite possible to get an empty set here.
      */
     @NotNull
-    Set<JetType> getPossibleTypes(@NotNull DataFlowValue key);
+    Set<KtType> getPossibleTypes(@NotNull DataFlowValue key);
 
     /**
      * Call this function to clear all data flow information about
@@ -73,7 +73,7 @@ public interface DataFlowInfo {
     DataFlowInfo disequate(@NotNull DataFlowValue a, @NotNull DataFlowValue b);
 
     @NotNull
-    DataFlowInfo establishSubtyping(@NotNull DataFlowValue value, @NotNull JetType type);
+    DataFlowInfo establishSubtyping(@NotNull DataFlowValue value, @NotNull KtType type);
 
     /**
      * Call this function to add data flow information from other to this and return sum as the result
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowValue.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowValue.kt
index 1c44ddb56d3..c6890b53056 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowValue.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowValue.kt
@@ -18,13 +18,13 @@ package org.jetbrains.kotlin.resolve.calls.smartcasts
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 /**
  * This class describes an arbitrary object which has some value in data flow analysis.
  * In general case it's some r-value.
  */
-class DataFlowValue(val id: Any?, val type: JetType, val kind: DataFlowValue.Kind, val immanentNullability: Nullability) {
+class DataFlowValue(val id: Any?, val type: KtType, val kind: DataFlowValue.Kind, val immanentNullability: Nullability) {
 
     enum class Kind(private val str: String) {
         // Smart casts are completely safe
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowValueFactory.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowValueFactory.java
index a73590e95ce..cf2c4c62c41 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowValueFactory.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowValueFactory.java
@@ -21,11 +21,11 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt;
 import org.jetbrains.kotlin.resolve.BindingContext;
@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValue.Kind;
 import org.jetbrains.kotlin.resolve.scopes.receivers.*;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.kotlin.types.expressions.PreliminaryDeclarationVisitor;
@@ -58,8 +58,8 @@ public class DataFlowValueFactory {
 
     @NotNull
     public static DataFlowValue createDataFlowValue(
-            @NotNull JetExpression expression,
-            @NotNull JetType type,
+            @NotNull KtExpression expression,
+            @NotNull KtType type,
             @NotNull ResolutionContext resolutionContext
     ) {
         return createDataFlowValue(expression, type, resolutionContext.trace.getBindingContext(),
@@ -68,14 +68,14 @@ public class DataFlowValueFactory {
 
     @NotNull
     public static DataFlowValue createDataFlowValue(
-            @NotNull JetExpression expression,
-            @NotNull JetType type,
+            @NotNull KtExpression expression,
+            @NotNull KtType type,
             @NotNull BindingContext bindingContext,
             @NotNull DeclarationDescriptor containingDeclarationOrModule
     ) {
-        if (expression instanceof JetConstantExpression) {
-            JetConstantExpression constantExpression = (JetConstantExpression) expression;
-            if (constantExpression.getNode().getElementType() == JetNodeTypes.NULL) {
+        if (expression instanceof KtConstantExpression) {
+            KtConstantExpression constantExpression = (KtConstantExpression) expression;
+            if (constantExpression.getNode().getElementType() == KtNodeTypes.NULL) {
                 return DataFlowValue.nullValue(DescriptorUtilsKt.getBuiltIns(containingDeclarationOrModule));
             }
         }
@@ -84,7 +84,7 @@ public class DataFlowValueFactory {
             return DataFlowValue.nullValue(DescriptorUtilsKt.getBuiltIns(containingDeclarationOrModule)); // 'null' is the only inhabitant of 'Nothing?'
         }
 
-        if (ExpressionTypingUtils.isExclExclExpression(JetPsiUtil.deparenthesize(expression))) {
+        if (ExpressionTypingUtils.isExclExclExpression(KtPsiUtil.deparenthesize(expression))) {
             // In most cases type of `E!!`-expression is strictly not nullable and we could get proper Nullability
             // by calling `getImmanentNullability` (as it happens below).
             //
@@ -105,7 +105,7 @@ public class DataFlowValueFactory {
 
     @NotNull
     public static DataFlowValue createDataFlowValue(@NotNull ThisReceiver receiver) {
-        JetType type = receiver.getType();
+        KtType type = receiver.getType();
         return new DataFlowValue(receiver, type, STABLE_VALUE, getImmanentNullability(type));
     }
 
@@ -126,7 +126,7 @@ public class DataFlowValueFactory {
     ) {
         if (receiverValue instanceof TransientReceiver || receiverValue instanceof ScriptReceiver) {
             // SCRIPT: smartcasts data flow
-            JetType type = receiverValue.getType();
+            KtType type = receiverValue.getType();
             return new DataFlowValue(receiverValue, type, STABLE_VALUE, getImmanentNullability(type));
         }
         else if (receiverValue instanceof ClassReceiver || receiverValue instanceof ExtensionReceiver) {
@@ -148,12 +148,12 @@ public class DataFlowValueFactory {
 
     @NotNull
     public static DataFlowValue createDataFlowValueForProperty(
-            @NotNull JetProperty property,
+            @NotNull KtProperty property,
             @NotNull VariableDescriptor variableDescriptor,
             @NotNull BindingContext bindingContext,
             @Nullable ModuleDescriptor usageContainingModule
     ) {
-        JetType type = variableDescriptor.getType();
+        KtType type = variableDescriptor.getType();
         return new DataFlowValue(variableDescriptor, type,
                                  variableKind(variableDescriptor, usageContainingModule,
                                               bindingContext, property),
@@ -161,7 +161,7 @@ public class DataFlowValueFactory {
     }
 
     @NotNull
-    private static Nullability getImmanentNullability(@NotNull JetType type) {
+    private static Nullability getImmanentNullability(@NotNull KtType type) {
         return TypeUtils.isNullableType(type) ? Nullability.UNKNOWN : Nullability.NOT_NULL;
     }
 
@@ -215,7 +215,7 @@ public class DataFlowValueFactory {
     }
 
     @NotNull
-    private static IdentifierInfo createPostfixInfo(@NotNull JetPostfixExpression expression, @NotNull IdentifierInfo argumentInfo) {
+    private static IdentifierInfo createPostfixInfo(@NotNull KtPostfixExpression expression, @NotNull IdentifierInfo argumentInfo) {
         if (argumentInfo == NO_IDENTIFIER_INFO) {
             return NO_IDENTIFIER_INFO;
         }
@@ -224,43 +224,43 @@ public class DataFlowValueFactory {
 
     @NotNull
     private static IdentifierInfo getIdForStableIdentifier(
-            @Nullable JetExpression expression,
+            @Nullable KtExpression expression,
             @NotNull BindingContext bindingContext,
             @NotNull DeclarationDescriptor containingDeclarationOrModule
     ) {
         if (expression != null) {
-            JetExpression deparenthesized = JetPsiUtil.deparenthesize(expression);
+            KtExpression deparenthesized = KtPsiUtil.deparenthesize(expression);
             if (expression != deparenthesized) {
                 return getIdForStableIdentifier(deparenthesized, bindingContext, containingDeclarationOrModule);
             }
         }
-        if (expression instanceof JetQualifiedExpression) {
-            JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) expression;
-            JetExpression receiverExpression = qualifiedExpression.getReceiverExpression();
-            JetExpression selectorExpression = qualifiedExpression.getSelectorExpression();
+        if (expression instanceof KtQualifiedExpression) {
+            KtQualifiedExpression qualifiedExpression = (KtQualifiedExpression) expression;
+            KtExpression receiverExpression = qualifiedExpression.getReceiverExpression();
+            KtExpression selectorExpression = qualifiedExpression.getSelectorExpression();
             IdentifierInfo receiverId = getIdForStableIdentifier(receiverExpression, bindingContext, containingDeclarationOrModule);
             IdentifierInfo selectorId = getIdForStableIdentifier(selectorExpression, bindingContext, containingDeclarationOrModule);
 
             return combineInfo(receiverId, selectorId);
         }
-        if (expression instanceof JetSimpleNameExpression) {
-            return getIdForSimpleNameExpression((JetSimpleNameExpression) expression, bindingContext, containingDeclarationOrModule);
+        if (expression instanceof KtSimpleNameExpression) {
+            return getIdForSimpleNameExpression((KtSimpleNameExpression) expression, bindingContext, containingDeclarationOrModule);
         }
-        else if (expression instanceof JetThisExpression) {
-            JetThisExpression thisExpression = (JetThisExpression) expression;
+        else if (expression instanceof KtThisExpression) {
+            KtThisExpression thisExpression = (KtThisExpression) expression;
             DeclarationDescriptor declarationDescriptor = bindingContext.get(REFERENCE_TARGET, thisExpression.getInstanceReference());
 
             return getIdForThisReceiver(declarationDescriptor);
         }
-        else if (expression instanceof JetPostfixExpression) {
-            JetPostfixExpression postfixExpression = (JetPostfixExpression) expression;
+        else if (expression instanceof KtPostfixExpression) {
+            KtPostfixExpression postfixExpression = (KtPostfixExpression) expression;
             IElementType operationType = postfixExpression.getOperationReference().getReferencedNameElementType();
-            if (operationType == JetTokens.PLUSPLUS || operationType == JetTokens.MINUSMINUS) {
+            if (operationType == KtTokens.PLUSPLUS || operationType == KtTokens.MINUSMINUS) {
                 return createPostfixInfo(postfixExpression,
                         getIdForStableIdentifier(postfixExpression.getBaseExpression(), bindingContext, containingDeclarationOrModule));
             }
         }
-        else if (expression instanceof JetRootPackageExpression) {
+        else if (expression instanceof KtRootPackageExpression) {
             //todo return createPackageInfo());
         }
         return NO_IDENTIFIER_INFO;
@@ -268,7 +268,7 @@ public class DataFlowValueFactory {
 
     @NotNull
     private static IdentifierInfo getIdForSimpleNameExpression(
-            @NotNull JetSimpleNameExpression simpleNameExpression,
+            @NotNull KtSimpleNameExpression simpleNameExpression,
             @NotNull BindingContext bindingContext,
             @NotNull DeclarationDescriptor containingDeclarationOrModule
     ) {
@@ -297,7 +297,7 @@ public class DataFlowValueFactory {
     }
 
     @Nullable
-    private static IdentifierInfo getIdForImplicitReceiver(@NotNull ReceiverValue receiverValue, @Nullable JetExpression expression) {
+    private static IdentifierInfo getIdForImplicitReceiver(@NotNull ReceiverValue receiverValue, @Nullable KtExpression expression) {
         if (receiverValue instanceof ThisReceiver) {
             return getIdForThisReceiver(((ThisReceiver) receiverValue).getDeclarationDescriptor());
         }
@@ -340,12 +340,12 @@ public class DataFlowValueFactory {
     private static boolean isAccessedInsideClosure(
             @NotNull DeclarationDescriptor variableContainingDeclaration,
             @NotNull BindingContext bindingContext,
-            @NotNull JetElement accessElement
+            @NotNull KtElement accessElement
     ) {
         PsiElement parent = accessElement.getParent();
         while (parent != null) {
             // We are inside some declaration
-            if (parent instanceof JetDeclarationWithBody || parent instanceof JetClassOrObject) {
+            if (parent instanceof KtDeclarationWithBody || parent instanceof KtClassOrObject) {
                 DeclarationDescriptor descriptor = bindingContext.get(DECLARATION_TO_DESCRIPTOR, parent);
                 if (variableContainingDeclaration.equals(descriptor)) {
                     // Access is at the same declaration: not in closure
@@ -363,13 +363,13 @@ public class DataFlowValueFactory {
 
     private static boolean isAccessedBeforeAllClosureWriters(
             @NotNull DeclarationDescriptor variableContainingDeclaration,
-            @NotNull Set<JetDeclaration> writers,
+            @NotNull Set<KtDeclaration> writers,
             @NotNull BindingContext bindingContext,
-            @NotNull JetElement accessElement
+            @NotNull KtElement accessElement
     ) {
         // All writers should be before access element, with the exception:
         // writer which is the same with declaration site does not count
-        for (JetDeclaration writer : writers) {
+        for (KtDeclaration writer : writers) {
             DeclarationDescriptor writerDescriptor = bindingContext.get(DECLARATION_TO_DESCRIPTOR, writer);
             // Access is after some writer
             if (!variableContainingDeclaration.equals(writerDescriptor) && !PsiUtilsKt.before(accessElement, writer)) {
@@ -384,7 +384,7 @@ public class DataFlowValueFactory {
             @NotNull VariableDescriptor variableDescriptor,
             @Nullable ModuleDescriptor usageModule,
             @NotNull BindingContext bindingContext,
-            @NotNull JetElement accessElement
+            @NotNull KtElement accessElement
     ) {
         if (isStableValue(variableDescriptor, usageModule)) return STABLE_VALUE;
         boolean isLocalVar = variableDescriptor.isVar() && variableDescriptor instanceof LocalVariableDescriptor;
@@ -399,7 +399,7 @@ public class DataFlowValueFactory {
 
         // Analyze who writes variable
         // If there is no writer: predictable
-        Set<JetDeclaration> writers = preliminaryVisitor.writers(variableDescriptor);
+        Set<KtDeclaration> writers = preliminaryVisitor.writers(variableDescriptor);
         if (writers.isEmpty()) return PREDICTABLE_VARIABLE;
 
         // If access element is inside closure: unpredictable
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DelegatingDataFlowInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DelegatingDataFlowInfo.java
index 28bada2ee94..8474870ddef 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DelegatingDataFlowInfo.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DelegatingDataFlowInfo.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve.calls.smartcasts;
 import com.google.common.collect.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 
 import java.util.HashSet;
@@ -31,7 +31,7 @@ import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL
 
 /* package */ class DelegatingDataFlowInfo implements DataFlowInfo {
     private static final ImmutableMap<DataFlowValue, Nullability> EMPTY_NULLABILITY_INFO = ImmutableMap.of();
-    private static final SetMultimap<DataFlowValue, JetType> EMPTY_TYPE_INFO = newTypeInfo();
+    private static final SetMultimap<DataFlowValue, KtType> EMPTY_TYPE_INFO = newTypeInfo();
 
     @Nullable
     private final DataFlowInfo parent;
@@ -41,7 +41,7 @@ import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL
 
     // Also immutable
     @NotNull
-    private final SetMultimap<DataFlowValue, JetType> typeInfo;
+    private final SetMultimap<DataFlowValue, KtType> typeInfo;
 
     /**
      * Value for which type info was cleared or reassigned at this point
@@ -53,7 +53,7 @@ import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL
     /* package */ DelegatingDataFlowInfo(
             @Nullable DataFlowInfo parent,
             @NotNull ImmutableMap<DataFlowValue, Nullability> nullabilityInfo,
-            @NotNull SetMultimap<DataFlowValue, JetType> typeInfo
+            @NotNull SetMultimap<DataFlowValue, KtType> typeInfo
     ) {
         this(parent, nullabilityInfo, typeInfo, null);
     }
@@ -61,7 +61,7 @@ import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL
     /* package */ DelegatingDataFlowInfo(
             @Nullable DataFlowInfo parent,
             @NotNull ImmutableMap<DataFlowValue, Nullability> nullabilityInfo,
-            @NotNull SetMultimap<DataFlowValue, JetType> typeInfo,
+            @NotNull SetMultimap<DataFlowValue, KtType> typeInfo,
             @Nullable DataFlowValue valueWithGivenTypeInfo
     ) {
         this.parent = parent;
@@ -90,8 +90,8 @@ import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL
 
     @Override
     @NotNull
-    public SetMultimap<DataFlowValue, JetType> getCompleteTypeInfo() {
-        SetMultimap<DataFlowValue, JetType> result = newTypeInfo();
+    public SetMultimap<DataFlowValue, KtType> getCompleteTypeInfo() {
+        SetMultimap<DataFlowValue, KtType> result = newTypeInfo();
         Set<DataFlowValue> withGivenTypeInfo = new HashSet<DataFlowValue>();
         DelegatingDataFlowInfo info = this;
         while (info != null) {
@@ -130,18 +130,18 @@ import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL
 
     @Override
     @NotNull
-    public Set<JetType> getPossibleTypes(@NotNull DataFlowValue key) {
-        JetType originalType = key.getType();
-        Set<JetType> types = collectTypesFromMeAndParents(key);
+    public Set<KtType> getPossibleTypes(@NotNull DataFlowValue key) {
+        KtType originalType = key.getType();
+        Set<KtType> types = collectTypesFromMeAndParents(key);
         if (getNullability(key).canBeNull()) {
             return types;
         }
 
-        Set<JetType> enrichedTypes = Sets.newHashSetWithExpectedSize(types.size() + 1);
+        Set<KtType> enrichedTypes = Sets.newHashSetWithExpectedSize(types.size() + 1);
         if (originalType.isMarkedNullable()) {
             enrichedTypes.add(TypeUtils.makeNotNullable(originalType));
         }
-        for (JetType type : types) {
+        for (KtType type : types) {
             enrichedTypes.add(TypeUtils.makeNotNullable(type));
         }
 
@@ -174,8 +174,8 @@ import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL
         Nullability nullabilityOfB = getNullability(b);
         putNullability(nullability, a, nullabilityOfB);
 
-        SetMultimap<DataFlowValue, JetType> newTypeInfo = newTypeInfo();
-        Set<JetType> typesForB = collectTypesFromMeAndParents(b);
+        SetMultimap<DataFlowValue, KtType> newTypeInfo = newTypeInfo();
+        Set<KtType> typesForB = collectTypesFromMeAndParents(b);
         // Own type of B must be recorded separately, e.g. for a constant
         // But if its type is the same as A or it's null, there is no reason to do it
         // because usually null type or own type are not saved in this set
@@ -203,7 +203,7 @@ import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL
         changed |= putNullability(builder, a, nullabilityOfA.refine(nullabilityOfB));
         changed |= putNullability(builder, b, nullabilityOfB.refine(nullabilityOfA));
 
-        SetMultimap<DataFlowValue, JetType> newTypeInfo = newTypeInfo();
+        SetMultimap<DataFlowValue, KtType> newTypeInfo = newTypeInfo();
         newTypeInfo.putAll(a, collectTypesFromMeAndParents(b));
         newTypeInfo.putAll(b, collectTypesFromMeAndParents(a));
         changed |= !newTypeInfo.isEmpty();
@@ -218,8 +218,8 @@ import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL
     }
 
     @NotNull
-    private Set<JetType> collectTypesFromMeAndParents(@NotNull DataFlowValue value) {
-        Set<JetType> types = new LinkedHashSet<JetType>();
+    private Set<KtType> collectTypesFromMeAndParents(@NotNull DataFlowValue value) {
+        Set<KtType> types = new LinkedHashSet<KtType>();
 
         DataFlowInfo current = this;
         while (current != null) {
@@ -257,12 +257,12 @@ import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL
 
     @Override
     @NotNull
-    public DataFlowInfo establishSubtyping(@NotNull DataFlowValue value, @NotNull JetType type) {
+    public DataFlowInfo establishSubtyping(@NotNull DataFlowValue value, @NotNull KtType type) {
         if (value.getType().equals(type)) return this;
         if (getPossibleTypes(value).contains(type)) return this;
         ImmutableMap<DataFlowValue, Nullability> newNullabilityInfo =
                 type.isMarkedNullable() ? EMPTY_NULLABILITY_INFO : ImmutableMap.of(value, NOT_NULL);
-        SetMultimap<DataFlowValue, JetType> newTypeInfo = ImmutableSetMultimap.of(value, type);
+        SetMultimap<DataFlowValue, KtType> newTypeInfo = ImmutableSetMultimap.of(value, type);
         return new DelegatingDataFlowInfo(this, newNullabilityInfo, newTypeInfo);
     }
 
@@ -287,8 +287,8 @@ import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL
             }
         }
 
-        SetMultimap<DataFlowValue, JetType> myTypeInfo = getCompleteTypeInfo();
-        SetMultimap<DataFlowValue, JetType> otherTypeInfo = other.getCompleteTypeInfo();
+        SetMultimap<DataFlowValue, KtType> myTypeInfo = getCompleteTypeInfo();
+        SetMultimap<DataFlowValue, KtType> otherTypeInfo = other.getCompleteTypeInfo();
         if (nullabilityMapBuilder.isEmpty() && containsAll(myTypeInfo, otherTypeInfo)) {
             return this;
         }
@@ -296,7 +296,7 @@ import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL
         return new DelegatingDataFlowInfo(this, ImmutableMap.copyOf(nullabilityMapBuilder), otherTypeInfo);
     }
 
-    private static boolean containsAll(SetMultimap<DataFlowValue, JetType> first, SetMultimap<DataFlowValue, JetType> second) {
+    private static boolean containsAll(SetMultimap<DataFlowValue, KtType> first, SetMultimap<DataFlowValue, KtType> second) {
         return first.entries().containsAll(second.entries());
     }
 
@@ -318,13 +318,13 @@ import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL
             nullabilityMapBuilder.put(key, thisFlags.or(otherFlags));
         }
 
-        SetMultimap<DataFlowValue, JetType> myTypeInfo = getCompleteTypeInfo();
-        SetMultimap<DataFlowValue, JetType> otherTypeInfo = other.getCompleteTypeInfo();
-        SetMultimap<DataFlowValue, JetType> newTypeInfo = newTypeInfo();
+        SetMultimap<DataFlowValue, KtType> myTypeInfo = getCompleteTypeInfo();
+        SetMultimap<DataFlowValue, KtType> otherTypeInfo = other.getCompleteTypeInfo();
+        SetMultimap<DataFlowValue, KtType> newTypeInfo = newTypeInfo();
 
         for (DataFlowValue key : Sets.intersection(myTypeInfo.keySet(), otherTypeInfo.keySet())) {
-            Set<JetType> thisTypes = myTypeInfo.get(key);
-            Set<JetType> otherTypes = otherTypeInfo.get(key);
+            Set<KtType> thisTypes = myTypeInfo.get(key);
+            Set<KtType> otherTypes = otherTypeInfo.get(key);
             newTypeInfo.putAll(key, Sets.intersection(thisTypes, otherTypes));
         }
 
@@ -336,7 +336,7 @@ import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL
     }
 
     @NotNull
-    /* package */ static SetMultimap<DataFlowValue, JetType> newTypeInfo() {
+    /* package */ static SetMultimap<DataFlowValue, KtType> newTypeInfo() {
         return LinkedHashMultimap.create();
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/SmartCastManager.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/SmartCastManager.java
index 28583d7b1af..d78f2fee9fc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/SmartCastManager.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/SmartCastManager.java
@@ -23,16 +23,16 @@ import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeIntersector;
 import org.jetbrains.kotlin.types.TypeUtils;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.Collection;
 import java.util.List;
@@ -44,7 +44,7 @@ import static org.jetbrains.kotlin.resolve.BindingContext.SMARTCAST;
 public class SmartCastManager {
 
     @NotNull
-    public List<JetType> getSmartCastVariants(
+    public List<KtType> getSmartCastVariants(
             @NotNull ReceiverValue receiverToCast,
             @NotNull ResolutionContext context
     ) {
@@ -52,34 +52,34 @@ public class SmartCastManager {
     }
 
     @NotNull
-    public List<JetType> getSmartCastVariants(
+    public List<KtType> getSmartCastVariants(
             @NotNull ReceiverValue receiverToCast,
             @NotNull BindingContext bindingContext,
             @NotNull DeclarationDescriptor containingDeclarationOrModule,
             @NotNull DataFlowInfo dataFlowInfo
     ) {
-        List<JetType> variants = Lists.newArrayList();
+        List<KtType> variants = Lists.newArrayList();
         variants.add(receiverToCast.getType());
         variants.addAll(getSmartCastVariantsExcludingReceiver(bindingContext, containingDeclarationOrModule, dataFlowInfo, receiverToCast));
         return variants;
     }
 
     @NotNull
-    public List<JetType> getSmartCastVariantsWithLessSpecificExcluded(
+    public List<KtType> getSmartCastVariantsWithLessSpecificExcluded(
             @NotNull ReceiverValue receiverToCast,
             @NotNull BindingContext bindingContext,
             @NotNull DeclarationDescriptor containingDeclarationOrModule,
             @NotNull DataFlowInfo dataFlowInfo
     ) {
-        final List<JetType> variants = getSmartCastVariants(receiverToCast, bindingContext,
-                                                            containingDeclarationOrModule, dataFlowInfo);
-        return CollectionsKt.filter(variants, new Function1<JetType, Boolean>() {
+        final List<KtType> variants = getSmartCastVariants(receiverToCast, bindingContext,
+                                                           containingDeclarationOrModule, dataFlowInfo);
+        return CollectionsKt.filter(variants, new Function1<KtType, Boolean>() {
             @Override
-            public Boolean invoke(final JetType type) {
-                return !CollectionsKt.any(variants, new Function1<JetType, Boolean>() {
+            public Boolean invoke(final KtType type) {
+                return !CollectionsKt.any(variants, new Function1<KtType, Boolean>() {
                     @Override
-                    public Boolean invoke(JetType another) {
-                        return another != type && JetTypeChecker.DEFAULT.isSubtypeOf(another, type);
+                    public Boolean invoke(KtType another) {
+                        return another != type && KotlinTypeChecker.DEFAULT.isSubtypeOf(another, type);
                     }
                 });
             }
@@ -90,7 +90,7 @@ public class SmartCastManager {
      * @return variants @param receiverToCast may be cast to according to context dataFlowInfo, receiverToCast itself is NOT included
      */
     @NotNull
-    public Collection<JetType> getSmartCastVariantsExcludingReceiver(
+    public Collection<KtType> getSmartCastVariantsExcludingReceiver(
             @NotNull ResolutionContext context,
             @NotNull ReceiverValue receiverToCast
     ) {
@@ -104,7 +104,7 @@ public class SmartCastManager {
      * @return variants @param receiverToCast may be cast to according to @param dataFlowInfo, @param receiverToCast itself is NOT included
      */
     @NotNull
-    public Collection<JetType> getSmartCastVariantsExcludingReceiver(
+    public Collection<KtType> getSmartCastVariantsExcludingReceiver(
             @NotNull BindingContext bindingContext,
             @NotNull DeclarationDescriptor containingDeclarationOrModule,
             @NotNull DataFlowInfo dataFlowInfo,
@@ -119,27 +119,27 @@ public class SmartCastManager {
 
     public boolean isSubTypeBySmartCastIgnoringNullability(
             @NotNull ReceiverValue receiverArgument,
-            @NotNull JetType receiverParameterType,
+            @NotNull KtType receiverParameterType,
             @NotNull ResolutionContext context
     ) {
-        List<JetType> smartCastTypes = getSmartCastVariants(receiverArgument, context);
+        List<KtType> smartCastTypes = getSmartCastVariants(receiverArgument, context);
         return getSmartCastSubType(TypeUtils.makeNullable(receiverParameterType), smartCastTypes) != null;
     }
 
     @Nullable
-    private JetType getSmartCastSubType(
-            @NotNull JetType receiverParameterType,
-            @NotNull Collection<JetType> smartCastTypes
+    private KtType getSmartCastSubType(
+            @NotNull KtType receiverParameterType,
+            @NotNull Collection<KtType> smartCastTypes
     ) {
-        Set<JetType> subTypes = Sets.newHashSet();
-        for (JetType smartCastType : smartCastTypes) {
+        Set<KtType> subTypes = Sets.newHashSet();
+        for (KtType smartCastType : smartCastTypes) {
             if (ArgumentTypeResolver.isSubtypeOfForArgumentType(smartCastType, receiverParameterType)) {
                 subTypes.add(smartCastType);
             }
         }
         if (subTypes.isEmpty()) return null;
 
-        JetType intersection = TypeIntersector.intersectTypes(JetTypeChecker.DEFAULT, subTypes);
+        KtType intersection = TypeIntersector.intersectTypes(KotlinTypeChecker.DEFAULT, subTypes);
         if (intersection == null || !intersection.getConstructor().isDenotable()) {
             return receiverParameterType;
         }
@@ -147,8 +147,8 @@ public class SmartCastManager {
     }
 
     private static void recordCastOrError(
-            @NotNull JetExpression expression,
-            @NotNull JetType type,
+            @NotNull KtExpression expression,
+            @NotNull KtType type,
             @NotNull BindingTrace trace,
             boolean canBeCast,
             boolean recordExpressionType
@@ -169,12 +169,12 @@ public class SmartCastManager {
     @Nullable
     public SmartCastResult checkAndRecordPossibleCast(
             @NotNull DataFlowValue dataFlowValue,
-            @NotNull JetType expectedType,
-            @Nullable JetExpression expression,
+            @NotNull KtType expectedType,
+            @Nullable KtExpression expression,
             @NotNull ResolutionContext c,
             boolean recordExpressionType
     ) {
-        for (JetType possibleType : c.dataFlowInfo.getPossibleTypes(dataFlowValue)) {
+        for (KtType possibleType : c.dataFlowInfo.getPossibleTypes(dataFlowValue)) {
             if (ArgumentTypeResolver.isSubtypeOfForArgumentType(possibleType, expectedType)) {
                 if (expression != null) {
                     recordCastOrError(expression, possibleType, c.trace, dataFlowValue.isPredictable(), recordExpressionType);
@@ -198,7 +198,7 @@ public class SmartCastManager {
             // E.g. in case x!! when x has type of T where T is type parameter with nullable upper bounds
             // x!! is immanently not null (see DataFlowValueFactory.createDataFlowValue for expression)
             boolean immanentlyNotNull = !dataFlowValue.getImmanentNullability().canBeNull();
-            JetType nullableExpectedType = TypeUtils.makeNullable(expectedType);
+            KtType nullableExpectedType = TypeUtils.makeNullable(expectedType);
 
             if (ArgumentTypeResolver.isSubtypeOfForArgumentType(dataFlowValue.getType(), nullableExpectedType)) {
                 if (!immanentlyNotNull) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/SmartCastResult.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/SmartCastResult.kt
index 546d7fdd092..643e31f48ed 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/SmartCastResult.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/SmartCastResult.kt
@@ -16,6 +16,6 @@
 
 package org.jetbrains.kotlin.resolve.calls.smartcasts
 
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
-public class SmartCastResult(public val resultType: JetType, public val isCorrect: Boolean)
+public class SmartCastResult(public val resultType: KtType, public val isCorrect: Boolean)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/AbstractTracingStrategy.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/AbstractTracingStrategy.java
index e35b5294805..fb68ba5754f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/AbstractTracingStrategy.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/AbstractTracingStrategy.java
@@ -21,8 +21,8 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.lexer.JetToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.Variance;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
 
@@ -50,10 +50,10 @@ import static org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.Co
 import static org.jetbrains.kotlin.types.TypeUtils.noExpectedType;
 
 public abstract class AbstractTracingStrategy implements TracingStrategy {
-    protected final JetExpression reference;
+    protected final KtExpression reference;
     protected final Call call;
 
-    protected AbstractTracingStrategy(@NotNull JetExpression reference, @NotNull Call call) {
+    protected AbstractTracingStrategy(@NotNull KtExpression reference, @NotNull Call call) {
         this.reference = reference;
         this.call = call;
     }
@@ -69,7 +69,7 @@ public abstract class AbstractTracingStrategy implements TracingStrategy {
 
     @Override
     public void noValueForParameter(@NotNull BindingTrace trace, @NotNull ValueParameterDescriptor valueParameter) {
-        JetElement reportOn = CallUtilKt.getValueArgumentListOrElement(call);
+        KtElement reportOn = CallUtilKt.getValueArgumentListOrElement(call);
         trace.report(NO_VALUE_FOR_PARAMETER.on(reportOn, valueParameter));
     }
 
@@ -96,7 +96,7 @@ public abstract class AbstractTracingStrategy implements TracingStrategy {
 
     @Override
     public void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount) {
-        JetTypeArgumentList typeArgumentList = call.getTypeArgumentList();
+        KtTypeArgumentList typeArgumentList = call.getTypeArgumentList();
         if (typeArgumentList != null) {
             trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(typeArgumentList, expectedTypeArgumentCount));
         }
@@ -144,7 +144,7 @@ public abstract class AbstractTracingStrategy implements TracingStrategy {
             if (DescriptorUtils.getFqName(importableDescriptor).isSafe()) {
                 FqName fqName = getFqNameFromTopLevelClass(importableDescriptor);
                 String qualifiedName;
-                if (reference.getParent() instanceof JetCallableReferenceExpression) {
+                if (reference.getParent() instanceof KtCallableReferenceExpression) {
                     qualifiedName = fqName.parent() + "::" + classDescriptor.getName();
                 }
                 else {
@@ -158,23 +158,23 @@ public abstract class AbstractTracingStrategy implements TracingStrategy {
     }
 
     @Override
-    public void unsafeCall(@NotNull BindingTrace trace, @NotNull JetType type, boolean isCallForImplicitInvoke) {
+    public void unsafeCall(@NotNull BindingTrace trace, @NotNull KtType type, boolean isCallForImplicitInvoke) {
         ASTNode callOperationNode = call.getCallOperationNode();
         if (callOperationNode != null && !isCallForImplicitInvoke) {
             trace.report(UNSAFE_CALL.on(callOperationNode.getPsi(), type));
         }
         else {
             PsiElement callElement = call.getCallElement();
-            if (callElement instanceof JetBinaryExpression) {
-                JetBinaryExpression binaryExpression = (JetBinaryExpression)callElement;
-                JetSimpleNameExpression operationReference = binaryExpression.getOperationReference();
+            if (callElement instanceof KtBinaryExpression) {
+                KtBinaryExpression binaryExpression = (KtBinaryExpression)callElement;
+                KtSimpleNameExpression operationReference = binaryExpression.getOperationReference();
 
-                Name operationString = operationReference.getReferencedNameElementType() == JetTokens.IDENTIFIER ?
+                Name operationString = operationReference.getReferencedNameElementType() == KtTokens.IDENTIFIER ?
                                        Name.identifier(operationReference.getText()) :
-                                       OperatorConventions.getNameForOperationSymbol((JetToken) operationReference.getReferencedNameElementType());
+                                       OperatorConventions.getNameForOperationSymbol((KtToken) operationReference.getReferencedNameElementType());
 
-                JetExpression left = binaryExpression.getLeft();
-                JetExpression right = binaryExpression.getRight();
+                KtExpression left = binaryExpression.getLeft();
+                KtExpression right = binaryExpression.getRight();
                 if (left != null && right != null) {
                     trace.report(UNSAFE_INFIX_CALL.on(reference, left.getText(), operationString.asString(), right.getText()));
                 }
@@ -186,11 +186,11 @@ public abstract class AbstractTracingStrategy implements TracingStrategy {
     }
 
     @Override
-    public void unnecessarySafeCall(@NotNull BindingTrace trace, @NotNull JetType type) {
+    public void unnecessarySafeCall(@NotNull BindingTrace trace, @NotNull KtType type) {
         ASTNode callOperationNode = call.getCallOperationNode();
         assert callOperationNode != null;
         ReceiverValue explicitReceiver = call.getExplicitReceiver();
-        if (explicitReceiver instanceof ExpressionReceiver && ((ExpressionReceiver)explicitReceiver).getExpression() instanceof JetSuperExpression) {
+        if (explicitReceiver instanceof ExpressionReceiver && ((ExpressionReceiver)explicitReceiver).getExpression() instanceof KtSuperExpression) {
             trace.report(UNEXPECTED_SAFE_CALL.on(callOperationNode.getPsi()));
         }
         else {
@@ -215,12 +215,12 @@ public abstract class AbstractTracingStrategy implements TracingStrategy {
             return;
         }
         if (status.hasOnlyErrorsDerivedFrom(EXPECTED_TYPE_POSITION)) {
-            JetType declaredReturnType = data.descriptor.getReturnType();
+            KtType declaredReturnType = data.descriptor.getReturnType();
             if (declaredReturnType == null) return;
 
             ConstraintSystem systemWithoutExpectedTypeConstraint =
                     ((ConstraintSystemImpl) constraintSystem).filterConstraintsOut(EXPECTED_TYPE_POSITION);
-            JetType substitutedReturnType = systemWithoutExpectedTypeConstraint.getResultingSubstitutor().substitute(
+            KtType substitutedReturnType = systemWithoutExpectedTypeConstraint.getResultingSubstitutor().substitute(
                     declaredReturnType, Variance.OUT_VARIANCE);
             assert substitutedReturnType != null; //todo
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt
index d09e120e4af..9b37f43ce56 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt
@@ -26,13 +26,13 @@ import org.jetbrains.kotlin.resolve.LibrarySourceHacks
 import org.jetbrains.kotlin.resolve.calls.tasks.createSynthesizedInvokes
 import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasClassObjectType
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.LexicalChainedScope
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.resolve.scopes.utils.collectAllFromMeAndParent
 import org.jetbrains.kotlin.resolve.scopes.utils.getLocalVariable
 import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.kotlin.utils.singletonOrEmptyList
 
@@ -40,16 +40,16 @@ public interface CallableDescriptorCollector<D : CallableDescriptor> {
 
     public fun getLocalNonExtensionsByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection<D>
 
-    public fun getNonExtensionsByName(scope: JetScope, name: Name, location: LookupLocation): Collection<D>
+    public fun getNonExtensionsByName(scope: KtScope, name: Name, location: LookupLocation): Collection<D>
 
     // todo this is hack for static members priority
     public fun getStaticInheritanceByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection<D>
 
-    public fun getMembersByName(receiver: JetType, name: Name, location: LookupLocation): Collection<D>
+    public fun getMembersByName(receiver: KtType, name: Name, location: LookupLocation): Collection<D>
 
-    public fun getStaticMembersByName(receiver: JetType, name: Name, location: LookupLocation): Collection<D>
+    public fun getStaticMembersByName(receiver: KtType, name: Name, location: LookupLocation): Collection<D>
 
-    public fun getExtensionsByName(scope: JetScope, name: Name, receiverTypes: Collection<JetType>, location: LookupLocation): Collection<D>
+    public fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection<KtType>, location: LookupLocation): Collection<D>
 }
 
 private fun <D : CallableDescriptor> CallableDescriptorCollector<D>.withDefaultFilter() = filtered { !LibrarySourceHacks.shouldSkip(it) }
@@ -103,11 +103,11 @@ private object FunctionCollector : CallableDescriptorCollector<FunctionDescripto
         }
     }
 
-    override fun getNonExtensionsByName(scope: JetScope, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
+    override fun getNonExtensionsByName(scope: KtScope, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
         return scope.getFunctions(name, location).filter { it.extensionReceiverParameter == null } + getConstructors(scope, name, location)
     }
 
-    override fun getMembersByName(receiver: JetType, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
+    override fun getMembersByName(receiver: KtType, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
         val receiverScope = receiver.memberScope
         val members = receiverScope.getFunctions(name, location)
         val constructors = getConstructors(receiverScope, name, location, { !isStaticNestedClass(it) })
@@ -125,11 +125,11 @@ private object FunctionCollector : CallableDescriptorCollector<FunctionDescripto
         return members + constructors
     }
 
-    override fun getStaticMembersByName(receiver: JetType, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
+    override fun getStaticMembersByName(receiver: KtType, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
         return getConstructors(receiver.memberScope, name, location, { isStaticNestedClass(it) })
     }
 
-    override fun getExtensionsByName(scope: JetScope, name: Name, receiverTypes: Collection<JetType>, location: LookupLocation): Collection<FunctionDescriptor> {
+    override fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection<KtType>, location: LookupLocation): Collection<FunctionDescriptor> {
         val functions = scope.getFunctions(name, location)
         val (extensions, nonExtensions) = functions.partition { it.extensionReceiverParameter != null }
         val syntheticExtensions = scope.getSyntheticExtensionFunctions(receiverTypes, name, location)
@@ -143,7 +143,7 @@ private object FunctionCollector : CallableDescriptorCollector<FunctionDescripto
     }
 
     private fun getConstructors(
-            scope: JetScope, name: Name,
+            scope: KtScope, name: Name,
             location: LookupLocation,
             filterClassPredicate: (ClassDescriptor) -> Boolean = { true }
     ): Collection<FunctionDescriptor> {
@@ -182,14 +182,14 @@ private object VariableCollector : CallableDescriptorCollector<VariableDescripto
         }
     }
 
-    private fun getFakeDescriptorForObject(scope: JetScope, name: Name, location: LookupLocation): VariableDescriptor? {
+    private fun getFakeDescriptorForObject(scope: KtScope, name: Name, location: LookupLocation): VariableDescriptor? {
         val classifier = scope.getClassifier(name, location)
         if (classifier !is ClassDescriptor || !classifier.hasClassObjectType) return null
 
         return FakeCallableDescriptorForObject(classifier)
     }
 
-    override fun getNonExtensionsByName(scope: JetScope, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
+    override fun getNonExtensionsByName(scope: KtScope, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
         val localVariable = scope.getLocalVariable(name)
         if (localVariable != null) {
             return setOf(localVariable)
@@ -199,18 +199,18 @@ private object VariableCollector : CallableDescriptorCollector<VariableDescripto
         return if (fakeDescriptor != null) properties + fakeDescriptor else properties
     }
 
-    override fun getMembersByName(receiver: JetType, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
+    override fun getMembersByName(receiver: KtType, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
         val memberScope = receiver.memberScope
         val properties = memberScope.getProperties(name, location)
         val fakeDescriptor = getFakeDescriptorForObject(memberScope, name, location)
         return if (fakeDescriptor != null) properties + fakeDescriptor else properties
     }
 
-    override fun getStaticMembersByName(receiver: JetType, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
+    override fun getStaticMembersByName(receiver: KtType, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
         return listOf()
     }
 
-    override fun getExtensionsByName(scope: JetScope, name: Name, receiverTypes: Collection<JetType>, location: LookupLocation): Collection<VariableDescriptor> {
+    override fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection<KtType>, location: LookupLocation): Collection<VariableDescriptor> {
         // property may have an extension function type, we check the applicability later to avoid an early computing of deferred types
         return scope.getLocalVariable(name).singletonOrEmptyList() +
                scope.getProperties(name, location) +
@@ -232,19 +232,19 @@ private object PropertyCollector : CallableDescriptorCollector<VariableDescripto
         return filterProperties(VARIABLES_COLLECTOR.getStaticInheritanceByName(lexicalScope, name, location))
     }
 
-    override fun getNonExtensionsByName(scope: JetScope, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
+    override fun getNonExtensionsByName(scope: KtScope, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
         return filterProperties(VARIABLES_COLLECTOR.getNonExtensionsByName(scope, name, location))
     }
 
-    override fun getMembersByName(receiver: JetType, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
+    override fun getMembersByName(receiver: KtType, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
         return filterProperties(VARIABLES_COLLECTOR.getMembersByName(receiver, name, location))
     }
 
-    override fun getStaticMembersByName(receiver: JetType, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
+    override fun getStaticMembersByName(receiver: KtType, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
         return filterProperties(VARIABLES_COLLECTOR.getStaticMembersByName(receiver, name, location))
     }
 
-    override fun getExtensionsByName(scope: JetScope, name: Name, receiverTypes: Collection<JetType>, location: LookupLocation): Collection<VariableDescriptor> {
+    override fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection<KtType>, location: LookupLocation): Collection<VariableDescriptor> {
         return filterProperties(VARIABLES_COLLECTOR.getExtensionsByName(scope, name, receiverTypes, location))
     }
 
@@ -262,19 +262,19 @@ private fun <D : CallableDescriptor> CallableDescriptorCollector<D>.filtered(fil
             return delegate.getStaticInheritanceByName(lexicalScope, name, location)
         }
 
-        override fun getNonExtensionsByName(scope: JetScope, name: Name, location: LookupLocation): Collection<D> {
+        override fun getNonExtensionsByName(scope: KtScope, name: Name, location: LookupLocation): Collection<D> {
             return delegate.getNonExtensionsByName(scope, name, location).filter(filter)
         }
 
-        override fun getMembersByName(receiver: JetType, name: Name, location: LookupLocation): Collection<D> {
+        override fun getMembersByName(receiver: KtType, name: Name, location: LookupLocation): Collection<D> {
             return delegate.getMembersByName(receiver, name, location).filter(filter)
         }
 
-        override fun getStaticMembersByName(receiver: JetType, name: Name, location: LookupLocation): Collection<D> {
+        override fun getStaticMembersByName(receiver: KtType, name: Name, location: LookupLocation): Collection<D> {
             return delegate.getStaticMembersByName(receiver, name, location).filter(filter)
         }
 
-        override fun getExtensionsByName(scope: JetScope, name: Name, receiverTypes: Collection<JetType>, location: LookupLocation): Collection<D> {
+        override fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection<KtType>, location: LookupLocation): Collection<D> {
             return delegate.getExtensionsByName(scope, name, receiverTypes, location).filter(filter)
         }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTask.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTask.java
index 6e598eb2f23..9ecedb0f030 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTask.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTask.java
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments;
 import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collection;
 
@@ -48,7 +48,7 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull Call call,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull ContextDependency contextDependency,
             @NotNull CheckArgumentTypesMode checkArguments,
@@ -101,7 +101,7 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
             @NotNull StatementFilter statementFilter,
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTaskHolder.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTaskHolder.kt
index 7a752254364..2bdafda0a16 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTaskHolder.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTaskHolder.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.resolve.calls.tasks
 
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.psi.JetPsiUtil
+import org.jetbrains.kotlin.psi.KtPsiUtil
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.storage.StorageManager
 import java.util.ArrayList
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt
index dba47b8d488..0c850f81430 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.incremental.KotlinLookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus
 import org.jetbrains.kotlin.psi.Call
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.doNotAnalyze
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getUnaryPlusOrMinusOperatorFunctionName
@@ -50,8 +50,8 @@ import org.jetbrains.kotlin.resolve.scopes.utils.memberScopeAsFileScope
 import org.jetbrains.kotlin.resolve.validation.InfixValidator
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.KtType
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
 import org.jetbrains.kotlin.types.isDynamic
 import org.jetbrains.kotlin.util.OperatorNameConventions
@@ -144,7 +144,7 @@ public class TaskPrioritizer(
             val value: ReceiverValue,
             private val context: ResolutionContext<*>
     ) {
-        val types: Collection<JetType> by lazy { smartCastManager.getSmartCastVariants(value, context) }
+        val types: Collection<KtType> by lazy { smartCastManager.getSmartCastVariants(value, context) }
     }
 
     private fun <D : CallableDescriptor, F : D> addCandidatesForExplicitReceiver(
@@ -341,7 +341,7 @@ public class TaskPrioritizer(
     private fun createLookupLocation(c: TaskPrioritizerContext<*, *>) = KotlinLookupLocation(c.context.call.run {
         calleeExpression?.let {
             // Can't use getContainingJetFile() because we can get from IDE an element with JavaDummyHolder as containing file
-            if ((it.containingFile as? JetFile)?.doNotAnalyze == null) it else null
+            if ((it.containingFile as? KtFile)?.doNotAnalyze == null) it else null
         }
         ?: callElement
     })
@@ -455,7 +455,7 @@ public class TaskPrioritizer(
         if (dispatchReceiver == null) return true
         val receivers = scope.getImplicitReceiversHierarchy()
         for (receiver in receivers) {
-            if (JetTypeChecker.DEFAULT.isSubtypeOf(receiver.getType(), dispatchReceiver.getType())) {
+            if (KotlinTypeChecker.DEFAULT.isSubtypeOf(receiver.getType(), dispatchReceiver.getType())) {
                 // TODO : Smartcasts & nullability
                 candidate.setDispatchReceiver(dispatchReceiver.getValue())
                 return true
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategy.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategy.java
index 17908e21c6d..61f5d9f1b53 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategy.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategy.java
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.calls.inference.InferenceErrorData;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collection;
 
@@ -89,10 +89,10 @@ public interface TracingStrategy {
         ) {}
 
         @Override
-        public void unsafeCall(@NotNull BindingTrace trace, @NotNull JetType type, boolean isCallForImplicitInvoke) {}
+        public void unsafeCall(@NotNull BindingTrace trace, @NotNull KtType type, boolean isCallForImplicitInvoke) {}
 
         @Override
-        public void unnecessarySafeCall(@NotNull BindingTrace trace, @NotNull JetType type) {}
+        public void unnecessarySafeCall(@NotNull BindingTrace trace, @NotNull KtType type) {}
 
         @Override
         public void invisibleMember(@NotNull BindingTrace trace, @NotNull DeclarationDescriptorWithVisibility descriptor) {}
@@ -145,9 +145,9 @@ public interface TracingStrategy {
             @NotNull ExplicitReceiverKind explicitReceiverKind
     );
 
-    void unsafeCall(@NotNull BindingTrace trace, @NotNull JetType type, boolean isCallForImplicitInvoke);
+    void unsafeCall(@NotNull BindingTrace trace, @NotNull KtType type, boolean isCallForImplicitInvoke);
 
-    void unnecessarySafeCall(@NotNull BindingTrace trace, @NotNull JetType type);
+    void unnecessarySafeCall(@NotNull BindingTrace trace, @NotNull KtType type);
 
     void invisibleMember(@NotNull BindingTrace trace, @NotNull DeclarationDescriptorWithVisibility descriptor);
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategyForImplicitConstructorDelegationCall.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategyForImplicitConstructorDelegationCall.kt
index 5d35f96968a..8dd49b1d097 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategyForImplicitConstructorDelegationCall.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategyForImplicitConstructorDelegationCall.kt
@@ -21,9 +21,9 @@ import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.diagnostics.Errors.UNRESOLVED_REFERENCE
 import org.jetbrains.kotlin.diagnostics.Errors.UNRESOLVED_REFERENCE_WRONG_RECEIVER
 import org.jetbrains.kotlin.psi.Call
-import org.jetbrains.kotlin.psi.JetConstructorDelegationCall
-import org.jetbrains.kotlin.psi.JetFunctionLiteralArgument
-import org.jetbrains.kotlin.psi.JetSecondaryConstructor
+import org.jetbrains.kotlin.psi.KtConstructorDelegationCall
+import org.jetbrains.kotlin.psi.KtFunctionLiteralArgument
+import org.jetbrains.kotlin.psi.KtSecondaryConstructor
 import org.jetbrains.kotlin.resolve.BindingContext.CALL
 import org.jetbrains.kotlin.resolve.BindingContext.REFERENCE_TARGET
 import org.jetbrains.kotlin.resolve.BindingContext.RESOLVED_CALL
@@ -32,11 +32,11 @@ import org.jetbrains.kotlin.resolve.calls.inference.InferenceErrorData
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 
 public class TracingStrategyForImplicitConstructorDelegationCall(
-        val delegationCall: JetConstructorDelegationCall, call: Call
+        val delegationCall: KtConstructorDelegationCall, call: Call
 ) : AbstractTracingStrategy(delegationCall.getCalleeExpression()!!, call) {
 
     val calleeExpression = delegationCall.getCalleeExpression()
@@ -109,11 +109,11 @@ public class TracingStrategyForImplicitConstructorDelegationCall(
         unexpectedError("nestedClassAccessViaInstanceReference")
     }
 
-    override fun unsafeCall(trace: BindingTrace, type: JetType, isCallForImplicitInvoke: Boolean) {
+    override fun unsafeCall(trace: BindingTrace, type: KtType, isCallForImplicitInvoke: Boolean) {
         unexpectedError("unsafeCall")
     }
 
-    override fun unnecessarySafeCall(trace: BindingTrace, type: JetType) {
+    override fun unnecessarySafeCall(trace: BindingTrace, type: KtType) {
         unexpectedError("unnecessarySafeCall")
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategyForInvoke.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategyForInvoke.java
index fcd4792d8fe..a4f551c5572 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategyForInvoke.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategyForInvoke.java
@@ -21,13 +21,13 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.psi.Call;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetReferenceExpression;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtReferenceExpression;
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collection;
 
@@ -37,12 +37,12 @@ import static org.jetbrains.kotlin.resolve.BindingContext.CALL;
 import static org.jetbrains.kotlin.resolve.BindingContext.RESOLVED_CALL;
 
 public class TracingStrategyForInvoke extends AbstractTracingStrategy {
-    private final JetType calleeType;
+    private final KtType calleeType;
 
     public TracingStrategyForInvoke(
-            @NotNull JetExpression reference,
+            @NotNull KtExpression reference,
             @NotNull Call call,
-            @NotNull JetType calleeType
+            @NotNull KtType calleeType
     ) {
         super(reference, call);
         this.calleeType = calleeType;
@@ -52,7 +52,7 @@ public class TracingStrategyForInvoke extends AbstractTracingStrategy {
     public void bindCall(@NotNull BindingTrace trace, @NotNull Call call) {
         // If reference is a simple name, it's 'variable as function call' case ('foo(a, b)' where 'foo' is a variable).
         // The outer call is bound ('foo(a, b)'), while 'invoke' call for this case is 'foo.invoke(a, b)' and shouldn't be bound.
-        if (reference instanceof JetSimpleNameExpression) return;
+        if (reference instanceof KtSimpleNameExpression) return;
         trace.record(CALL, reference, call);
     }
 
@@ -61,8 +61,8 @@ public class TracingStrategyForInvoke extends AbstractTracingStrategy {
             @NotNull BindingTrace trace, @NotNull ResolvedCall<D> resolvedCall
     ) {
         PsiElement callElement = call.getCallElement();
-        if (callElement instanceof JetReferenceExpression) {
-            trace.record(BindingContext.REFERENCE_TARGET, (JetReferenceExpression) callElement, resolvedCall.getCandidateDescriptor());
+        if (callElement instanceof KtReferenceExpression) {
+            trace.record(BindingContext.REFERENCE_TARGET, (KtReferenceExpression) callElement, resolvedCall.getCandidateDescriptor());
         }
     }
 
@@ -70,7 +70,7 @@ public class TracingStrategyForInvoke extends AbstractTracingStrategy {
     public <D extends CallableDescriptor> void bindResolvedCall(
             @NotNull BindingTrace trace, @NotNull ResolvedCall<D> resolvedCall
     ) {
-        if (reference instanceof JetSimpleNameExpression) return;
+        if (reference instanceof KtSimpleNameExpression) return;
         trace.record(RESOLVED_CALL, call, resolvedCall);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategyImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategyImpl.java
index 623ec5232c5..76641551e5d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategyImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategyImpl.java
@@ -20,7 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.psi.Call;
-import org.jetbrains.kotlin.psi.JetReferenceExpression;
+import org.jetbrains.kotlin.psi.KtReferenceExpression;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall;
@@ -34,15 +34,15 @@ import static org.jetbrains.kotlin.diagnostics.Errors.UNRESOLVED_REFERENCE_WRONG
 import static org.jetbrains.kotlin.resolve.BindingContext.*;
 
 public class TracingStrategyImpl extends AbstractTracingStrategy {
-    private final JetReferenceExpression reference;
+    private final KtReferenceExpression reference;
 
-    private TracingStrategyImpl(@NotNull JetReferenceExpression reference, @NotNull Call call) {
+    private TracingStrategyImpl(@NotNull KtReferenceExpression reference, @NotNull Call call) {
         super(reference, call);
         this.reference = reference;
     }
 
     @NotNull
-    public static TracingStrategy create(@NotNull JetReferenceExpression reference, @NotNull Call call) {
+    public static TracingStrategy create(@NotNull KtReferenceExpression reference, @NotNull Call call) {
         return new TracingStrategyImpl(reference, call);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt
index 92422e84752..89896e0b331 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt
@@ -21,17 +21,17 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.*
 import org.jetbrains.kotlin.incremental.components.LookupLocation
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.DescriptorFactory
 import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollector
 import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollectors
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
-import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
+import org.jetbrains.kotlin.resolve.scopes.KtScope
+import org.jetbrains.kotlin.resolve.scopes.KtScopeImpl
 import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.createDynamicType
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
@@ -43,7 +43,7 @@ class DynamicCallableDescriptors(private val builtIns: KotlinBuiltIns) {
 
     val dynamicType = createDynamicType(builtIns)
 
-    fun createDynamicDescriptorScope(call: Call, owner: DeclarationDescriptor) = object : JetScopeImpl() {
+    fun createDynamicDescriptorScope(call: Call, owner: DeclarationDescriptor) = object : KtScopeImpl() {
         override fun getContainingDeclaration() = owner
 
         override fun printScopeStructure(p: Printer) {
@@ -69,9 +69,9 @@ class DynamicCallableDescriptors(private val builtIns: KotlinBuiltIns) {
          */
         private fun isAugmentedAssignmentConvention(name: Name): Boolean {
             val callee = call.getCalleeExpression()
-            if (callee is JetOperationReferenceExpression) {
+            if (callee is KtOperationReferenceExpression) {
                 val token = callee.getReferencedNameElementType()
-                if (token in JetTokens.AUGMENTED_ASSIGNMENTS && OperatorConventions.ASSIGNMENT_OPERATIONS[token] != name) {
+                if (token in KtTokens.AUGMENTED_ASSIGNMENTS && OperatorConventions.ASSIGNMENT_OPERATIONS[token] != name) {
                     return true
                 }
             }
@@ -103,7 +103,7 @@ class DynamicCallableDescriptors(private val builtIns: KotlinBuiltIns) {
                 dynamicType,
                 createTypeParameters(propertyDescriptor, call),
                 createDynamicDispatchReceiverParameter(propertyDescriptor),
-                null as JetType?
+                null as KtType?
         )
 
         val getter = DescriptorFactory.createDefaultGetter(propertyDescriptor, Annotations.EMPTY)
@@ -155,7 +155,7 @@ class DynamicCallableDescriptors(private val builtIns: KotlinBuiltIns) {
     private fun createValueParameters(owner: FunctionDescriptor, call: Call): List<ValueParameterDescriptor> {
         val parameters = ArrayList<ValueParameterDescriptor>()
 
-        fun addParameter(arg : ValueArgument, outType: JetType, varargElementType: JetType?) {
+        fun addParameter(arg : ValueArgument, outType: KtType, varargElementType: KtType?) {
             val index = parameters.size()
 
             parameters.add(ValueParameterDescriptorImpl(
@@ -173,7 +173,7 @@ class DynamicCallableDescriptors(private val builtIns: KotlinBuiltIns) {
             ))
         }
 
-        fun getFunctionType(funLiteralExpr: JetFunctionLiteralExpression): JetType {
+        fun getFunctionType(funLiteralExpr: KtFunctionLiteralExpression): KtType {
             val funLiteral = funLiteralExpr.getFunctionLiteral()
 
             val receiverType = funLiteral.getReceiverTypeReference()?.let { dynamicType }
@@ -183,14 +183,14 @@ class DynamicCallableDescriptors(private val builtIns: KotlinBuiltIns) {
         }
 
         for (arg in call.getValueArguments()) {
-            val outType: JetType
-            val varargElementType: JetType?
+            val outType: KtType
+            val varargElementType: KtType?
             var hasSpreadOperator = false
 
-            val argExpression = JetPsiUtil.deparenthesize(arg.getArgumentExpression())
+            val argExpression = KtPsiUtil.deparenthesize(arg.getArgumentExpression())
 
             when {
-                argExpression is JetFunctionLiteralExpression -> {
+                argExpression is KtFunctionLiteralExpression -> {
                     outType = getFunctionType(argExpression)
                     varargElementType = null
                 }
@@ -229,7 +229,7 @@ public fun DeclarationDescriptor.isDynamic(): Boolean {
 }
 
 class CollectorForDynamicReceivers<D: CallableDescriptor>(val delegate: CallableDescriptorCollector<D>) : CallableDescriptorCollector<D> by delegate {
-    override fun getExtensionsByName(scope: JetScope, name: Name, receiverTypes: Collection<JetType>, location: LookupLocation): Collection<D> {
+    override fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection<KtType>, location: LookupLocation): Collection<D> {
         return delegate.getExtensionsByName(scope, name, receiverTypes, location).filter {
             it.getExtensionReceiverParameter()?.getType()?.isDynamic() ?: false
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/CallMaker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/CallMaker.java
index d039f9d512d..b9df85df787 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/CallMaker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/CallMaker.java
@@ -34,15 +34,15 @@ public class CallMaker {
 
     private static class ExpressionValueArgument implements ValueArgument {
 
-        private final JetExpression expression;
+        private final KtExpression expression;
 
-        private final JetElement reportErrorsOn;
+        private final KtElement reportErrorsOn;
 
         private final boolean isExternal;
 
         private ExpressionValueArgument(
-                @Nullable JetExpression expression,
-                @NotNull JetElement reportErrorsOn,
+                @Nullable KtExpression expression,
+                @NotNull KtElement reportErrorsOn,
                 boolean isExternal
         ) {
             this.expression = expression;
@@ -56,7 +56,7 @@ public class CallMaker {
         }
 
         @Override
-        public JetExpression getArgumentExpression() {
+        public KtExpression getArgumentExpression() {
             return expression;
         }
 
@@ -72,7 +72,7 @@ public class CallMaker {
 
         @NotNull
         @Override
-        public JetElement asElement() {
+        public KtElement asElement() {
             return reportErrorsOn;
         }
 
@@ -101,19 +101,19 @@ public class CallMaker {
 
     private static class CallImpl implements Call {
 
-        private final JetElement callElement;
+        private final KtElement callElement;
         private final ReceiverValue explicitReceiver;
         private final ASTNode callOperationNode;
-        private final JetExpression calleeExpression;
+        private final KtExpression calleeExpression;
         private final List<? extends ValueArgument> valueArguments;
         private final Call.CallType callType;
 
-        protected CallImpl(@NotNull JetElement callElement, @NotNull ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode, @Nullable JetExpression calleeExpression, @NotNull List<? extends ValueArgument> valueArguments) {
+        protected CallImpl(@NotNull KtElement callElement, @NotNull ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode, @Nullable KtExpression calleeExpression, @NotNull List<? extends ValueArgument> valueArguments) {
             this(callElement, explicitReceiver, callOperationNode, calleeExpression, valueArguments, CallType.DEFAULT);
         }
 
-        protected CallImpl(@NotNull JetElement callElement, @NotNull ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode,
-                @Nullable JetExpression calleeExpression, @NotNull List<? extends ValueArgument> valueArguments, @NotNull CallType callType) {
+        protected CallImpl(@NotNull KtElement callElement, @NotNull ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode,
+                @Nullable KtExpression calleeExpression, @NotNull List<? extends ValueArgument> valueArguments, @NotNull CallType callType) {
             this.callElement = callElement;
             this.explicitReceiver = explicitReceiver;
             this.callOperationNode = callOperationNode;
@@ -140,7 +140,7 @@ public class CallMaker {
         }
 
         @Override
-        public JetExpression getCalleeExpression() {
+        public KtExpression getCalleeExpression() {
             return calleeExpression;
         }
 
@@ -152,12 +152,12 @@ public class CallMaker {
 
         @NotNull
         @Override
-        public JetElement getCallElement() {
+        public KtElement getCallElement() {
             return callElement;
         }
 
         @Override
-        public JetValueArgumentList getValueArgumentList() {
+        public KtValueArgumentList getValueArgumentList() {
             return null;
         }
 
@@ -168,12 +168,12 @@ public class CallMaker {
         }
         @NotNull
         @Override
-        public List<JetTypeProjection> getTypeArguments() {
+        public List<KtTypeProjection> getTypeArguments() {
             return Collections.emptyList();
         }
 
         @Override
-        public JetTypeArgumentList getTypeArgumentList() {
+        public KtTypeArgumentList getTypeArgumentList() {
             return null;
         }
 
@@ -190,80 +190,81 @@ public class CallMaker {
     }
 
     @NotNull
-    public static Call makeCallWithExpressions(@NotNull JetElement callElement, @NotNull ReceiverValue explicitReceiver,
-                                               @Nullable ASTNode callOperationNode, @NotNull JetExpression calleeExpression,
-                                               @NotNull List<JetExpression> argumentExpressions) {
+    public static Call makeCallWithExpressions(@NotNull KtElement callElement, @NotNull ReceiverValue explicitReceiver,
+                                               @Nullable ASTNode callOperationNode, @NotNull KtExpression calleeExpression,
+                                               @NotNull List<KtExpression> argumentExpressions) {
         return makeCallWithExpressions(callElement, explicitReceiver, callOperationNode, calleeExpression, argumentExpressions, CallType.DEFAULT);
     }
 
     @NotNull
-    public static Call makeCallWithExpressions(@NotNull JetElement callElement, @NotNull ReceiverValue explicitReceiver,
-                                               @Nullable ASTNode callOperationNode, @NotNull JetExpression calleeExpression,
-                                               @NotNull List<JetExpression> argumentExpressions, @NotNull CallType callType) {
+    public static Call makeCallWithExpressions(@NotNull KtElement callElement, @NotNull ReceiverValue explicitReceiver,
+                                               @Nullable ASTNode callOperationNode, @NotNull KtExpression calleeExpression,
+                                               @NotNull List<KtExpression> argumentExpressions, @NotNull CallType callType) {
         List<ValueArgument> arguments = new ArrayList<ValueArgument>(argumentExpressions.size());
-        for (JetExpression argumentExpression : argumentExpressions) {
+        for (KtExpression argumentExpression : argumentExpressions) {
             arguments.add(makeValueArgument(argumentExpression, calleeExpression));
         }
         return makeCall(callElement, explicitReceiver, callOperationNode, calleeExpression, arguments, callType);
     }
 
     @NotNull
-    public static Call makeCall(JetElement callElement, ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode, JetExpression calleeExpression, List<? extends ValueArgument> arguments) {
+    public static Call makeCall(KtElement callElement, ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode, KtExpression calleeExpression, List<? extends ValueArgument> arguments) {
         return makeCall(callElement, explicitReceiver, callOperationNode, calleeExpression, arguments, CallType.DEFAULT);
     }
 
     @NotNull
-    public static Call makeCall(JetElement callElement, ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode,
-            JetExpression calleeExpression, List<? extends ValueArgument> arguments, CallType callType) {
+    public static Call makeCall(
+            KtElement callElement, ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode,
+            KtExpression calleeExpression, List<? extends ValueArgument> arguments, CallType callType) {
         return new CallImpl(callElement, explicitReceiver, callOperationNode, calleeExpression, arguments, callType);
     }
 
     @NotNull
-    public static Call makeCall(@NotNull ReceiverValue leftAsReceiver, JetBinaryExpression expression) {
+    public static Call makeCall(@NotNull ReceiverValue leftAsReceiver, KtBinaryExpression expression) {
         return makeCallWithExpressions(expression, leftAsReceiver, null, expression.getOperationReference(), Collections.singletonList(expression.getRight()));
     }
 
     @NotNull
-    public static Call makeCall(@NotNull ReceiverValue baseAsReceiver, JetUnaryExpression expression) {
+    public static Call makeCall(@NotNull ReceiverValue baseAsReceiver, KtUnaryExpression expression) {
         return makeCall(expression, baseAsReceiver, null, expression.getOperationReference(), Collections.<ValueArgument>emptyList());
     }
 
     @NotNull
-    public static Call makeArraySetCall(@NotNull ReceiverValue arrayAsReceiver, @NotNull JetArrayAccessExpression arrayAccessExpression,
-            @NotNull JetExpression rightHandSide, @NotNull CallType callType) {
-        List<JetExpression> arguments = Lists.newArrayList(arrayAccessExpression.getIndexExpressions());
+    public static Call makeArraySetCall(@NotNull ReceiverValue arrayAsReceiver, @NotNull KtArrayAccessExpression arrayAccessExpression,
+            @NotNull KtExpression rightHandSide, @NotNull CallType callType) {
+        List<KtExpression> arguments = Lists.newArrayList(arrayAccessExpression.getIndexExpressions());
         arguments.add(rightHandSide);
         return makeCallWithExpressions(arrayAccessExpression, arrayAsReceiver, null, arrayAccessExpression, arguments, callType);
     }
 
     @NotNull
-    public static Call makeArrayGetCall(@NotNull ReceiverValue arrayAsReceiver, @NotNull JetArrayAccessExpression arrayAccessExpression,
+    public static Call makeArrayGetCall(@NotNull ReceiverValue arrayAsReceiver, @NotNull KtArrayAccessExpression arrayAccessExpression,
             @NotNull CallType callType) {
         return makeCallWithExpressions(arrayAccessExpression, arrayAsReceiver, null, arrayAccessExpression, arrayAccessExpression.getIndexExpressions(), callType);
     }
 
     @NotNull
-    public static ValueArgument makeValueArgument(@NotNull JetExpression expression) {
+    public static ValueArgument makeValueArgument(@NotNull KtExpression expression) {
         return makeValueArgument(expression, expression);
     }
 
     @NotNull
-    public static ValueArgument makeValueArgument(@Nullable JetExpression expression, @NotNull JetElement reportErrorsOn) {
+    public static ValueArgument makeValueArgument(@Nullable KtExpression expression, @NotNull KtElement reportErrorsOn) {
         return new ExpressionValueArgument(expression, reportErrorsOn, false);
     }
 
     @NotNull
-    public static ValueArgument makeExternalValueArgument(@NotNull JetExpression expression) {
+    public static ValueArgument makeExternalValueArgument(@NotNull KtExpression expression) {
         return new ExpressionValueArgument(expression, expression, true);
     }
 
     @NotNull
-    public static Call makePropertyCall(@NotNull ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode, @NotNull JetSimpleNameExpression nameExpression) {
-        return makeCallWithExpressions(nameExpression, explicitReceiver, callOperationNode, nameExpression, Collections.<JetExpression>emptyList());
+    public static Call makePropertyCall(@NotNull ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode, @NotNull KtSimpleNameExpression nameExpression) {
+        return makeCallWithExpressions(nameExpression, explicitReceiver, callOperationNode, nameExpression, Collections.<KtExpression>emptyList());
     }
 
     @NotNull
-    public static Call makeCall(@NotNull final ReceiverValue explicitReceiver, @Nullable final ASTNode callOperationNode, @NotNull final JetCallElement callElement) {
+    public static Call makeCall(@NotNull final ReceiverValue explicitReceiver, @Nullable final ASTNode callOperationNode, @NotNull final KtCallElement callElement) {
         return new Call() {
             @Override
             public ASTNode getCallOperationNode() {
@@ -284,13 +285,13 @@ public class CallMaker {
 
             @Override
             @Nullable
-            public JetExpression getCalleeExpression() {
+            public KtExpression getCalleeExpression() {
                 return callElement.getCalleeExpression();
             }
 
             @Override
             @Nullable
-            public JetValueArgumentList getValueArgumentList() {
+            public KtValueArgumentList getValueArgumentList() {
                 return callElement.getValueArgumentList();
             }
 
@@ -308,19 +309,19 @@ public class CallMaker {
 
             @Override
             @NotNull
-            public List<JetTypeProjection> getTypeArguments() {
+            public List<KtTypeProjection> getTypeArguments() {
                 return callElement.getTypeArguments();
             }
 
             @Override
             @Nullable
-            public JetTypeArgumentList getTypeArgumentList() {
+            public KtTypeArgumentList getTypeArgumentList() {
                 return callElement.getTypeArgumentList();
             }
 
             @NotNull
             @Override
-            public JetElement getCallElement() {
+            public KtElement getCallElement() {
                 return callElement;
             }
 
@@ -338,7 +339,7 @@ public class CallMaker {
     }
 
     @NotNull
-    public static Call makeCall(@NotNull JetElement callElement, @NotNull ReceiverValue explicitReceiver) {
+    public static Call makeCall(@NotNull KtElement callElement, @NotNull ReceiverValue explicitReceiver) {
         return new CallImpl(callElement, explicitReceiver, null, null, Collections.<ValueArgument>emptyList());
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/DelegatingCall.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/DelegatingCall.java
index 7f8cf7d609f..4e18b6706cd 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/DelegatingCall.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/DelegatingCall.java
@@ -53,13 +53,13 @@ public class DelegatingCall implements Call {
 
     @Override
     @Nullable
-    public JetExpression getCalleeExpression() {
+    public KtExpression getCalleeExpression() {
         return delegate.getCalleeExpression();
     }
 
     @Override
     @Nullable
-    public JetValueArgumentList getValueArgumentList() {
+    public KtValueArgumentList getValueArgumentList() {
         return delegate.getValueArgumentList();
     }
 
@@ -78,19 +78,19 @@ public class DelegatingCall implements Call {
 
     @Override
     @NotNull
-    public List<JetTypeProjection> getTypeArguments() {
+    public List<KtTypeProjection> getTypeArguments() {
         return delegate.getTypeArguments();
     }
 
     @Override
     @Nullable
-    public JetTypeArgumentList getTypeArgumentList() {
+    public KtTypeArgumentList getTypeArgumentList() {
         return delegate.getTypeArgumentList();
     }
 
     @NotNull
     @Override
-    public JetElement getCallElement() {
+    public KtElement getCallElement() {
         return delegate.getCallElement();
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/FakeCallableDescriptorForObject.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/FakeCallableDescriptorForObject.kt
index bd4706cb066..ed9e65aff88 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/FakeCallableDescriptorForObject.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/FakeCallableDescriptorForObject.kt
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.resolve.descriptorUtil.classObjectType
 import org.jetbrains.kotlin.resolve.descriptorUtil.getClassObjectReferenceTarget
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasClassObjectType
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.util.Collections
 
 public class FakeCallableDescriptorForObject(
@@ -44,7 +44,7 @@ public class FakeCallableDescriptorForObject(
 
     override fun getValueParameters(): List<ValueParameterDescriptor> = Collections.emptyList()
 
-    override fun getReturnType(): JetType? = getType()
+    override fun getReturnType(): KtType? = getType()
 
     override fun hasSynthesizedParameterNames() = false
 
@@ -52,7 +52,7 @@ public class FakeCallableDescriptorForObject(
 
     override fun getOverriddenDescriptors(): Set<CallableDescriptor> = Collections.emptySet()
 
-    override fun getType(): JetType = classDescriptor.classObjectType!!
+    override fun getType(): KtType = classDescriptor.classObjectType!!
 
     override fun isVar() = false
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt
index 84c15b2f025..4f525700a22 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt
@@ -20,7 +20,7 @@ import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getTextWithLocation
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -68,7 +68,7 @@ public fun <D : CallableDescriptor> ResolvedCall<D>.getParameterForArgument(valu
 
 public fun <C: ResolutionContext<C>> Call.hasUnresolvedArguments(context: ResolutionContext<C>): Boolean {
     val arguments = getValueArguments().map { it.getArgumentExpression() }
-    return arguments.any (fun (argument: JetExpression?): Boolean {
+    return arguments.any (fun (argument: KtExpression?): Boolean {
         if (argument == null || ArgumentTypeResolver.isFunctionLiteralArgument(argument, context)) return false
 
         val resolvedCall = argument.getResolvedCall(context.trace.getBindingContext()) as MutableResolvedCall<*>?
@@ -81,36 +81,36 @@ public fun <C: ResolutionContext<C>> Call.hasUnresolvedArguments(context: Resolu
 
 public fun Call.getValueArgumentsInParentheses(): List<ValueArgument> = getValueArguments().filterArgsInParentheses()
 
-public fun JetCallElement.getValueArgumentsInParentheses(): List<ValueArgument> = getValueArguments().filterArgsInParentheses()
+public fun KtCallElement.getValueArgumentsInParentheses(): List<ValueArgument> = getValueArguments().filterArgsInParentheses()
 
-public fun Call.getValueArgumentListOrElement(): JetElement = getValueArgumentList() ?: getCalleeExpression() ?: getCallElement()
+public fun Call.getValueArgumentListOrElement(): KtElement = getValueArgumentList() ?: getCalleeExpression() ?: getCallElement()
 
 @Suppress("UNCHECKED_CAST")
-private fun List<ValueArgument?>.filterArgsInParentheses() = filter { it !is JetFunctionLiteralArgument } as List<ValueArgument>
+private fun List<ValueArgument?>.filterArgsInParentheses() = filter { it !is KtFunctionLiteralArgument } as List<ValueArgument>
 
-public fun Call.getValueArgumentForExpression(expression: JetExpression): ValueArgument? {
-    fun JetElement.deparenthesizeStructurally(): JetElement? {
-        val deparenthesized = if (this is JetExpression) JetPsiUtil.deparenthesizeOnce(this) else this
+public fun Call.getValueArgumentForExpression(expression: KtExpression): ValueArgument? {
+    fun KtElement.deparenthesizeStructurally(): KtElement? {
+        val deparenthesized = if (this is KtExpression) KtPsiUtil.deparenthesizeOnce(this) else this
         return when {
             deparenthesized != this -> deparenthesized
-            this is JetFunctionLiteralExpression -> this.getFunctionLiteral()
-            this is JetFunctionLiteral -> this.getBodyExpression()
+            this is KtFunctionLiteralExpression -> this.getFunctionLiteral()
+            this is KtFunctionLiteral -> this.getBodyExpression()
             else -> null
         }
     }
-    fun JetElement.isParenthesizedExpression() = sequence(this) { it.deparenthesizeStructurally() }.any { it == expression }
+    fun KtElement.isParenthesizedExpression() = sequence(this) { it.deparenthesizeStructurally() }.any { it == expression }
     return getValueArguments().firstOrNull { it?.getArgumentExpression()?.isParenthesizedExpression() ?: false }
 }
 
 // Get call / resolved call from binding context
 
-public fun JetElement?.getCalleeExpressionIfAny(): JetExpression? {
-    val element = if (this is JetExpression) JetPsiUtil.deparenthesize(this) else this
+public fun KtElement?.getCalleeExpressionIfAny(): KtExpression? {
+    val element = if (this is KtExpression) KtPsiUtil.deparenthesize(this) else this
     return when (element) {
-        is JetSimpleNameExpression -> element
-        is JetCallElement -> element.getCalleeExpression()
-        is JetQualifiedExpression -> element.getSelectorExpression().getCalleeExpressionIfAny()
-        is JetOperationExpression -> element.getOperationReference()
+        is KtSimpleNameExpression -> element
+        is KtCallElement -> element.getCalleeExpression()
+        is KtQualifiedExpression -> element.getSelectorExpression().getCalleeExpressionIfAny()
+        is KtOperationExpression -> element.getOperationReference()
         else -> null
     }
 }
@@ -122,14 +122,14 @@ public fun JetElement?.getCalleeExpressionIfAny(): JetExpression? {
  *  Note: special construction like <code>a!!, a ?: b, if (c) a else b</code> are resolved as calls,
  *  so there is a corresponding call for them.
  */
-public fun JetElement.getCall(context: BindingContext): Call? {
-    val element = if (this is JetExpression) JetPsiUtil.deparenthesize(this) else this
+public fun KtElement.getCall(context: BindingContext): Call? {
+    val element = if (this is KtExpression) KtPsiUtil.deparenthesize(this) else this
     if (element == null) return null
 
     val parent = element.getParent()
-    val reference: JetExpression? = when {
-        parent is JetInstanceExpressionWithLabel -> parent
-        parent is JetUserType -> parent.getParent()?.getParent() as? JetConstructorCalleeExpression
+    val reference: KtExpression? = when {
+        parent is KtInstanceExpressionWithLabel -> parent
+        parent is KtUserType -> parent.getParent()?.getParent() as? KtConstructorCalleeExpression
         else -> element.getCalleeExpressionIfAny()
     }
     if (reference != null) {
@@ -138,10 +138,10 @@ public fun JetElement.getCall(context: BindingContext): Call? {
     return context[CALL, element]
 }
 
-public fun JetElement.getParentCall(context: BindingContext, strict: Boolean = true): Call? {
-    val callExpressionTypes = arrayOf<Class<out JetElement>?>(
-            javaClass<JetSimpleNameExpression>(), javaClass<JetCallElement>(), javaClass<JetBinaryExpression>(),
-            javaClass<JetUnaryExpression>(), javaClass<JetArrayAccessExpression>())
+public fun KtElement.getParentCall(context: BindingContext, strict: Boolean = true): Call? {
+    val callExpressionTypes = arrayOf<Class<out KtElement>?>(
+            javaClass<KtSimpleNameExpression>(), javaClass<KtCallElement>(), javaClass<KtBinaryExpression>(),
+            javaClass<KtUnaryExpression>(), javaClass<KtArrayAccessExpression>())
 
     val parent = if (strict) {
         PsiTreeUtil.getParentOfType(this, *callExpressionTypes)
@@ -155,19 +155,19 @@ public fun Call?.getResolvedCall(context: BindingContext): ResolvedCall<out Call
     return context[RESOLVED_CALL, this]
 }
 
-public fun JetElement?.getResolvedCall(context: BindingContext): ResolvedCall<out CallableDescriptor>? {
+public fun KtElement?.getResolvedCall(context: BindingContext): ResolvedCall<out CallableDescriptor>? {
     return this?.getCall(context)?.getResolvedCall(context)
 }
 
-public fun JetElement?.getParentResolvedCall(context: BindingContext, strict: Boolean = true): ResolvedCall<out CallableDescriptor>? {
+public fun KtElement?.getParentResolvedCall(context: BindingContext, strict: Boolean = true): ResolvedCall<out CallableDescriptor>? {
     return this?.getParentCall(context, strict)?.getResolvedCall(context)
 }
 
-public fun JetElement.getCallWithAssert(context: BindingContext): Call {
+public fun KtElement.getCallWithAssert(context: BindingContext): Call {
     return getCall(context).sure { "No call for ${this.getTextWithLocation()}" }
 }
 
-public fun JetElement.getResolvedCallWithAssert(context: BindingContext): ResolvedCall<out CallableDescriptor> {
+public fun KtElement.getResolvedCallWithAssert(context: BindingContext): ResolvedCall<out CallableDescriptor> {
     return getResolvedCall(context).sure { "No resolved call for ${this.getTextWithLocation()}" }
 }
 
@@ -175,7 +175,7 @@ public fun Call.getResolvedCallWithAssert(context: BindingContext): ResolvedCall
     return getResolvedCall(context).sure { "No resolved call for ${this.getCallElement().getTextWithLocation()}" }
 }
 
-public fun JetExpression.getFunctionResolvedCallWithAssert(context: BindingContext): ResolvedCall<out FunctionDescriptor> {
+public fun KtExpression.getFunctionResolvedCallWithAssert(context: BindingContext): ResolvedCall<out FunctionDescriptor> {
     val resolvedCall = getResolvedCallWithAssert(context)
     assert(resolvedCall.getResultingDescriptor() is FunctionDescriptor) {
         "ResolvedCall for this expression must be ResolvedCall<? extends FunctionDescriptor>: ${this.getTextWithLocation()}"
@@ -194,4 +194,4 @@ public fun Call.isSafeCall(): Boolean {
     return isExplicitSafeCall()
 }
 
-public fun Call.isExplicitSafeCall(): Boolean = getCallOperationNode()?.getElementType() == JetTokens.SAFE_ACCESS
\ No newline at end of file
+public fun Call.isExplicitSafeCall(): Boolean = getCallOperationNode()?.getElementType() == KtTokens.SAFE_ACCESS
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantChecker.java
index 089491dbdd3..28bad745d90 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantChecker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantChecker.java
@@ -20,16 +20,16 @@ import com.google.common.collect.Sets;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory;
-import org.jetbrains.kotlin.psi.JetConstantExpression;
-import org.jetbrains.kotlin.psi.JetElement;
+import org.jetbrains.kotlin.psi.KtConstantExpression;
+import org.jetbrains.kotlin.psi.KtElement;
 import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.Set;
 
@@ -56,24 +56,24 @@ public class CompileTimeConstantChecker {
     // return true if there is an error
     public boolean checkConstantExpressionType(
             @Nullable ConstantValue<?> compileTimeConstant,
-            @NotNull JetConstantExpression expression,
-            @NotNull JetType expectedType
+            @NotNull KtConstantExpression expression,
+            @NotNull KtType expectedType
     ) {
         IElementType elementType = expression.getNode().getElementType();
 
-        if (elementType == JetNodeTypes.INTEGER_CONSTANT) {
+        if (elementType == KtNodeTypes.INTEGER_CONSTANT) {
             return checkIntegerValue(compileTimeConstant, expectedType, expression);
         }
-        else if (elementType == JetNodeTypes.FLOAT_CONSTANT) {
+        else if (elementType == KtNodeTypes.FLOAT_CONSTANT) {
             return checkFloatValue(compileTimeConstant, expectedType, expression);
         }
-        else if (elementType == JetNodeTypes.BOOLEAN_CONSTANT) {
+        else if (elementType == KtNodeTypes.BOOLEAN_CONSTANT) {
             return checkBooleanValue(expectedType, expression);
         }
-        else if (elementType == JetNodeTypes.CHARACTER_CONSTANT) {
+        else if (elementType == KtNodeTypes.CHARACTER_CONSTANT) {
             return checkCharValue(compileTimeConstant, expectedType, expression);
         }
-        else if (elementType == JetNodeTypes.NULL) {
+        else if (elementType == KtNodeTypes.NULL) {
             return checkNullValue(expectedType, expression);
         }
         return false;
@@ -81,8 +81,8 @@ public class CompileTimeConstantChecker {
 
     private boolean checkIntegerValue(
             @Nullable ConstantValue<?> value,
-            @NotNull JetType expectedType,
-            @NotNull JetConstantExpression expression
+            @NotNull KtType expectedType,
+            @NotNull KtConstantExpression expression
     ) {
         if (value == null) {
             return reportError(INT_LITERAL_OUT_OF_RANGE.on(expression));
@@ -93,8 +93,8 @@ public class CompileTimeConstantChecker {
         }
 
         if (!noExpectedTypeOrError(expectedType)) {
-            JetType valueType = value.getType();
-            if (!JetTypeChecker.DEFAULT.isSubtypeOf(valueType, expectedType)) {
+            KtType valueType = value.getType();
+            if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(valueType, expectedType)) {
                 return reportError(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "integer", expectedType));
             }
         }
@@ -103,15 +103,15 @@ public class CompileTimeConstantChecker {
 
     private boolean checkFloatValue(
             @Nullable ConstantValue<?> value,
-            @NotNull JetType expectedType,
-            @NotNull JetConstantExpression expression
+            @NotNull KtType expectedType,
+            @NotNull KtConstantExpression expression
     ) {
         if (value == null) {
             return reportError(FLOAT_LITERAL_OUT_OF_RANGE.on(expression));
         }
         if (!noExpectedTypeOrError(expectedType)) {
-            JetType valueType = value.getType();
-            if (!JetTypeChecker.DEFAULT.isSubtypeOf(valueType, expectedType)) {
+            KtType valueType = value.getType();
+            if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(valueType, expectedType)) {
                 return reportError(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "floating-point", expectedType));
             }
         }
@@ -119,19 +119,19 @@ public class CompileTimeConstantChecker {
     }
 
     private boolean checkBooleanValue(
-            @NotNull JetType expectedType,
-            @NotNull JetConstantExpression expression
+            @NotNull KtType expectedType,
+            @NotNull KtConstantExpression expression
     ) {
         if (!noExpectedTypeOrError(expectedType)
-            && !JetTypeChecker.DEFAULT.isSubtypeOf(builtIns.getBooleanType(), expectedType)) {
+            && !KotlinTypeChecker.DEFAULT.isSubtypeOf(builtIns.getBooleanType(), expectedType)) {
             return reportError(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "boolean", expectedType));
         }
         return false;
     }
 
-    private boolean checkCharValue(ConstantValue<?> constant, JetType expectedType, JetConstantExpression expression) {
+    private boolean checkCharValue(ConstantValue<?> constant, KtType expectedType, KtConstantExpression expression) {
         if (!noExpectedTypeOrError(expectedType)
-            && !JetTypeChecker.DEFAULT.isSubtypeOf(builtIns.getCharType(), expectedType)) {
+            && !KotlinTypeChecker.DEFAULT.isSubtypeOf(builtIns.getCharType(), expectedType)) {
             return reportError(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "character", expectedType));
         }
 
@@ -146,7 +146,7 @@ public class CompileTimeConstantChecker {
         return false;
     }
 
-    private boolean checkNullValue(@NotNull JetType expectedType, @NotNull JetConstantExpression expression) {
+    private boolean checkNullValue(@NotNull KtType expectedType, @NotNull KtConstantExpression expression) {
         if (!noExpectedTypeOrError(expectedType) && !TypeUtils.acceptsNullable(expectedType)) {
             return reportError(NULL_FOR_NONNULL_TYPE.on(expression, expectedType));
         }
@@ -154,7 +154,7 @@ public class CompileTimeConstantChecker {
     }
 
     @NotNull
-    private static CharacterWithDiagnostic parseCharacter(@NotNull JetConstantExpression expression) {
+    private static CharacterWithDiagnostic parseCharacter(@NotNull KtConstantExpression expression) {
         String text = expression.getText();
         // Strip the quotes
         if (text.length() < 2 || text.charAt(0) != '\'' || text.charAt(text.length() - 1) != '\'') {
@@ -177,7 +177,7 @@ public class CompileTimeConstantChecker {
     }
 
     @NotNull
-    public static CharacterWithDiagnostic escapedStringToCharacter(@NotNull String text, @NotNull JetElement expression) {
+    public static CharacterWithDiagnostic escapedStringToCharacter(@NotNull String text, @NotNull KtElement expression) {
         assert text.length() > 0 && text.charAt(0) == '\\' : "Only escaped sequences must be passed to this routine: " + text;
 
         // Escape
@@ -209,7 +209,7 @@ public class CompileTimeConstantChecker {
     }
 
     @NotNull
-    private static CharacterWithDiagnostic illegalEscape(@NotNull JetElement expression) {
+    private static CharacterWithDiagnostic illegalEscape(@NotNull KtElement expression) {
         return createErrorCharacter(ILLEGAL_ESCAPE.on(expression, expression));
     }
 
@@ -242,7 +242,7 @@ public class CompileTimeConstantChecker {
     }
 
     @Nullable
-    public static Character parseChar(@NotNull JetConstantExpression expression) {
+    public static Character parseChar(@NotNull KtConstantExpression expression) {
         return parseCharacter(expression).getValue();
     }
 
@@ -269,7 +269,7 @@ public class CompileTimeConstantChecker {
         return null;
     }
 
-    public static boolean noExpectedTypeOrError(JetType expectedType) {
+    public static boolean noExpectedTypeOrError(KtType expectedType) {
         return TypeUtils.noExpectedType(expectedType) || expectedType.isError();
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt
index 77ad32c7834..0f4bd35306b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt
@@ -17,12 +17,12 @@
 package org.jetbrains.kotlin.resolve.constants.evaluate
 
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.JetNodeTypes
+import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.*
@@ -31,9 +31,9 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
 import org.jetbrains.kotlin.resolve.constants.*
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.util.OperatorNameConventions
 import java.math.BigInteger
@@ -45,16 +45,16 @@ public class ConstantExpressionEvaluator(
     internal val constantValueFactory = ConstantValueFactory(builtIns)
 
     public fun updateNumberType(
-            numberType: JetType,
-            expression: JetExpression?,
+            numberType: KtType,
+            expression: KtExpression?,
             statementFilter: StatementFilter,
             trace: BindingTrace
     ) {
         if (expression == null) return
         BindingContextUtils.updateRecordedType(numberType, expression, trace, false)
 
-        if (expression !is JetConstantExpression) {
-            val deparenthesized = JetPsiUtil.getLastElementDeparenthesized(expression, statementFilter)
+        if (expression !is KtConstantExpression) {
+            val deparenthesized = KtPsiUtil.getLastElementDeparenthesized(expression, statementFilter)
             if (deparenthesized !== expression) {
                 updateNumberType(numberType, deparenthesized, statementFilter, trace)
             }
@@ -101,19 +101,19 @@ public class ConstantExpressionEvaluator(
     }
 
     private fun checkCompileTimeConstant(
-            argumentExpression: JetExpression,
-            expectedType: JetType,
+            argumentExpression: KtExpression,
+            expectedType: KtType,
             trace: BindingTrace
     ) {
         val expressionType = trace.getType(argumentExpression)
 
-        if (expressionType == null || !JetTypeChecker.DEFAULT.isSubtypeOf(expressionType, expectedType)) {
+        if (expressionType == null || !KotlinTypeChecker.DEFAULT.isSubtypeOf(expressionType, expectedType)) {
             // TYPE_MISMATCH should be reported otherwise
             return
         }
 
         // array(1, <!>null<!>, 3) - error should be reported on inner expression
-        if (argumentExpression is JetCallExpression) {
+        if (argumentExpression is KtCallExpression) {
             val arrayArgument = getArgumentExpressionsForArrayCall(argumentExpression, trace)
             if (arrayArgument != null) {
                 for (expression in arrayArgument.first) {
@@ -143,9 +143,9 @@ public class ConstantExpressionEvaluator(
     }
 
     private fun getArgumentExpressionsForArrayCall(
-            expression: JetCallExpression,
+            expression: KtCallExpression,
             trace: BindingTrace
-    ): Pair<List<JetExpression>, JetType?>? {
+    ): Pair<List<KtExpression>, KtType?>? {
         val resolvedCall = expression.getResolvedCall(trace.getBindingContext())
         if (resolvedCall == null || !CompileTimeConstantUtils.isArrayMethodCall(resolvedCall)) {
             return null
@@ -155,7 +155,7 @@ public class ConstantExpressionEvaluator(
 
         val elementType = argumentEntry.getKey().getVarargElementType() ?: return null
 
-        val result = arrayListOf<JetExpression>()
+        val result = arrayListOf<KtExpression>()
         for (valueArgument in argumentEntry.getValue().getArguments()) {
             val valueArgumentExpression = valueArgument.getArgumentExpression()
             if (valueArgumentExpression != null) {
@@ -163,7 +163,7 @@ public class ConstantExpressionEvaluator(
             }
         }
 
-        return Pair<List<JetExpression>, JetType>(result, elementType)
+        return Pair<List<KtExpression>, KtType>(result, elementType)
     }
 
     private fun hasSpread(argument: ResolvedValueArgument): Boolean {
@@ -173,7 +173,7 @@ public class ConstantExpressionEvaluator(
 
     private fun resolveAnnotationValueArguments(
             resolvedValueArgument: ResolvedValueArgument,
-            expectedType: JetType,
+            expectedType: KtType,
             trace: BindingTrace): List<CompileTimeConstant<*>> {
         val constants = ArrayList<CompileTimeConstant<*>>()
         for (argument in resolvedValueArgument.getArguments()) {
@@ -192,9 +192,9 @@ public class ConstantExpressionEvaluator(
     }
 
     public fun evaluateExpression(
-            expression: JetExpression,
+            expression: KtExpression,
             trace: BindingTrace,
-            expectedType: JetType? = TypeUtils.NO_EXPECTED_TYPE
+            expectedType: KtType? = TypeUtils.NO_EXPECTED_TYPE
     ): CompileTimeConstant<*>? {
         val visitor = ConstantExpressionEvaluatorVisitor(this, trace)
         val constant = visitor.evaluate(expression, expectedType) ?: return null
@@ -202,9 +202,9 @@ public class ConstantExpressionEvaluator(
     }
 
     public fun evaluateToConstantValue(
-            expression: JetExpression,
+            expression: KtExpression,
             trace: BindingTrace,
-            expectedType: JetType
+            expectedType: KtType
     ): ConstantValue<*>? {
         return evaluateExpression(expression, trace, expectedType)?.toConstantValue(expectedType)
     }
@@ -212,13 +212,13 @@ public class ConstantExpressionEvaluator(
 
     companion object {
         @JvmStatic
-        public fun getConstant(expression: JetExpression, bindingContext: BindingContext): CompileTimeConstant<*>? {
+        public fun getConstant(expression: KtExpression, bindingContext: BindingContext): CompileTimeConstant<*>? {
             val constant = getPossiblyErrorConstant(expression, bindingContext) ?: return null
             return if (!constant.isError) constant else null
         }
 
         @JvmStatic
-        fun getPossiblyErrorConstant(expression: JetExpression, bindingContext: BindingContext): CompileTimeConstant<*>? {
+        fun getPossiblyErrorConstant(expression: KtExpression, bindingContext: BindingContext): CompileTimeConstant<*>? {
             return bindingContext.get(BindingContext.COMPILE_TIME_VALUE, expression)
         }
     }
@@ -227,11 +227,11 @@ public class ConstantExpressionEvaluator(
 private class ConstantExpressionEvaluatorVisitor(
         private val constantExpressionEvaluator: ConstantExpressionEvaluator,
         private val trace: BindingTrace
-) : JetVisitor<CompileTimeConstant<*>?, JetType>() {
+) : KtVisitor<CompileTimeConstant<*>?, KtType>() {
 
     private val factory = constantExpressionEvaluator.constantValueFactory
 
-    fun evaluate(expression: JetExpression, expectedType: JetType?): CompileTimeConstant<*>? {
+    fun evaluate(expression: KtExpression, expectedType: KtType?): CompileTimeConstant<*>? {
         val recordedCompileTimeConstant = ConstantExpressionEvaluator.getPossiblyErrorConstant(expression, trace.getBindingContext())
         if (recordedCompileTimeConstant != null) {
             return recordedCompileTimeConstant
@@ -245,7 +245,7 @@ private class ConstantExpressionEvaluatorVisitor(
         return null
     }
 
-    private val stringExpressionEvaluator = object : JetVisitor<TypedCompileTimeConstant<String>, Nothing?>() {
+    private val stringExpressionEvaluator = object : KtVisitor<TypedCompileTimeConstant<String>, Nothing?>() {
         private fun createStringConstant(compileTimeConstant: CompileTimeConstant<*>): TypedCompileTimeConstant<String>? {
             val constantValue = compileTimeConstant.toConstantValue(TypeUtils.NO_EXPECTED_TYPE)
             return when (constantValue) {
@@ -255,11 +255,11 @@ private class ConstantExpressionEvaluatorVisitor(
             }.wrap(compileTimeConstant.parameters)
         }
 
-        fun evaluate(entry: JetStringTemplateEntry): TypedCompileTimeConstant<String>? {
+        fun evaluate(entry: KtStringTemplateEntry): TypedCompileTimeConstant<String>? {
             return entry.accept(this, null)
         }
 
-        override fun visitStringTemplateEntryWithExpression(entry: JetStringTemplateEntryWithExpression, data: Nothing?): TypedCompileTimeConstant<String>? {
+        override fun visitStringTemplateEntryWithExpression(entry: KtStringTemplateEntryWithExpression, data: Nothing?): TypedCompileTimeConstant<String>? {
             val expression = entry.getExpression() ?: return null
 
             return evaluate(expression, constantExpressionEvaluator.builtIns.getStringType())?.let {
@@ -267,38 +267,38 @@ private class ConstantExpressionEvaluatorVisitor(
             }
         }
 
-        override fun visitLiteralStringTemplateEntry(entry: JetLiteralStringTemplateEntry, data: Nothing?) = factory.createStringValue(entry.getText()).wrap()
+        override fun visitLiteralStringTemplateEntry(entry: KtLiteralStringTemplateEntry, data: Nothing?) = factory.createStringValue(entry.getText()).wrap()
 
-        override fun visitEscapeStringTemplateEntry(entry: JetEscapeStringTemplateEntry, data: Nothing?) = factory.createStringValue(entry.getUnescapedValue()).wrap()
+        override fun visitEscapeStringTemplateEntry(entry: KtEscapeStringTemplateEntry, data: Nothing?) = factory.createStringValue(entry.getUnescapedValue()).wrap()
     }
 
-    override fun visitConstantExpression(expression: JetConstantExpression, expectedType: JetType?): CompileTimeConstant<*>? {
+    override fun visitConstantExpression(expression: KtConstantExpression, expectedType: KtType?): CompileTimeConstant<*>? {
         val text = expression.getText() ?: return null
 
         val nodeElementType = expression.getNode().getElementType()
-        if (nodeElementType == JetNodeTypes.NULL) return factory.createNullValue().wrap()
+        if (nodeElementType == KtNodeTypes.NULL) return factory.createNullValue().wrap()
 
         val result: Any? = when (nodeElementType) {
-                               JetNodeTypes.INTEGER_CONSTANT -> parseLong(text)
-                               JetNodeTypes.FLOAT_CONSTANT -> parseFloatingLiteral(text)
-                               JetNodeTypes.BOOLEAN_CONSTANT -> parseBoolean(text)
-                               JetNodeTypes.CHARACTER_CONSTANT -> CompileTimeConstantChecker.parseChar(expression)
+                               KtNodeTypes.INTEGER_CONSTANT -> parseLong(text)
+                               KtNodeTypes.FLOAT_CONSTANT -> parseFloatingLiteral(text)
+                               KtNodeTypes.BOOLEAN_CONSTANT -> parseBoolean(text)
+                               KtNodeTypes.CHARACTER_CONSTANT -> CompileTimeConstantChecker.parseChar(expression)
                                else -> throw IllegalArgumentException("Unsupported constant: " + expression)
                            } ?: return null
 
-        fun isLongWithSuffix() = nodeElementType == JetNodeTypes.INTEGER_CONSTANT && hasLongSuffix(text)
+        fun isLongWithSuffix() = nodeElementType == KtNodeTypes.INTEGER_CONSTANT && hasLongSuffix(text)
         return createConstant(result, expectedType, CompileTimeConstant.Parameters(true, !isLongWithSuffix(), false, usesNonConstValAsConstant = false))
     }
 
-    override fun visitParenthesizedExpression(expression: JetParenthesizedExpression, expectedType: JetType?): CompileTimeConstant<*>? {
-        val deparenthesizedExpression = JetPsiUtil.deparenthesize(expression)
+    override fun visitParenthesizedExpression(expression: KtParenthesizedExpression, expectedType: KtType?): CompileTimeConstant<*>? {
+        val deparenthesizedExpression = KtPsiUtil.deparenthesize(expression)
         if (deparenthesizedExpression != null && deparenthesizedExpression != expression) {
             return evaluate(deparenthesizedExpression, expectedType)
         }
         return null
     }
 
-    override fun visitLabeledExpression(expression: JetLabeledExpression, expectedType: JetType?): CompileTimeConstant<*>? {
+    override fun visitLabeledExpression(expression: KtLabeledExpression, expectedType: KtType?): CompileTimeConstant<*>? {
         val baseExpression = expression.getBaseExpression()
         if (baseExpression != null) {
             return evaluate(baseExpression, expectedType)
@@ -306,7 +306,7 @@ private class ConstantExpressionEvaluatorVisitor(
         return null
     }
 
-    override fun visitStringTemplateExpression(expression: JetStringTemplateExpression, expectedType: JetType?): CompileTimeConstant<*>? {
+    override fun visitStringTemplateExpression(expression: KtStringTemplateExpression, expectedType: KtType?): CompileTimeConstant<*>? {
         val sb = StringBuilder()
         var interupted = false
         var canBeUsedInAnnotation = true
@@ -339,10 +339,10 @@ private class ConstantExpressionEvaluatorVisitor(
         else null
     }
 
-    override fun visitBinaryWithTypeRHSExpression(expression: JetBinaryExpressionWithTypeRHS, expectedType: JetType?): CompileTimeConstant<*>? =
+    override fun visitBinaryWithTypeRHSExpression(expression: KtBinaryExpressionWithTypeRHS, expectedType: KtType?): CompileTimeConstant<*>? =
             evaluate(expression.getLeft(), expectedType)
 
-    override fun visitBinaryExpression(expression: JetBinaryExpression, expectedType: JetType?): CompileTimeConstant<*>? {
+    override fun visitBinaryExpression(expression: KtBinaryExpression, expectedType: KtType?): CompileTimeConstant<*>? {
         val leftExpression = expression.getLeft() ?: return null
 
         val operationToken = expression.getOperationToken()
@@ -360,8 +360,8 @@ private class ConstantExpressionEvaluatorVisitor(
 
             if (leftValue !is Boolean || rightValue !is Boolean) return null
             val result = when (operationToken) {
-                JetTokens.ANDAND -> leftValue && rightValue
-                JetTokens.OROR -> leftValue || rightValue
+                KtTokens.ANDAND -> leftValue && rightValue
+                KtTokens.OROR -> leftValue || rightValue
                 else -> throw IllegalArgumentException("Unknown boolean operation token ${operationToken}")
             }
             return createConstant(
@@ -379,7 +379,7 @@ private class ConstantExpressionEvaluatorVisitor(
         }
     }
 
-    private fun evaluateCall(callExpression: JetExpression, receiverExpression: JetExpression, expectedType: JetType?): CompileTimeConstant<*>? {
+    private fun evaluateCall(callExpression: KtExpression, receiverExpression: KtExpression, expectedType: KtType?): CompileTimeConstant<*>? {
         val resolvedCall = callExpression.getResolvedCall(trace.getBindingContext())
         if (resolvedCall == null) return null
 
@@ -412,7 +412,7 @@ private class ConstantExpressionEvaluatorVisitor(
             if (argumentForParameter == null) return null
 
             if (isDivisionByZero(resultingDescriptorName.asString(), argumentForParameter.value)) {
-                val parentExpression: JetExpression = PsiTreeUtil.getParentOfType(receiverExpression, javaClass())!!
+                val parentExpression: KtExpression = PsiTreeUtil.getParentOfType(receiverExpression, javaClass())!!
                 trace.report(Errors.DIVISION_BY_ZERO.on(parentExpression))
                 return factory.createErrorValue("Division by zero").wrap()
             }
@@ -437,15 +437,15 @@ private class ConstantExpressionEvaluatorVisitor(
         return null
     }
 
-    private fun usesVariableAsConstant(expression: JetExpression) = ConstantExpressionEvaluator.getConstant(expression, trace.getBindingContext())?.usesVariableAsConstant ?: false
-    private fun usesNonConstValAsConstant(expression: JetExpression)
+    private fun usesVariableAsConstant(expression: KtExpression) = ConstantExpressionEvaluator.getConstant(expression, trace.getBindingContext())?.usesVariableAsConstant ?: false
+    private fun usesNonConstValAsConstant(expression: KtExpression)
             = ConstantExpressionEvaluator.getConstant(expression, trace.bindingContext)?.usesNonConstValAsConstant ?: false
 
-    private fun canBeUsedInAnnotation(expression: JetExpression) = ConstantExpressionEvaluator.getConstant(expression, trace.getBindingContext())?.canBeUsedInAnnotations ?: false
+    private fun canBeUsedInAnnotation(expression: KtExpression) = ConstantExpressionEvaluator.getConstant(expression, trace.getBindingContext())?.canBeUsedInAnnotations ?: false
 
-    private fun isPureConstant(expression: JetExpression) = ConstantExpressionEvaluator.getConstant(expression, trace.getBindingContext())?.isPure ?: false
+    private fun isPureConstant(expression: KtExpression) = ConstantExpressionEvaluator.getConstant(expression, trace.getBindingContext())?.isPure ?: false
 
-    private fun evaluateUnaryAndCheck(receiver: OperationArgument, name: String, callExpression: JetExpression): Any? {
+    private fun evaluateUnaryAndCheck(receiver: OperationArgument, name: String, callExpression: KtExpression): Any? {
         val functions = unaryOperations[UnaryOperationKey(receiver.ctcType, name)]
         if (functions == null) return null
 
@@ -458,12 +458,12 @@ private class ConstantExpressionEvaluatorVisitor(
         assert(name == "minus" || name == "unaryMinus") { "Only negation should be checked for overflow" }
 
         if (receiver.value == result) {
-            trace.report(Errors.INTEGER_OVERFLOW.on(callExpression.getStrictParentOfType<JetExpression>() ?: callExpression))
+            trace.report(Errors.INTEGER_OVERFLOW.on(callExpression.getStrictParentOfType<KtExpression>() ?: callExpression))
         }
         return result
     }
 
-    private fun evaluateBinaryAndCheck(receiver: OperationArgument, parameter: OperationArgument, name: String, callExpression: JetExpression): Any? {
+    private fun evaluateBinaryAndCheck(receiver: OperationArgument, parameter: OperationArgument, name: String, callExpression: KtExpression): Any? {
         val functions = binaryOperations[BinaryOperationKey(receiver.ctcType, parameter.ctcType, name)]
         if (functions == null) return null
 
@@ -484,13 +484,13 @@ private class ConstantExpressionEvaluatorVisitor(
         val resultInBigIntegers = checker(toBigInteger(receiver.value), toBigInteger(parameter.value))
 
         if (toBigInteger(actualResult) != resultInBigIntegers) {
-            trace.report(Errors.INTEGER_OVERFLOW.on(callExpression.getStrictParentOfType<JetExpression>() ?: callExpression))
+            trace.report(Errors.INTEGER_OVERFLOW.on(callExpression.getStrictParentOfType<KtExpression>() ?: callExpression))
         }
         return actualResult
     }
 
     private fun isDivisionByZero(name: String, parameter: Any?): Boolean {
-        if (name == OperatorConventions.BINARY_OPERATION_NAMES[JetTokens.DIV]!!.asString()) {
+        if (name == OperatorConventions.BINARY_OPERATION_NAMES[KtTokens.DIV]!!.asString()) {
             if (isIntegerType(parameter)) {
                 return (parameter as Number).toLong() == 0.toLong()
             }
@@ -501,14 +501,14 @@ private class ConstantExpressionEvaluatorVisitor(
         return false
     }
 
-    override fun visitUnaryExpression(expression: JetUnaryExpression, expectedType: JetType?): CompileTimeConstant<*>? {
+    override fun visitUnaryExpression(expression: KtUnaryExpression, expectedType: KtType?): CompileTimeConstant<*>? {
         val leftExpression = expression.getBaseExpression()
         if (leftExpression == null) return null
 
         return evaluateCall(expression.getOperationReference(), leftExpression, expectedType)
     }
 
-    override fun visitSimpleNameExpression(expression: JetSimpleNameExpression, expectedType: JetType?): CompileTimeConstant<*>? {
+    override fun visitSimpleNameExpression(expression: KtSimpleNameExpression, expectedType: KtType?): CompileTimeConstant<*>? {
         val enumDescriptor = trace.getBindingContext().get(BindingContext.REFERENCE_TARGET, expression);
         if (enumDescriptor != null && DescriptorUtils.isEnumEntry(enumDescriptor)) {
             return factory.createEnumValue(enumDescriptor as ClassDescriptor).wrap()
@@ -547,17 +547,17 @@ private class ConstantExpressionEvaluatorVisitor(
         return false
     }
 
-    override fun visitQualifiedExpression(expression: JetQualifiedExpression, expectedType: JetType?): CompileTimeConstant<*>? {
+    override fun visitQualifiedExpression(expression: KtQualifiedExpression, expectedType: KtType?): CompileTimeConstant<*>? {
         val selectorExpression = expression.getSelectorExpression()
         // 1.toInt(); 1.plus(1);
-        if (selectorExpression is JetCallExpression) {
+        if (selectorExpression is KtCallExpression) {
             val qualifiedCallValue = evaluate(selectorExpression, expectedType)
             if (qualifiedCallValue != null) {
                 return qualifiedCallValue
             }
 
             val calleeExpression = selectorExpression.getCalleeExpression()
-            if (calleeExpression !is JetSimpleNameExpression) {
+            if (calleeExpression !is KtSimpleNameExpression) {
                 return null
             }
 
@@ -565,7 +565,7 @@ private class ConstantExpressionEvaluatorVisitor(
             return evaluateCall(calleeExpression, receiverExpression, expectedType)
         }
 
-        if (selectorExpression is JetSimpleNameExpression) {
+        if (selectorExpression is KtSimpleNameExpression) {
             val result = evaluateCall(selectorExpression, expression.receiverExpression, expectedType)
             if (result != null) return result
         }
@@ -578,7 +578,7 @@ private class ConstantExpressionEvaluatorVisitor(
         return null
     }
 
-    override fun visitCallExpression(expression: JetCallExpression, expectedType: JetType?): CompileTimeConstant<*>? {
+    override fun visitCallExpression(expression: KtCallExpression, expectedType: KtType?): CompileTimeConstant<*>? {
         val call = expression.getResolvedCall(trace.getBindingContext())
         if (call == null) return null
 
@@ -613,13 +613,13 @@ private class ConstantExpressionEvaluatorVisitor(
         return null
     }
 
-    override fun visitClassLiteralExpression(expression: JetClassLiteralExpression, expectedType: JetType?): CompileTimeConstant<*>? {
+    override fun visitClassLiteralExpression(expression: KtClassLiteralExpression, expectedType: KtType?): CompileTimeConstant<*>? {
         val jetType = trace.getType(expression)!!
         if (jetType.isError()) return null
         return KClassValue(jetType).wrap()
     }
 
-    private fun resolveArguments(valueArguments: List<ValueArgument>, expectedType: JetType): List<CompileTimeConstant<*>> {
+    private fun resolveArguments(valueArguments: List<ValueArgument>, expectedType: KtType): List<CompileTimeConstant<*>> {
         val constants = arrayListOf<CompileTimeConstant<*>>()
         for (argument in valueArguments) {
             val argumentExpression = argument.getArgumentExpression()
@@ -633,13 +633,13 @@ private class ConstantExpressionEvaluatorVisitor(
         return constants
     }
 
-    override fun visitJetElement(element: JetElement, expectedType: JetType?): CompileTimeConstant<*>? {
+    override fun visitJetElement(element: KtElement, expectedType: KtType?): CompileTimeConstant<*>? {
         return null
     }
 
-    private class OperationArgument(val value: Any, val ctcType: CompileTimeType<*>, val expression: JetExpression)
+    private class OperationArgument(val value: Any, val ctcType: CompileTimeType<*>, val expression: KtExpression)
 
-    private fun createOperationArgumentForReceiver(resolvedCall: ResolvedCall<*>, expression: JetExpression): OperationArgument? {
+    private fun createOperationArgumentForReceiver(resolvedCall: ResolvedCall<*>, expression: KtExpression): OperationArgument? {
         val receiverExpressionType = getReceiverExpressionType(resolvedCall)
         if (receiverExpressionType == null) return null
 
@@ -662,7 +662,7 @@ private class ConstantExpressionEvaluatorVisitor(
     }
 
 
-    private fun getCompileTimeType(c: JetType): CompileTimeType<out Any>? {
+    private fun getCompileTimeType(c: KtType): CompileTimeType<out Any>? {
         val builtIns = constantExpressionEvaluator.builtIns
         return when (TypeUtils.makeNotNullable(c)) {
             builtIns.intType -> INT
@@ -679,7 +679,7 @@ private class ConstantExpressionEvaluatorVisitor(
         }
     }
 
-    private fun createOperationArgument(expression: JetExpression, expressionType: JetType, compileTimeType: CompileTimeType<*>): OperationArgument? {
+    private fun createOperationArgument(expression: KtExpression, expressionType: KtType, compileTimeType: CompileTimeType<*>): OperationArgument? {
         val compileTimeConstant = constantExpressionEvaluator.evaluateExpression(expression, trace, expressionType) ?: return null
         val evaluationResult = compileTimeConstant.getValue(expressionType) ?: return null
         return OperationArgument(evaluationResult, compileTimeType, expression)
@@ -687,7 +687,7 @@ private class ConstantExpressionEvaluatorVisitor(
 
     private fun createConstant(
             value: Any?,
-            expectedType: JetType?,
+            expectedType: KtType?,
             parameters: CompileTimeConstant.Parameters
     ): CompileTimeConstant<*>? {
         return if (parameters.isPure) {
@@ -701,7 +701,7 @@ private class ConstantExpressionEvaluatorVisitor(
     private fun createCompileTimeConstant(
             value: Any?,
             parameters: CompileTimeConstant.Parameters,
-            expectedType: JetType
+            expectedType: KtType
     ): CompileTimeConstant<*>? {
         return when (value) {
             is Byte, is Short, is Int, is Long -> createIntegerCompileTimeConstant((value as Number).toLong(), parameters, expectedType)
@@ -712,7 +712,7 @@ private class ConstantExpressionEvaluatorVisitor(
     private fun createIntegerCompileTimeConstant(
             value: Long,
             parameters: CompileTimeConstant.Parameters,
-            expectedType: JetType
+            expectedType: KtType
     ): CompileTimeConstant<*>? {
         if (TypeUtils.noExpectedType(expectedType) || expectedType.isError()) {
             return IntegerValueTypeConstant(value, constantExpressionEvaluator.builtIns, parameters)
@@ -794,14 +794,14 @@ private fun parseBoolean(text: String): Boolean {
 }
 
 
-private fun createCompileTimeConstantForEquals(result: Any?, operationReference: JetExpression, factory: ConstantValueFactory): ConstantValue<*>? {
+private fun createCompileTimeConstantForEquals(result: Any?, operationReference: KtExpression, factory: ConstantValueFactory): ConstantValue<*>? {
     if (result is Boolean) {
-        assert(operationReference is JetSimpleNameExpression) { "This method should be called only for equals operations" }
-        val operationToken = (operationReference as JetSimpleNameExpression).getReferencedNameElementType()
+        assert(operationReference is KtSimpleNameExpression) { "This method should be called only for equals operations" }
+        val operationToken = (operationReference as KtSimpleNameExpression).getReferencedNameElementType()
         val value: Boolean = when (operationToken) {
-            JetTokens.EQEQ -> result
-            JetTokens.EXCLEQ -> !result
-            JetTokens.IDENTIFIER -> {
+            KtTokens.EQEQ -> result
+            KtTokens.EXCLEQ -> !result
+            KtTokens.IDENTIFIER -> {
                 assert(operationReference.getReferencedNameAsName() == OperatorNameConventions.EQUALS) { "This method should be called only for equals operations" }
                 result
             }
@@ -812,16 +812,16 @@ private fun createCompileTimeConstantForEquals(result: Any?, operationReference:
     return null
 }
 
-private fun createCompileTimeConstantForCompareTo(result: Any?, operationReference: JetExpression, factory: ConstantValueFactory): ConstantValue<*>? {
+private fun createCompileTimeConstantForCompareTo(result: Any?, operationReference: KtExpression, factory: ConstantValueFactory): ConstantValue<*>? {
     if (result is Int) {
-        assert(operationReference is JetSimpleNameExpression) { "This method should be called only for compareTo operations" }
-        val operationToken = (operationReference as JetSimpleNameExpression).getReferencedNameElementType()
+        assert(operationReference is KtSimpleNameExpression) { "This method should be called only for compareTo operations" }
+        val operationToken = (operationReference as KtSimpleNameExpression).getReferencedNameElementType()
         return when (operationToken) {
-            JetTokens.LT -> factory.createBooleanValue(result < 0)
-            JetTokens.LTEQ -> factory.createBooleanValue(result <= 0)
-            JetTokens.GT -> factory.createBooleanValue(result > 0)
-            JetTokens.GTEQ -> factory.createBooleanValue(result >= 0)
-            JetTokens.IDENTIFIER -> {
+            KtTokens.LT -> factory.createBooleanValue(result < 0)
+            KtTokens.LTEQ -> factory.createBooleanValue(result <= 0)
+            KtTokens.GT -> factory.createBooleanValue(result > 0)
+            KtTokens.GTEQ -> factory.createBooleanValue(result >= 0)
+            KtTokens.IDENTIFIER -> {
                 assert(operationReference.getReferencedNameAsName() == OperatorNameConventions.COMPARE_TO) { "This method should be called only for compareTo operations" }
                 return factory.createIntValue(result)
             }
@@ -833,7 +833,7 @@ private fun createCompileTimeConstantForCompareTo(result: Any?, operationReferen
 
 fun isIntegerType(value: Any?) = value is Byte || value is Short || value is Int || value is Long
 
-private fun getReceiverExpressionType(resolvedCall: ResolvedCall<*>): JetType? {
+private fun getReceiverExpressionType(resolvedCall: ResolvedCall<*>): KtType? {
     return when (resolvedCall.getExplicitReceiverKind()) {
         ExplicitReceiverKind.DISPATCH_RECEIVER -> resolvedCall.getDispatchReceiver().getType()
         ExplicitReceiverKind.EXTENSION_RECEIVER -> resolvedCall.getExtensionReceiver().getType()
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsWithSuppression.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsWithSuppression.java
index 63b6e70aff1..bfab7e70a78 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsWithSuppression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsWithSuppression.java
@@ -68,7 +68,7 @@ public class DiagnosticsWithSuppression implements Diagnostics {
     private final Collection<Diagnostic> diagnostics;
 
     // The cache is weak: we're OK with losing it
-    private final Map<JetAnnotated, Suppressor> suppressors = new ConcurrentWeakValueHashMap<JetAnnotated, Suppressor>();
+    private final Map<KtAnnotated, Suppressor> suppressors = new ConcurrentWeakValueHashMap<KtAnnotated, Suppressor>();
 
     private final Condition<Diagnostic> filter = new Condition<Diagnostic>() {
         @Override
@@ -115,18 +115,18 @@ public class DiagnosticsWithSuppression implements Diagnostics {
     private boolean isSuppressed(@NotNull Diagnostic diagnostic) {
         PsiElement element = diagnostic.getPsiElement();
 
-        // If diagnostics are reported in a synthetic file generated by JetPsiFactory (dummy.kt),
+        // If diagnostics are reported in a synthetic file generated by KtPsiFactory (dummy.kt),
         // there's no point to present such diagnostics to the user, because the user didn't write this code
         PsiFile file = element.getContainingFile();
-        if (file instanceof JetFile) {
-            if (JetPsiFactoryKt.getDoNotAnalyze((JetFile) file) != null) return true;
+        if (file instanceof KtFile) {
+            if (KtPsiFactoryKt.getDoNotAnalyze((KtFile) file) != null) return true;
         }
 
         for (DiagnosticSuppressor suppressor : DIAGNOSTIC_SUPPRESSORS.get()) {
             if (suppressor.isSuppressed(diagnostic)) return true;
         }
 
-        JetAnnotated annotated = JetStubbedPsiUtil.getPsiOrStubParent(element, JetAnnotated.class, false);
+        KtAnnotated annotated = KtStubbedPsiUtil.getPsiOrStubParent(element, KtAnnotated.class, false);
         if (annotated == null) return false;
 
         return isSuppressedByAnnotated(diagnostic, annotated, 0);
@@ -161,7 +161,7 @@ public class DiagnosticsWithSuppression implements Diagnostics {
 
        This way we need no more lookups than the number of suppress() annotations from here to the root.
      */
-    private boolean isSuppressedByAnnotated(@NotNull Diagnostic diagnostic, @NotNull JetAnnotated annotated, int debugDepth) {
+    private boolean isSuppressedByAnnotated(@NotNull Diagnostic diagnostic, @NotNull KtAnnotated annotated, int debugDepth) {
         if (LOG.isDebugEnabled()) {
             LOG.debug("Annotated: ", annotated.getName());
             LOG.debug("Depth: ", debugDepth);
@@ -171,7 +171,7 @@ public class DiagnosticsWithSuppression implements Diagnostics {
         Suppressor suppressor = getOrCreateSuppressor(annotated);
         if (suppressor.isSuppressed(diagnostic)) return true;
 
-        JetAnnotated annotatedAbove = JetStubbedPsiUtil.getPsiOrStubParent(suppressor.getAnnotatedElement(), JetAnnotated.class, true);
+        KtAnnotated annotatedAbove = KtStubbedPsiUtil.getPsiOrStubParent(suppressor.getAnnotatedElement(), KtAnnotated.class, true);
         if (annotatedAbove == null) return false;
 
         boolean suppressed = isSuppressedByAnnotated(diagnostic, annotatedAbove, debugDepth + 1);
@@ -184,7 +184,7 @@ public class DiagnosticsWithSuppression implements Diagnostics {
     }
 
     @NotNull
-    private Suppressor getOrCreateSuppressor(@NotNull JetAnnotated annotated) {
+    private Suppressor getOrCreateSuppressor(@NotNull KtAnnotated annotated) {
         Suppressor suppressor = suppressors.get(annotated);
         if (suppressor == null) {
             Set<String> strings = getSuppressingStrings(annotated);
@@ -202,7 +202,7 @@ public class DiagnosticsWithSuppression implements Diagnostics {
         return suppressor;
     }
 
-    private Set<String> getSuppressingStrings(@NotNull JetAnnotated annotated) {
+    private Set<String> getSuppressingStrings(@NotNull KtAnnotated annotated) {
         ImmutableSet.Builder<String> builder = ImmutableSet.builder();
 
         DeclarationDescriptor descriptor = context.get(BindingContext.DECLARATION_TO_DESCRIPTOR, annotated);
@@ -213,7 +213,7 @@ public class DiagnosticsWithSuppression implements Diagnostics {
             }
         }
         else {
-            for (JetAnnotationEntry annotationEntry : annotated.getAnnotationEntries()) {
+            for (KtAnnotationEntry annotationEntry : annotated.getAnnotationEntries()) {
                 AnnotationDescriptor annotationDescriptor = context.get(BindingContext.ANNOTATION, annotationEntry);
                 processAnnotation(builder, annotationDescriptor);
             }
@@ -255,14 +255,14 @@ public class DiagnosticsWithSuppression implements Diagnostics {
     }
 
     private static abstract class Suppressor {
-        private final JetAnnotated annotated;
+        private final KtAnnotated annotated;
 
-        protected Suppressor(@NotNull JetAnnotated annotated) {
+        protected Suppressor(@NotNull KtAnnotated annotated) {
             this.annotated = annotated;
         }
 
         @NotNull
-        public JetAnnotated getAnnotatedElement() {
+        public KtAnnotated getAnnotatedElement() {
             return annotated;
         }
 
@@ -274,7 +274,7 @@ public class DiagnosticsWithSuppression implements Diagnostics {
 
     private static class EmptySuppressor extends Suppressor {
 
-        private EmptySuppressor(@NotNull JetAnnotated annotated) {
+        private EmptySuppressor(@NotNull KtAnnotated annotated) {
             super(annotated);
         }
 
@@ -292,7 +292,7 @@ public class DiagnosticsWithSuppression implements Diagnostics {
     private static class SingularSuppressor extends Suppressor {
         private final String string;
 
-        private SingularSuppressor(@NotNull JetAnnotated annotated, @NotNull String string) {
+        private SingularSuppressor(@NotNull KtAnnotated annotated, @NotNull String string) {
             super(annotated);
             this.string = string;
         }
@@ -312,7 +312,7 @@ public class DiagnosticsWithSuppression implements Diagnostics {
     private static class MultiSuppressor extends Suppressor {
         private final Set<String> strings;
 
-        private MultiSuppressor(@NotNull JetAnnotated annotated, @NotNull Set<String> strings) {
+        private MultiSuppressor(@NotNull KtAnnotated annotated, @NotNull Set<String> strings) {
             super(annotated);
             this.strings = strings;
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/SuppressDiagnosticsByAnnotations.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/SuppressDiagnosticsByAnnotations.kt
index 51d2a3bbc60..a427a46088c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/SuppressDiagnosticsByAnnotations.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/SuppressDiagnosticsByAnnotations.kt
@@ -22,16 +22,16 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFunction
+import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory0
 
-public val FUNCTION_NO_BODY_ERRORS: List<DiagnosticFactory1<JetFunction, SimpleFunctionDescriptor>> =
+public val FUNCTION_NO_BODY_ERRORS: List<DiagnosticFactory1<KtFunction, SimpleFunctionDescriptor>> =
         listOf(Errors.NON_ABSTRACT_FUNCTION_WITH_NO_BODY, Errors.NON_MEMBER_FUNCTION_NO_BODY, Errors.FINAL_FUNCTION_WITH_NO_BODY)
 
-public val PROPERTY_NOT_INITIALIZED_ERRORS: List<DiagnosticFactory0<JetProperty>> =
+public val PROPERTY_NOT_INITIALIZED_ERRORS: List<DiagnosticFactory0<KtProperty>> =
         listOf(Errors.MUST_BE_INITIALIZED, Errors.MUST_BE_INITIALIZED_OR_BE_ABSTRACT)
 
 public abstract class SuppressDiagnosticsByAnnotations(
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineAnalyzerExtension.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineAnalyzerExtension.java
index 62c52f616c0..e004f15a752 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineAnalyzerExtension.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineAnalyzerExtension.java
@@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.diagnostics.Errors;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
@@ -39,7 +39,7 @@ public class InlineAnalyzerExtension implements FunctionAnalyzerExtension.Analyz
 
     @Override
     public void process(
-            @NotNull final FunctionDescriptor descriptor, @NotNull JetNamedFunction function, @NotNull final BindingTrace trace
+            @NotNull final FunctionDescriptor descriptor, @NotNull KtNamedFunction function, @NotNull final BindingTrace trace
     ) {
         assert InlineUtil.isInline(descriptor) : "This method should be invoked on inline function: " + descriptor;
 
@@ -47,21 +47,21 @@ public class InlineAnalyzerExtension implements FunctionAnalyzerExtension.Analyz
         checkNotVirtual(descriptor, function, trace);
         checkHasInlinableAndNullability(descriptor, function, trace);
 
-        JetVisitorVoid visitor = new JetVisitorVoid() {
+        KtVisitorVoid visitor = new KtVisitorVoid() {
             @Override
-            public void visitJetElement(@NotNull JetElement element) {
+            public void visitJetElement(@NotNull KtElement element) {
                 super.visitJetElement(element);
                 element.acceptChildren(this);
             }
 
             @Override
-            public void visitClass(@NotNull JetClass klass) {
+            public void visitClass(@NotNull KtClass klass) {
                 trace.report(Errors.NOT_YET_SUPPORTED_IN_INLINE.on(klass, klass, descriptor));
             }
 
             @Override
-            public void visitNamedFunction(@NotNull JetNamedFunction function) {
-                if (function.getParent().getParent() instanceof JetObjectDeclaration) {
+            public void visitNamedFunction(@NotNull KtNamedFunction function) {
+                if (function.getParent().getParent() instanceof KtObjectDeclaration) {
                     super.visitNamedFunction(function);
                 } else {
                     trace.report(Errors.NOT_YET_SUPPORTED_IN_INLINE.on(function, function, descriptor));
@@ -74,13 +74,13 @@ public class InlineAnalyzerExtension implements FunctionAnalyzerExtension.Analyz
 
     private static void checkDefaults(
             @NotNull FunctionDescriptor functionDescriptor,
-            @NotNull JetFunction function,
+            @NotNull KtFunction function,
             @NotNull BindingTrace trace
     ) {
-        List<JetParameter> jetParameters = function.getValueParameters();
+        List<KtParameter> jetParameters = function.getValueParameters();
         for (ValueParameterDescriptor parameter : functionDescriptor.getValueParameters()) {
             if (DescriptorUtilsKt.hasDefaultValue(parameter)) {
-                JetParameter jetParameter = jetParameters.get(parameter.getIndex());
+                KtParameter jetParameter = jetParameters.get(parameter.getIndex());
                 //report not supported default only on inlinable lambda and on parameter with inherited default (there is some problems to inline it)
                 if (checkInlinableParameter(parameter, jetParameter, functionDescriptor, null) || !parameter.declaresDefaultValue()) {
                     trace.report(Errors.NOT_YET_SUPPORTED_IN_INLINE.on(jetParameter, jetParameter, functionDescriptor));
@@ -91,7 +91,7 @@ public class InlineAnalyzerExtension implements FunctionAnalyzerExtension.Analyz
 
     private static void checkNotVirtual(
             @NotNull FunctionDescriptor functionDescriptor,
-            @NotNull JetFunction function,
+            @NotNull KtFunction function,
             @NotNull BindingTrace trace
     ) {
         if (Visibilities.isPrivate(functionDescriptor.getVisibility()) || functionDescriptor.getModality() == Modality.FINAL) {
@@ -108,7 +108,7 @@ public class InlineAnalyzerExtension implements FunctionAnalyzerExtension.Analyz
 
     private static void checkHasInlinableAndNullability(
             @NotNull FunctionDescriptor functionDescriptor,
-            @NotNull JetFunction function,
+            @NotNull KtFunction function,
             @NotNull BindingTrace trace
     ) {
         boolean hasInlinable = false;
@@ -119,7 +119,7 @@ public class InlineAnalyzerExtension implements FunctionAnalyzerExtension.Analyz
         }
         ReceiverParameterDescriptor receiverParameter = functionDescriptor.getExtensionReceiverParameter();
         if (receiverParameter != null) {
-            JetTypeReference receiver = function.getReceiverTypeReference();
+            KtTypeReference receiver = function.getReceiverTypeReference();
             assert receiver != null : "Descriptor has a receiver but psi doesn't " + function.getText();
             hasInlinable |= checkInlinableParameter(receiverParameter, receiver, functionDescriptor, trace);
         }
@@ -127,8 +127,8 @@ public class InlineAnalyzerExtension implements FunctionAnalyzerExtension.Analyz
         hasInlinable |= DescriptorUtils.containsReifiedTypeParameters(functionDescriptor);
 
         if (!hasInlinable) {
-            JetModifierList modifierList = function.getModifierList();
-            PsiElement inlineModifier = modifierList == null ? null : modifierList.getModifier(JetTokens.INLINE_KEYWORD);
+            KtModifierList modifierList = function.getModifierList();
+            PsiElement inlineModifier = modifierList == null ? null : modifierList.getModifier(KtTokens.INLINE_KEYWORD);
             PsiElement reportOn = inlineModifier == null ? function : inlineModifier;
             trace.report(Errors.NOTHING_TO_INLINE.on(reportOn, functionDescriptor));
         }
@@ -136,7 +136,7 @@ public class InlineAnalyzerExtension implements FunctionAnalyzerExtension.Analyz
 
     public static boolean checkInlinableParameter(
             @NotNull ParameterDescriptor parameter,
-            @NotNull JetElement expression,
+            @NotNull KtElement expression,
             @NotNull CallableDescriptor functionDescriptor,
             @Nullable BindingTrace trace
     ) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java
index 5960c12737c..f3350b6af47 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java
@@ -54,10 +54,10 @@ public class InlineUtil {
 
     public static boolean checkNonLocalReturnUsage(
             @NotNull DeclarationDescriptor fromFunction,
-            @NotNull JetExpression startExpression,
+            @NotNull KtExpression startExpression,
             @NotNull BindingTrace trace
     ) {
-        PsiElement containingFunction = PsiTreeUtil.getParentOfType(startExpression, JetClassOrObject.class, JetDeclarationWithBody.class);
+        PsiElement containingFunction = PsiTreeUtil.getParentOfType(startExpression, KtClassOrObject.class, KtDeclarationWithBody.class);
         if (containingFunction == null) {
             return false;
         }
@@ -70,7 +70,7 @@ public class InlineUtil {
         BindingContext bindingContext = trace.getBindingContext();
 
         while (canBeInlineArgument(containingFunction) && fromFunction != containingFunctionDescriptor) {
-            if (!isInlinedArgument((JetFunction) containingFunction, bindingContext, true)) {
+            if (!isInlinedArgument((KtFunction) containingFunction, bindingContext, true)) {
                 return false;
             }
 
@@ -85,13 +85,13 @@ public class InlineUtil {
     }
 
     public static boolean isInlinedArgument(
-            @NotNull JetFunction argument,
+            @NotNull KtFunction argument,
             @NotNull BindingContext bindingContext,
             boolean checkNonLocalReturn
     ) {
         if (!canBeInlineArgument(argument)) return false;
 
-        JetExpression call = JetPsiUtil.getParentCallIfPresent(argument);
+        KtExpression call = KtPsiUtil.getParentCallIfPresent(argument);
         if (call != null) {
             ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(call, bindingContext);
             if (resolvedCall != null && isInline(resolvedCall.getResultingDescriptor())) {
@@ -111,7 +111,7 @@ public class InlineUtil {
     }
 
     public static boolean canBeInlineArgument(@Nullable PsiElement functionalExpression) {
-        return functionalExpression instanceof JetFunctionLiteral || functionalExpression instanceof JetNamedFunction;
+        return functionalExpression instanceof KtFunctionLiteral || functionalExpression instanceof KtNamedFunction;
     }
 
     @Nullable
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/DeclarationScopeProviderImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/DeclarationScopeProviderImpl.java
index 9591bdfb74d..d7570a3f4b0 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/DeclarationScopeProviderImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/DeclarationScopeProviderImpl.java
@@ -42,38 +42,38 @@ public class DeclarationScopeProviderImpl implements DeclarationScopeProvider {
     @Override
     @NotNull
     public LexicalScope getResolutionScopeForDeclaration(@NotNull PsiElement elementOfDeclaration) {
-        JetDeclaration jetDeclaration = JetStubbedPsiUtil.getPsiOrStubParent(elementOfDeclaration, JetDeclaration.class, false);
+        KtDeclaration ktDeclaration = KtStubbedPsiUtil.getPsiOrStubParent(elementOfDeclaration, KtDeclaration.class, false);
 
-        assert !(elementOfDeclaration instanceof JetDeclaration) || jetDeclaration == elementOfDeclaration :
+        assert !(elementOfDeclaration instanceof KtDeclaration) || ktDeclaration == elementOfDeclaration :
                 "For JetDeclaration element getParentOfType() should return itself.";
-        assert jetDeclaration != null : "Should be contained inside declaration.";
+        assert ktDeclaration != null : "Should be contained inside declaration.";
 
-        JetDeclaration parentDeclaration = JetStubbedPsiUtil.getContainingDeclaration(jetDeclaration);
+        KtDeclaration parentDeclaration = KtStubbedPsiUtil.getContainingDeclaration(ktDeclaration);
 
-        if (jetDeclaration instanceof JetPropertyAccessor) {
-            parentDeclaration = JetStubbedPsiUtil.getContainingDeclaration(parentDeclaration, JetDeclaration.class);
+        if (ktDeclaration instanceof KtPropertyAccessor) {
+            parentDeclaration = KtStubbedPsiUtil.getContainingDeclaration(parentDeclaration, KtDeclaration.class);
         }
 
         if (parentDeclaration == null) {
-            return fileScopeProvider.getFileScope((JetFile) elementOfDeclaration.getContainingFile());
+            return fileScopeProvider.getFileScope((KtFile) elementOfDeclaration.getContainingFile());
         }
 
-        if (parentDeclaration instanceof JetClassOrObject) {
-            JetClassOrObject classOrObject = (JetClassOrObject) parentDeclaration;
+        if (parentDeclaration instanceof KtClassOrObject) {
+            KtClassOrObject classOrObject = (KtClassOrObject) parentDeclaration;
             LazyClassDescriptor classDescriptor = (LazyClassDescriptor) lazyDeclarationResolver.getClassDescriptor(classOrObject, NoLookupLocation.WHEN_GET_DECLARATION_SCOPE);
-            if (jetDeclaration instanceof JetClassInitializer || jetDeclaration instanceof JetProperty) {
+            if (ktDeclaration instanceof KtClassInitializer || ktDeclaration instanceof KtProperty) {
                 return classDescriptor.getScopeForInitializerResolution();
             }
-            if (jetDeclaration instanceof JetObjectDeclaration
-                || (jetDeclaration instanceof JetClass && !((JetClass) jetDeclaration).isInner())) {
+            if (ktDeclaration instanceof KtObjectDeclaration
+                || (ktDeclaration instanceof KtClass && !((KtClass) ktDeclaration).isInner())) {
                 return classDescriptor.getScopeForStaticMemberDeclarationResolution();
             }
 
             return classDescriptor.getScopeForMemberDeclarationResolution();
         }
 
-        throw new IllegalStateException("Don't call this method for local declarations: " + jetDeclaration + "\n" +
-                                        PsiUtilsKt.getElementTextWithContext(jetDeclaration));
+        throw new IllegalStateException("Don't call this method for local declarations: " + ktDeclaration + "\n" +
+                                        PsiUtilsKt.getElementTextWithContext(ktDeclaration));
     }
 
     @NotNull
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt
index a7cc4558675..3cc70c0cd96 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt
@@ -16,20 +16,20 @@
 
 package org.jetbrains.kotlin.resolve.lazy
 
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 
 public interface FileScopeProvider {
-    fun getFileScope(file: JetFile): LazyFileScope
+    fun getFileScope(file: KtFile): LazyFileScope
 
     public object ThrowException : FileScopeProvider {
-        override fun getFileScope(file: JetFile): LazyFileScope {
+        override fun getFileScope(file: KtFile): LazyFileScope {
             throw UnsupportedOperationException("Should not be called")
         }
     }
 
     public interface AdditionalScopes {
-        public val scopes: List<JetScope>
+        public val scopes: List<KtScope>
     }
 }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt
index 911837959d8..bebaf569741 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt
@@ -19,12 +19,15 @@ package org.jetbrains.kotlin.resolve.lazy
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.impl.SubpackagesScope
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetCodeFragment
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetImportsFactory
-import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtImportsFactory
+import org.jetbrains.kotlin.psi.KtCodeFragment
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.NoSubpackagesInPackageScope
+import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
+import org.jetbrains.kotlin.resolve.TemporaryBindingTrace
 import org.jetbrains.kotlin.resolve.bindingContextUtil.recordScope
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.storage.getValue
 import org.jetbrains.kotlin.utils.sure
@@ -36,23 +39,23 @@ public class FileScopeProviderImpl(
         private val moduleDescriptor: ModuleDescriptor,
         private val qualifiedExpressionResolver: QualifiedExpressionResolver,
         private val bindingTrace: BindingTrace,
-        private val jetImportsFactory: JetImportsFactory,
+        private val ktImportsFactory: KtImportsFactory,
         private val additionalScopes: Iterable<FileScopeProvider.AdditionalScopes>
 ) : FileScopeProvider {
 
     private val defaultImports by storageManager.createLazyValue {
-        jetImportsFactory.createImportDirectives(moduleDescriptor.defaultImports)
+        ktImportsFactory.createImportDirectives(moduleDescriptor.defaultImports)
     }
 
-    private val fileScopes = storageManager.createMemoizedFunction { file: JetFile -> createFileScope(file) }
+    private val fileScopes = storageManager.createMemoizedFunction { file: KtFile -> createFileScope(file) }
 
-    override fun getFileScope(file: JetFile) = fileScopes(file)
+    override fun getFileScope(file: KtFile) = fileScopes(file)
 
-    private fun createFileScope(file: JetFile): LazyFileScope {
+    private fun createFileScope(file: KtFile): LazyFileScope {
         val debugName = "LazyFileScope for file " + file.getName()
         val tempTrace = TemporaryBindingTrace.create(bindingTrace, "Transient trace for default imports lazy resolve")
 
-        val imports = if (file is JetCodeFragment)
+        val imports = if (file is KtCodeFragment)
             file.importsAsImportList()?.getImports() ?: listOf()
         else
             file.getImportDirectives()
@@ -69,7 +72,7 @@ public class FileScopeProviderImpl(
         val defaultAliasImportResolver = createImportResolver(AliasImportsIndexed(defaultImports), tempTrace)
         val defaultAllUnderImportResolver = createImportResolver(AllUnderImportsIndexed(defaultImports), tempTrace)
 
-        val scopeChain = ArrayList<JetScope>()
+        val scopeChain = ArrayList<KtScope>()
 
         scopeChain.add(LazyImportScope(packageFragment, aliasImportResolver, LazyImportScope.FilteringKind.ALL, "Alias imports in $debugName"))
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ForceResolveUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ForceResolveUtil.java
index 08a21db625c..7fba79bc9e5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ForceResolveUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ForceResolveUtil.java
@@ -22,7 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.types.*;
 
 import java.util.Collection;
@@ -37,7 +37,7 @@ public class ForceResolveUtil {
         return descriptor;
     }
 
-    public static void forceResolveAllContents(@NotNull JetScope scope) {
+    public static void forceResolveAllContents(@NotNull KtScope scope) {
         forceResolveAllContents(scope.getAllDescriptors());
     }
 
@@ -47,8 +47,8 @@ public class ForceResolveUtil {
         }
     }
 
-    public static void forceResolveAllContents(@NotNull Collection<JetType> types) {
-        for (JetType type : types) {
+    public static void forceResolveAllContents(@NotNull Collection<KtType> types) {
+        for (KtType type : types) {
             forceResolveAllContents(type);
         }
     }
@@ -87,7 +87,7 @@ public class ForceResolveUtil {
     }
 
     @Nullable
-    public static JetType forceResolveAllContents(@Nullable JetType type) {
+    public static KtType forceResolveAllContents(@Nullable KtType type) {
         if (type == null) return null;
 
         forceResolveAllContents(type.getAnnotations());
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/KotlinCodeAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/KotlinCodeAnalyzer.java
index 14812adbf9a..09bfe135c7a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/KotlinCodeAnalyzer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/KotlinCodeAnalyzer.java
@@ -22,8 +22,8 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
 import org.jetbrains.kotlin.incremental.components.LookupLocation;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetDeclaration;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtDeclaration;
 import org.jetbrains.kotlin.resolve.BindingContext;
 
 public interface KotlinCodeAnalyzer extends TopLevelDescriptorProvider {
@@ -32,13 +32,13 @@ public interface KotlinCodeAnalyzer extends TopLevelDescriptorProvider {
     ModuleDescriptor getModuleDescriptor();
 
     @NotNull
-    ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject, @NotNull LookupLocation location);
+    ClassDescriptor getClassDescriptor(@NotNull KtClassOrObject classOrObject, @NotNull LookupLocation location);
 
     @NotNull
     BindingContext getBindingContext();
 
     @NotNull
-    DeclarationDescriptor resolveToDescriptor(@NotNull JetDeclaration declaration);
+    DeclarationDescriptor resolveToDescriptor(@NotNull KtDeclaration declaration);
 
     @NotNull
     DeclarationScopeProvider getDeclarationScopeProvider();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java
index 8effadadf04..7e61da3f909 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.storage.LockBasedLazyResolveStorageManager;
 
 import javax.inject.Inject;
@@ -65,8 +65,8 @@ public class LazyDeclarationResolver {
     }
 
     @NotNull
-    public ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject, @NotNull LookupLocation location) {
-        JetScope scope = getMemberScopeDeclaredIn(classOrObject, location);
+    public ClassDescriptor getClassDescriptor(@NotNull KtClassOrObject classOrObject, @NotNull LookupLocation location) {
+        KtScope scope = getMemberScopeDeclaredIn(classOrObject, location);
 
         // Why not use the result here. Because it may be that there is a redeclaration:
         //     class A {} class A { fun foo(): A<completion here>}
@@ -93,31 +93,31 @@ public class LazyDeclarationResolver {
     }
 
     @NotNull
-    public DeclarationDescriptor resolveToDescriptor(@NotNull JetDeclaration declaration) {
+    public DeclarationDescriptor resolveToDescriptor(@NotNull KtDeclaration declaration) {
         return resolveToDescriptor(declaration, /*track =*/true);
     }
 
     @NotNull
-    private DeclarationDescriptor resolveToDescriptor(@NotNull JetDeclaration declaration, final boolean track) {
-        DeclarationDescriptor result = declaration.accept(new JetVisitor<DeclarationDescriptor, Void>() {
+    private DeclarationDescriptor resolveToDescriptor(@NotNull KtDeclaration declaration, final boolean track) {
+        DeclarationDescriptor result = declaration.accept(new KtVisitor<DeclarationDescriptor, Void>() {
             @NotNull
-            private LookupLocation lookupLocationFor(@NotNull JetDeclaration declaration, boolean isTopLevel) {
+            private LookupLocation lookupLocationFor(@NotNull KtDeclaration declaration, boolean isTopLevel) {
                 return isTopLevel && track ? new KotlinLookupLocation(declaration) : NoLookupLocation.WHEN_RESOLVE_DECLARATION;
             }
 
             @Override
-            public DeclarationDescriptor visitClass(@NotNull JetClass klass, Void data) {
+            public DeclarationDescriptor visitClass(@NotNull KtClass klass, Void data) {
                 return getClassDescriptor(klass, lookupLocationFor(klass, klass.isTopLevel()));
             }
 
             @Override
-            public DeclarationDescriptor visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, Void data) {
+            public DeclarationDescriptor visitObjectDeclaration(@NotNull KtObjectDeclaration declaration, Void data) {
                 return getClassDescriptor(declaration, lookupLocationFor(declaration, declaration.isTopLevel()));
             }
 
             @Override
-            public DeclarationDescriptor visitTypeParameter(@NotNull JetTypeParameter parameter, Void data) {
-                JetTypeParameterListOwner ownerElement = PsiTreeUtil.getParentOfType(parameter, JetTypeParameterListOwner.class);
+            public DeclarationDescriptor visitTypeParameter(@NotNull KtTypeParameter parameter, Void data) {
+                KtTypeParameterListOwner ownerElement = PsiTreeUtil.getParentOfType(parameter, KtTypeParameterListOwner.class);
                 assert ownerElement != null : "Owner not found for type parameter: " + parameter.getText();
                 DeclarationDescriptor ownerDescriptor = resolveToDescriptor(ownerElement, /*track =*/false);
 
@@ -145,18 +145,18 @@ public class LazyDeclarationResolver {
             }
 
             @Override
-            public DeclarationDescriptor visitNamedFunction(@NotNull JetNamedFunction function, Void data) {
+            public DeclarationDescriptor visitNamedFunction(@NotNull KtNamedFunction function, Void data) {
                 LookupLocation location = lookupLocationFor(function, function.isTopLevel());
-                JetScope scopeForDeclaration = getMemberScopeDeclaredIn(function, location);
+                KtScope scopeForDeclaration = getMemberScopeDeclaredIn(function, location);
                 scopeForDeclaration.getFunctions(function.getNameAsSafeName(), location);
                 return getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, function);
             }
 
             @Override
-            public DeclarationDescriptor visitParameter(@NotNull JetParameter parameter, Void data) {
+            public DeclarationDescriptor visitParameter(@NotNull KtParameter parameter, Void data) {
                 PsiElement grandFather = parameter.getParent().getParent();
-                if (grandFather instanceof JetPrimaryConstructor) {
-                    JetClassOrObject jetClass = ((JetPrimaryConstructor) grandFather).getContainingClassOrObject();
+                if (grandFather instanceof KtPrimaryConstructor) {
+                    KtClassOrObject jetClass = ((KtPrimaryConstructor) grandFather).getContainingClassOrObject();
                     // This is a primary constructor parameter
                     ClassDescriptor classDescriptor = getClassDescriptor(jetClass, lookupLocationFor(jetClass, false));
                     if (parameter.hasValOrVar()) {
@@ -170,14 +170,14 @@ public class LazyDeclarationResolver {
                         return getBindingContext().get(BindingContext.VALUE_PARAMETER, parameter);
                     }
                 }
-                else if (grandFather instanceof JetNamedFunction) {
-                    FunctionDescriptor function = (FunctionDescriptor) visitNamedFunction((JetNamedFunction) grandFather, data);
+                else if (grandFather instanceof KtNamedFunction) {
+                    FunctionDescriptor function = (FunctionDescriptor) visitNamedFunction((KtNamedFunction) grandFather, data);
                     function.getValueParameters();
                     return getBindingContext().get(BindingContext.VALUE_PARAMETER, parameter);
                 }
-                else if (grandFather instanceof JetSecondaryConstructor) {
+                else if (grandFather instanceof KtSecondaryConstructor) {
                     ConstructorDescriptor constructorDescriptor = (ConstructorDescriptor) visitSecondaryConstructor(
-                            (JetSecondaryConstructor) grandFather, data
+                            (KtSecondaryConstructor) grandFather, data
                     );
                     constructorDescriptor.getValueParameters();
                     return getBindingContext().get(BindingContext.VALUE_PARAMETER, parameter);
@@ -189,32 +189,32 @@ public class LazyDeclarationResolver {
             }
 
             @Override
-            public DeclarationDescriptor visitSecondaryConstructor(@NotNull JetSecondaryConstructor constructor, Void data) {
-                getClassDescriptor((JetClassOrObject) constructor.getParent().getParent(), lookupLocationFor(constructor, false)).getConstructors();
+            public DeclarationDescriptor visitSecondaryConstructor(@NotNull KtSecondaryConstructor constructor, Void data) {
+                getClassDescriptor((KtClassOrObject) constructor.getParent().getParent(), lookupLocationFor(constructor, false)).getConstructors();
                 return getBindingContext().get(BindingContext.CONSTRUCTOR, constructor);
             }
 
             @Override
-            public DeclarationDescriptor visitPrimaryConstructor(@NotNull JetPrimaryConstructor constructor, Void data) {
+            public DeclarationDescriptor visitPrimaryConstructor(@NotNull KtPrimaryConstructor constructor, Void data) {
                 getClassDescriptor(constructor.getContainingClassOrObject(), lookupLocationFor(constructor, false)).getConstructors();
                 return getBindingContext().get(BindingContext.CONSTRUCTOR, constructor);
             }
 
             @Override
-            public DeclarationDescriptor visitProperty(@NotNull JetProperty property, Void data) {
+            public DeclarationDescriptor visitProperty(@NotNull KtProperty property, Void data) {
                 LookupLocation location = lookupLocationFor(property, property.isTopLevel());
-                JetScope scopeForDeclaration = getMemberScopeDeclaredIn(property, location);
+                KtScope scopeForDeclaration = getMemberScopeDeclaredIn(property, location);
                 scopeForDeclaration.getProperties(property.getNameAsSafeName(), location);
                 return getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, property);
             }
 
             @Override
-            public DeclarationDescriptor visitScript(@NotNull JetScript script, Void data) {
+            public DeclarationDescriptor visitScript(@NotNull KtScript script, Void data) {
                 return topLevelDescriptorProvider.getScriptDescriptor(script);
             }
 
             @Override
-            public DeclarationDescriptor visitJetElement(@NotNull JetElement element, Void data) {
+            public DeclarationDescriptor visitJetElement(@NotNull KtElement element, Void data) {
                 throw new IllegalArgumentException("Unsupported declaration type: " + element + " " +
                                                    PsiUtilsKt.getElementTextWithContext(element));
             }
@@ -226,18 +226,18 @@ public class LazyDeclarationResolver {
     }
 
     @NotNull
-    /*package*/ JetScope getMemberScopeDeclaredIn(@NotNull JetDeclaration declaration, @NotNull LookupLocation location) {
-        JetDeclaration parentDeclaration = JetStubbedPsiUtil.getContainingDeclaration(declaration);
+    /*package*/ KtScope getMemberScopeDeclaredIn(@NotNull KtDeclaration declaration, @NotNull LookupLocation location) {
+        KtDeclaration parentDeclaration = KtStubbedPsiUtil.getContainingDeclaration(declaration);
         boolean isTopLevel = parentDeclaration == null;
         if (isTopLevel) { // for top level declarations we search directly in package because of possible conflicts with imports
-            FqName fqName = ((JetFile) declaration.getContainingFile()).getPackageFqName();
+            FqName fqName = ((KtFile) declaration.getContainingFile()).getPackageFqName();
             LazyPackageDescriptor packageDescriptor = topLevelDescriptorProvider.getPackageFragment(fqName);
             assert packageDescriptor != null;
             return packageDescriptor.getMemberScope();
         }
         else {
-            if (parentDeclaration instanceof JetClassOrObject) {
-                return getClassDescriptor((JetClassOrObject) parentDeclaration, location).getUnsubstitutedMemberScope();
+            if (parentDeclaration instanceof KtClassOrObject) {
+                return getClassDescriptor((KtClassOrObject) parentDeclaration, location).getUnsubstitutedMemberScope();
             } else {
                 throw new IllegalStateException("Don't call this method for local declarations: " + declaration + "\n" +
                                                 PsiUtilsKt.getElementTextWithContext(declaration));
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt
index e48716f870d..86b5bd51c4b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt
@@ -20,14 +20,14 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetImportDirective
+import org.jetbrains.kotlin.psi.KtImportDirective
 import org.jetbrains.kotlin.resolve.scopes.ChainedScope
 import org.jetbrains.kotlin.resolve.scopes.FileScope
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.utils.Printer
 
 class LazyFileScope(
-        scopeChain: List<JetScope>,
+        scopeChain: List<KtScope>,
         private val aliasImportResolver: LazyImportResolver,
         private val allUnderImportResolver: LazyImportResolver,
         containingDeclaration: PackageFragmentDescriptor,
@@ -51,7 +51,7 @@ class LazyFileScope(
         allUnderImportResolver.forceResolveAllContents()
     }
 
-    public fun forceResolveImport(importDirective: JetImportDirective) {
+    public fun forceResolveImport(importDirective: KtImportDirective) {
         if (importDirective.isAllUnder()) {
             allUnderImportResolver.forceResolveImportDirective(importDirective)
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt
index ab6808269d5..19fa8a42c46 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt
@@ -24,35 +24,35 @@ import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.incremental.KotlinLookupLocation
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetImportDirective
-import org.jetbrains.kotlin.psi.JetPsiUtil
+import org.jetbrains.kotlin.psi.KtImportDirective
+import org.jetbrains.kotlin.psi.KtPsiUtil
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.PlatformTypesMappedToKotlinChecker
 import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.util.collectionUtils.concat
 import org.jetbrains.kotlin.utils.Printer
 import java.util.*
 
 interface IndexedImports {
-    val imports: List<JetImportDirective>
-    fun importsForName(name: Name): Collection<JetImportDirective>
+    val imports: List<KtImportDirective>
+    fun importsForName(name: Name): Collection<KtImportDirective>
 }
 
-class AllUnderImportsIndexed(allImports: Collection<JetImportDirective>) : IndexedImports {
+class AllUnderImportsIndexed(allImports: Collection<KtImportDirective>) : IndexedImports {
     override val imports = allImports.filter { it.isAllUnder() }
     override fun importsForName(name: Name) = imports
 }
 
-class AliasImportsIndexed(allImports: Collection<JetImportDirective>) : IndexedImports {
+class AliasImportsIndexed(allImports: Collection<KtImportDirective>) : IndexedImports {
     override val imports = allImports.filter { !it.isAllUnder() }
 
-    private val nameToDirectives: ListMultimap<Name, JetImportDirective> by lazy {
-        val builder = ImmutableListMultimap.builder<Name, JetImportDirective>()
+    private val nameToDirectives: ListMultimap<Name, KtImportDirective> by lazy {
+        val builder = ImmutableListMultimap.builder<Name, KtImportDirective>()
 
         for (directive in imports) {
             val path = directive.getImportPath() ?: continue // parse error
@@ -75,7 +75,7 @@ class LazyImportResolver(
         private val packageFragment: PackageFragmentDescriptor
 ) {
     private val importedScopesProvider = storageManager.createMemoizedFunctionWithNullableValues {
-        directive: JetImportDirective ->
+        directive: KtImportDirective ->
             val directiveImportScope = qualifiedExpressionResolver.processImportReference(
                     directive, moduleDescriptor, traceForImportResolve, packageFragment) ?: return@createMemoizedFunctionWithNullableValues null
 
@@ -88,12 +88,12 @@ class LazyImportResolver(
     }
 
     public fun forceResolveAllContents() {
-        val explicitClassImports = HashMultimap.create<String, JetImportDirective>()
+        val explicitClassImports = HashMultimap.create<String, KtImportDirective>()
         for (importDirective in indexedImports.imports) {
             forceResolveImportDirective(importDirective)
             val scope = importedScopesProvider(importDirective)
 
-            val alias = JetPsiUtil.getAliasName(importDirective)?.identifier
+            val alias = KtPsiUtil.getAliasName(importDirective)?.identifier
             if (scope != null && alias != null) {
                 if (scope.getClassifier(Name.identifier(alias), KotlinLookupLocation(importDirective)) != null) {
                     explicitClassImports.put(alias, importDirective)
@@ -115,13 +115,13 @@ class LazyImportResolver(
         }
     }
 
-    public fun forceResolveImportDirective(importDirective: JetImportDirective) {
+    public fun forceResolveImportDirective(importDirective: KtImportDirective) {
         getImportScope(importDirective)
     }
 
     public fun <D : DeclarationDescriptor> selectSingleFromImports(
             name: Name,
-            descriptorSelector: (JetScope, Name) -> D?
+            descriptorSelector: (KtScope, Name) -> D?
     ): D? {
         fun compute(): D? {
             val imports = indexedImports.importsForName(name)
@@ -139,7 +139,7 @@ class LazyImportResolver(
 
     public fun <D : DeclarationDescriptor> collectFromImports(
             name: Name,
-            descriptorsSelector: (JetScope, Name) -> Collection<D>
+            descriptorsSelector: (KtScope, Name) -> Collection<D>
     ): Collection<D> {
         return storageManager.compute {
             var descriptors: Collection<D>? = null
@@ -152,8 +152,8 @@ class LazyImportResolver(
         }
     }
 
-    public fun getImportScope(directive: JetImportDirective): JetScope {
-        return importedScopesProvider(directive) ?: JetScope.Empty
+    public fun getImportScope(directive: KtImportDirective): KtScope {
+        return importedScopesProvider(directive) ?: KtScope.Empty
     }
 }
 
@@ -162,7 +162,7 @@ class LazyImportScope(
         private val importResolver: LazyImportResolver,
         private val filteringKind: LazyImportScope.FilteringKind,
         private val debugName: String
-) : JetScope {
+) : KtScope {
 
     enum class FilteringKind {
         ALL,
@@ -202,17 +202,17 @@ class LazyImportScope(
         return importResolver.collectFromImports(name) { scope, name -> scope.getFunctions(name, location) }
     }
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor> {
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor> {
         if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return listOf()
         return importResolver.collectFromImports(name) { scope, name -> scope.getSyntheticExtensionProperties(receiverTypes, name, location) }
     }
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
         if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return listOf()
         return importResolver.collectFromImports(name) { scope, name -> scope.getSyntheticExtensionFunctions(receiverTypes, name, location) }
     }
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor> {
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>): Collection<PropertyDescriptor> {
         // we do not perform any filtering by visibility here because all descriptors from both visible/invisible filter scopes are to be added anyway
         if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return listOf()
 
@@ -223,7 +223,7 @@ class LazyImportScope(
         }
     }
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>): Collection<FunctionDescriptor> {
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>): Collection<FunctionDescriptor> {
         // we do not perform any filtering by visibility here because all descriptors from both visible/invisible filter scopes are to be added anyway
         if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return listOf()
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LocalDescriptorResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LocalDescriptorResolver.kt
index afc15bad769..8a6788d4ebc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LocalDescriptorResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LocalDescriptorResolver.kt
@@ -17,19 +17,19 @@
 package org.jetbrains.kotlin.resolve.lazy
 
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetPsiUtil
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtPsiUtil
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingContextUtils
 
 public interface LocalDescriptorResolver {
-    fun resolveLocalDeclaration(declaration: JetDeclaration): DeclarationDescriptor
+    fun resolveLocalDeclaration(declaration: KtDeclaration): DeclarationDescriptor
 }
 
 public class CompilerLocalDescriptorResolver(
         private val lazyDeclarationResolver: LazyDeclarationResolver
 ) : LocalDescriptorResolver {
-    override fun resolveLocalDeclaration(declaration: JetDeclaration): DeclarationDescriptor {
+    override fun resolveLocalDeclaration(declaration: KtDeclaration): DeclarationDescriptor {
         return lazyDeclarationResolver.resolveToDescriptor(declaration)
     }
 }
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/NoDescriptorForDeclarationException.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/NoDescriptorForDeclarationException.kt
index 38400591983..fa5993c92b6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/NoDescriptorForDeclarationException.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/NoDescriptorForDeclarationException.kt
@@ -16,8 +16,8 @@
 
 package org.jetbrains.kotlin.resolve.lazy
 
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 
-class NoDescriptorForDeclarationException(declaration: JetDeclaration) :
+class NoDescriptorForDeclarationException(declaration: KtDeclaration) :
         IllegalStateException("Descriptor wasn't found for declaration $declaration\n${declaration.getElementTextWithContext()}")
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java
index ddf276ac893..e75359fd72a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java
@@ -42,7 +42,7 @@ import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotations;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotationsContextImpl;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyScriptDescriptor;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.storage.*;
 
 import javax.inject.Inject;
@@ -62,12 +62,12 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
     private final MemoizedFunctionToNullable<FqName, LazyPackageDescriptor> packages;
     private final PackageFragmentProvider packageFragmentProvider;
 
-    private final MemoizedFunctionToNotNull<JetScript, LazyScriptDescriptor> scriptDescriptors;
+    private final MemoizedFunctionToNotNull<KtScript, LazyScriptDescriptor> scriptDescriptors;
 
-    private final MemoizedFunctionToNotNull<JetFile, LazyAnnotations> fileAnnotations;
-    private final MemoizedFunctionToNotNull<JetFile, LazyAnnotations> danglingAnnotations;
+    private final MemoizedFunctionToNotNull<KtFile, LazyAnnotations> fileAnnotations;
+    private final MemoizedFunctionToNotNull<KtFile, LazyAnnotations> danglingAnnotations;
 
-    private JetImportsFactory jetImportFactory;
+    private KtImportsFactory jetImportFactory;
     private AnnotationResolver annotationResolve;
     private DescriptorResolver descriptorResolver;
     private FunctionDescriptorResolver functionDescriptorResolver;
@@ -80,7 +80,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
     private LocalDescriptorResolver localDescriptorResolver;
 
     @Inject
-    public void setJetImportFactory(JetImportsFactory jetImportFactory) {
+    public void setJetImportFactory(KtImportsFactory jetImportFactory) {
         this.jetImportFactory = jetImportFactory;
     }
 
@@ -178,9 +178,9 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
         };
 
         this.scriptDescriptors = storageManager.createMemoizedFunction(
-                new Function1<JetScript, LazyScriptDescriptor>() {
+                new Function1<KtScript, LazyScriptDescriptor>() {
                     @Override
-                    public LazyScriptDescriptor invoke(JetScript script) {
+                    public LazyScriptDescriptor invoke(KtScript script) {
                         return new LazyScriptDescriptor(
                                 ResolveSession.this,
                                 scriptBodyResolver,
@@ -191,22 +191,22 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
                 }
         );
 
-        fileAnnotations = storageManager.createMemoizedFunction(new Function1<JetFile, LazyAnnotations>() {
+        fileAnnotations = storageManager.createMemoizedFunction(new Function1<KtFile, LazyAnnotations>() {
             @Override
-            public LazyAnnotations invoke(JetFile file) {
+            public LazyAnnotations invoke(KtFile file) {
                 return createAnnotations(file, file.getAnnotationEntries());
             }
         });
 
-        danglingAnnotations = storageManager.createMemoizedFunction(new Function1<JetFile, LazyAnnotations>() {
+        danglingAnnotations = storageManager.createMemoizedFunction(new Function1<KtFile, LazyAnnotations>() {
             @Override
-            public LazyAnnotations invoke(JetFile file) {
+            public LazyAnnotations invoke(KtFile file) {
                 return createAnnotations(file, file.getDanglingAnnotations());
             }
         });
     }
 
-    private LazyAnnotations createAnnotations(JetFile file, List<JetAnnotationEntry> annotationEntries) {
+    private LazyAnnotations createAnnotations(KtFile file, List<KtAnnotationEntry> annotationEntries) {
         LazyFileScope scope = fileScopeProvider.getFileScope(file);
         LazyAnnotationsContextImpl lazyAnnotationContext =
                 new LazyAnnotationsContextImpl(annotationResolve, storageManager, trace, scope);
@@ -268,7 +268,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
                         if (classLikeInfo instanceof JetScriptInfo) {
                             return getClassDescriptorForScript(((JetScriptInfo) classLikeInfo).getScript());
                         }
-                        JetClassOrObject classOrObject = classLikeInfo.getCorrespondingClassOrObject();
+                        KtClassOrObject classOrObject = classLikeInfo.getCorrespondingClassOrObject();
                         if (classOrObject == null) return null;
                         return getClassDescriptor(classOrObject, location);
                     }
@@ -278,13 +278,13 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
 
     @Override
     @NotNull
-    public ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject, @NotNull LookupLocation location) {
+    public ClassDescriptor getClassDescriptor(@NotNull KtClassOrObject classOrObject, @NotNull LookupLocation location) {
         return lazyDeclarationResolver.getClassDescriptor(classOrObject, location);
     }
 
     @NotNull
-    public ClassDescriptor getClassDescriptorForScript(@NotNull JetScript script) {
-        JetScope memberScope = lazyDeclarationResolver.getMemberScopeDeclaredIn(script, NoLookupLocation.FOR_SCRIPT);
+    public ClassDescriptor getClassDescriptorForScript(@NotNull KtScript script) {
+        KtScope memberScope = lazyDeclarationResolver.getMemberScopeDeclaredIn(script, NoLookupLocation.FOR_SCRIPT);
         FqName fqName = ScriptNameUtil.classNameForScript(script);
         ClassifierDescriptor classifier = memberScope.getClassifier(fqName.shortName(), NoLookupLocation.FOR_SCRIPT);
         assert classifier != null : "No descriptor for " + fqName + " in file " + script.getContainingFile();
@@ -293,7 +293,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
 
     @Override
     @NotNull
-    public ScriptDescriptor getScriptDescriptor(@NotNull JetScript script) {
+    public ScriptDescriptor getScriptDescriptor(@NotNull KtScript script) {
         return scriptDescriptors.invoke(script);
     }
 
@@ -317,20 +317,20 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
 
     @Override
     @NotNull
-    public DeclarationDescriptor resolveToDescriptor(@NotNull JetDeclaration declaration) {
-        if (!JetPsiUtil.isLocal(declaration)) {
+    public DeclarationDescriptor resolveToDescriptor(@NotNull KtDeclaration declaration) {
+        if (!KtPsiUtil.isLocal(declaration)) {
             return lazyDeclarationResolver.resolveToDescriptor(declaration);
         }
         return localDescriptorResolver.resolveLocalDeclaration(declaration);
     }
 
     @NotNull
-    public Annotations getFileAnnotations(@NotNull JetFile file) {
+    public Annotations getFileAnnotations(@NotNull KtFile file) {
         return fileAnnotations.invoke(file);
     }
 
     @NotNull
-    public Annotations getDanglingAnnotations(@NotNull JetFile file) {
+    public Annotations getDanglingAnnotations(@NotNull KtFile file) {
         return danglingAnnotations.invoke(file);
     }
 
@@ -348,7 +348,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
             @NotNull LazyPackageDescriptor current
     ) {
         result.add(current);
-        for (FqName subPackage : packageFragmentProvider.getSubPackagesOf(current.getFqName(), JetScope.Companion.getALL_NAME_FILTER())) {
+        for (FqName subPackage : packageFragmentProvider.getSubPackagesOf(current.getFqName(), KtScope.Companion.getALL_NAME_FILTER())) {
             LazyPackageDescriptor fragment = getPackageFragment(subPackage);
             assert fragment != null : "Couldn't find fragment for " + subPackage;
             collectAllPackages(result, fragment);
@@ -364,7 +364,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
     }
 
     @NotNull
-    public JetImportsFactory getJetImportsFactory() {
+    public KtImportsFactory getJetImportsFactory() {
         return jetImportFactory;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSessionUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSessionUtils.java
index cd622d8ad72..010191450b3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSessionUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSessionUtils.java
@@ -26,9 +26,9 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.name.*;
-import org.jetbrains.kotlin.psi.JetNamedDeclaration;
-import org.jetbrains.kotlin.psi.JetNamedDeclarationUtil;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.psi.KtNamedDeclaration;
+import org.jetbrains.kotlin.psi.KtNamedDeclarationUtil;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -76,10 +76,10 @@ public class ResolveSessionUtils {
     }
 
     @Nullable
-    public static ClassDescriptor findByQualifiedName(@NotNull JetScope outerScope, @NotNull FqName path) {
+    public static ClassDescriptor findByQualifiedName(@NotNull KtScope outerScope, @NotNull FqName path) {
         if (path.isRoot()) return null;
 
-        JetScope scope = outerScope;
+        KtScope scope = outerScope;
         for (Name name : path.pathSegments()) {
             ClassifierDescriptor classifier = scope.getClassifier(name, NoLookupLocation.UNSORTED);
             if (!(classifier instanceof ClassDescriptor)) return null;
@@ -90,7 +90,7 @@ public class ResolveSessionUtils {
     }
 
     @NotNull
-    public static Name safeNameForLazyResolve(@NotNull JetNamedDeclaration declaration) {
+    public static Name safeNameForLazyResolve(@NotNull KtNamedDeclaration declaration) {
         return safeNameForLazyResolve(declaration.getNameAsName());
     }
 
@@ -100,9 +100,9 @@ public class ResolveSessionUtils {
     }
 
     @Nullable
-    public static FqName safeFqNameForLazyResolve(@NotNull JetNamedDeclaration declaration) {
+    public static FqName safeFqNameForLazyResolve(@NotNull KtNamedDeclaration declaration) {
         //NOTE: should only create special names for package level declarations, so we can safely rely on real fq name for parent
-        FqName parentFqName = JetNamedDeclarationUtil.getParentFqName(declaration);
+        FqName parentFqName = KtNamedDeclarationUtil.getParentFqName(declaration);
         return parentFqName != null ? parentFqName.child(safeNameForLazyResolve(declaration)) : null;
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/TopLevelDescriptorProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/TopLevelDescriptorProvider.kt
index 15f04d20678..19bae1e1977 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/TopLevelDescriptorProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/TopLevelDescriptorProvider.kt
@@ -20,13 +20,13 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetScript
+import org.jetbrains.kotlin.psi.KtScript
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor
 
 public interface TopLevelDescriptorProvider {
     fun getPackageFragment(fqName: FqName): LazyPackageDescriptor?
 
-    fun getScriptDescriptor(script: JetScript): ScriptDescriptor
+    fun getScriptDescriptor(script: KtScript): ScriptDescriptor
 
     fun getTopLevelClassDescriptors(fqName: FqName, location: LookupLocation): Collection<ClassDescriptor>
 }
@@ -38,7 +38,7 @@ public object NoTopLevelDescriptorProvider : TopLevelDescriptorProvider {
         shouldNotBeCalled()
     }
 
-    override fun getScriptDescriptor(script: JetScript): ScriptDescriptor {
+    override fun getScriptDescriptor(script: KtScript): ScriptDescriptor {
         shouldNotBeCalled()
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfo.java
index 09a408c8bf0..1c942645610 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfo.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfo.java
@@ -19,16 +19,16 @@ package org.jetbrains.kotlin.resolve.lazy.data;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.ClassKind;
-import org.jetbrains.kotlin.psi.JetClass;
-import org.jetbrains.kotlin.psi.JetEnumEntry;
-import org.jetbrains.kotlin.psi.JetTypeParameterList;
+import org.jetbrains.kotlin.psi.KtClass;
+import org.jetbrains.kotlin.psi.KtEnumEntry;
+import org.jetbrains.kotlin.psi.KtTypeParameterList;
 
-public class JetClassInfo extends JetClassOrObjectInfo<JetClass> {
+public class JetClassInfo extends JetClassOrObjectInfo<KtClass> {
     private final ClassKind kind;
 
-    protected JetClassInfo(@NotNull JetClass classOrObject) {
+    protected JetClassInfo(@NotNull KtClass classOrObject) {
         super(classOrObject);
-        if (element instanceof JetEnumEntry) {
+        if (element instanceof KtEnumEntry) {
             this.kind = ClassKind.ENUM_ENTRY;
         }
         else if (element.isInterface()) {
@@ -44,7 +44,7 @@ public class JetClassInfo extends JetClassOrObjectInfo<JetClass> {
 
     @Nullable
     @Override
-    public JetTypeParameterList getTypeParameterList() {
+    public KtTypeParameterList getTypeParameterList() {
         return element.getTypeParameterList();
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfoUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfoUtil.java
index b0709b10ca2..f2b205a0d93 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfoUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfoUtil.java
@@ -17,19 +17,19 @@
 package org.jetbrains.kotlin.resolve.lazy.data;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetClass;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetObjectDeclaration;
+import org.jetbrains.kotlin.psi.KtClass;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtObjectDeclaration;
 
 public class JetClassInfoUtil {
 
     @NotNull
-    public static JetClassLikeInfo createClassLikeInfo(@NotNull JetClassOrObject classOrObject) {
-        if (classOrObject instanceof JetClass) {
-            return new JetClassInfo((JetClass) classOrObject);
+    public static JetClassLikeInfo createClassLikeInfo(@NotNull KtClassOrObject classOrObject) {
+        if (classOrObject instanceof KtClass) {
+            return new JetClassInfo((KtClass) classOrObject);
         }
-        if (classOrObject instanceof JetObjectDeclaration) {
-            return new JetObjectInfo((JetObjectDeclaration) classOrObject);
+        if (classOrObject instanceof KtObjectDeclaration) {
+            return new JetObjectInfo((KtObjectDeclaration) classOrObject);
         }
         throw new IllegalArgumentException("Unknown declaration type: " + classOrObject + classOrObject.getText());
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassLikeInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassLikeInfo.java
index 06cc731d08a..ddc4d3caaa5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassLikeInfo.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassLikeInfo.java
@@ -26,34 +26,34 @@ import org.jetbrains.kotlin.psi.*;
 
 import java.util.List;
 
-public interface JetClassLikeInfo extends JetDeclarationContainer {
+public interface JetClassLikeInfo extends KtDeclarationContainer {
     @NotNull
     FqName getContainingPackageFqName();
 
     @Nullable
-    JetModifierList getModifierList();
+    KtModifierList getModifierList();
 
     @NotNull
     @ReadOnly
-    List<JetObjectDeclaration> getCompanionObjects();
+    List<KtObjectDeclaration> getCompanionObjects();
 
     // This element is used to identify resolution scope for the class
     @NotNull
     PsiElement getScopeAnchor();
 
     @Nullable
-    JetClassOrObject getCorrespondingClassOrObject();
+    KtClassOrObject getCorrespondingClassOrObject();
 
     @Nullable
-    JetTypeParameterList getTypeParameterList();
+    KtTypeParameterList getTypeParameterList();
 
     @NotNull
     @ReadOnly
-    List<? extends JetParameter> getPrimaryConstructorParameters();
+    List<? extends KtParameter> getPrimaryConstructorParameters();
 
     @NotNull
     ClassKind getClassKind();
 
     @NotNull
-    List<JetAnnotationEntry> getDanglingAnnotations();
+    List<KtAnnotationEntry> getDanglingAnnotations();
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassOrObjectInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassOrObjectInfo.java
index cc99c973651..c19ab632485 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassOrObjectInfo.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassOrObjectInfo.java
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.psi.*;
 import java.util.Collections;
 import java.util.List;
 
-public abstract class JetClassOrObjectInfo<E extends JetClassOrObject> implements JetClassLikeInfo {
+public abstract class JetClassOrObjectInfo<E extends KtClassOrObject> implements JetClassLikeInfo {
     protected final E element;
 
     protected JetClassOrObjectInfo(@NotNull E element) {
@@ -40,26 +40,26 @@ public abstract class JetClassOrObjectInfo<E extends JetClassOrObject> implement
     }
 
     @Override
-    public JetClassOrObject getCorrespondingClassOrObject() {
+    public KtClassOrObject getCorrespondingClassOrObject() {
         return element;
     }
 
     @Override
     @Nullable
-    public JetModifierList getModifierList() {
+    public KtModifierList getModifierList() {
         return element.getModifierList();
     }
 
     @Override
     @NotNull
-    public List<JetDeclaration> getDeclarations() {
+    public List<KtDeclaration> getDeclarations() {
         return element.getDeclarations();
     }
 
     @NotNull
     @Override
-    public List<JetObjectDeclaration> getCompanionObjects() {
-        JetClassBody body = element.getBody();
+    public List<KtObjectDeclaration> getCompanionObjects() {
+        KtClassBody body = element.getBody();
         if (body == null) {
             return Collections.emptyList();
         }
@@ -76,8 +76,8 @@ public abstract class JetClassOrObjectInfo<E extends JetClassOrObject> implement
     @Override
     public FqName getContainingPackageFqName() {
         PsiFile file = element.getContainingFile();
-        if (file instanceof JetFile) {
-            JetFile jetFile = (JetFile) file;
+        if (file instanceof KtFile) {
+            KtFile jetFile = (KtFile) file;
             return jetFile.getPackageFqName();
         }
         throw new IllegalArgumentException("Not in a JetFile: " + element);
@@ -85,14 +85,14 @@ public abstract class JetClassOrObjectInfo<E extends JetClassOrObject> implement
 
     @NotNull
     @Override
-    public List<JetAnnotationEntry> getDanglingAnnotations() {
-        JetClassBody body = element.getBody();
-        return body == null ? Collections.<JetAnnotationEntry>emptyList() : body.getDanglingAnnotations();
+    public List<KtAnnotationEntry> getDanglingAnnotations() {
+        KtClassBody body = element.getBody();
+        return body == null ? Collections.<KtAnnotationEntry>emptyList() : body.getDanglingAnnotations();
     }
 
     @NotNull
     @Override
-    public List<? extends JetParameter> getPrimaryConstructorParameters() {
+    public List<? extends KtParameter> getPrimaryConstructorParameters() {
         return element.getPrimaryConstructorParameters();
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetObjectInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetObjectInfo.java
index 270c5c7b058..de04ede0efa 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetObjectInfo.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetObjectInfo.java
@@ -19,22 +19,22 @@ package org.jetbrains.kotlin.resolve.lazy.data;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.ClassKind;
-import org.jetbrains.kotlin.psi.JetObjectDeclaration;
-import org.jetbrains.kotlin.psi.JetTypeParameterList;
+import org.jetbrains.kotlin.psi.KtObjectDeclaration;
+import org.jetbrains.kotlin.psi.KtTypeParameterList;
 import org.jetbrains.kotlin.resolve.ModifiersChecker;
 
-public class JetObjectInfo extends JetClassOrObjectInfo<JetObjectDeclaration> {
+public class JetObjectInfo extends JetClassOrObjectInfo<KtObjectDeclaration> {
     @NotNull
     private final ClassKind kind;
 
-    protected JetObjectInfo(@NotNull JetObjectDeclaration element) {
+    protected JetObjectInfo(@NotNull KtObjectDeclaration element) {
         super(element);
         this.kind = element.isObjectLiteral() ? ClassKind.CLASS : ClassKind.OBJECT;
     }
 
     @Nullable
     @Override
-    public JetTypeParameterList getTypeParameterList() {
+    public KtTypeParameterList getTypeParameterList() {
         return null;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetScriptInfo.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetScriptInfo.kt
index 1fcf4b47370..feb509df431 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetScriptInfo.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetScriptInfo.kt
@@ -22,26 +22,26 @@ import org.jetbrains.kotlin.resolve.ScriptNameUtil
 import org.jetbrains.kotlin.name.FqName
 
 public class JetScriptInfo(
-        val script: JetScript
+        val script: KtScript
 ) : JetClassLikeInfo {
     public val fqName: FqName = ScriptNameUtil.classNameForScript(script)
     override fun getContainingPackageFqName() = fqName.parent()
     override fun getModifierList() = null
-    override fun getCompanionObjects() = listOf<JetObjectDeclaration>()
+    override fun getCompanionObjects() = listOf<KtObjectDeclaration>()
     override fun getScopeAnchor() = script
     override fun getCorrespondingClassOrObject() = null
     override fun getTypeParameterList() = null
-    override fun getPrimaryConstructorParameters() = listOf<JetParameter>()
+    override fun getPrimaryConstructorParameters() = listOf<KtParameter>()
     override fun getClassKind() = ClassKind.CLASS
     override fun getDeclarations() = script.getDeclarations()
             .filter(::shouldBeScriptClassMember)
-    override fun getDanglingAnnotations() = listOf<JetAnnotationEntry>()
+    override fun getDanglingAnnotations() = listOf<KtAnnotationEntry>()
 }
 
-public fun shouldBeScriptClassMember(declaration: JetDeclaration): Boolean {
+public fun shouldBeScriptClassMember(declaration: KtDeclaration): Boolean {
     // To avoid the necessity to always analyze the whole body of a script even if just its class descriptor is needed
     // we only add those vals, vars and funs that have explicitly specified return types
     // (or implicit Unit for function with block body)
-    return declaration is JetCallableDeclaration && declaration.getTypeReference() != null
-           || declaration is JetNamedFunction && declaration.hasBlockBody()
+    return declaration is KtCallableDeclaration && declaration.getTypeReference() != null
+           || declaration is KtNamedFunction && declaration.hasBlockBody()
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/AbstractPsiBasedDeclarationProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/AbstractPsiBasedDeclarationProvider.kt
index 79e074efb83..aba2b8ca67e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/AbstractPsiBasedDeclarationProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/AbstractPsiBasedDeclarationProvider.kt
@@ -32,29 +32,29 @@ public abstract class AbstractPsiBasedDeclarationProvider(storageManager: Storag
 
     protected class Index {
         // This mutable state is only modified under inside the computable
-        val allDeclarations = ArrayList<JetDeclaration>()
-        val functions = ArrayListMultimap.create<Name, JetNamedFunction>()
-        val properties = ArrayListMultimap.create<Name, JetProperty>()
+        val allDeclarations = ArrayList<KtDeclaration>()
+        val functions = ArrayListMultimap.create<Name, KtNamedFunction>()
+        val properties = ArrayListMultimap.create<Name, KtProperty>()
         val classesAndObjects = ArrayListMultimap.create<Name, JetClassLikeInfo>() // order matters here
 
-        public fun putToIndex(declaration: JetDeclaration) {
-            if (declaration is JetClassInitializer || declaration is JetSecondaryConstructor) return
+        public fun putToIndex(declaration: KtDeclaration) {
+            if (declaration is KtClassInitializer || declaration is KtSecondaryConstructor) return
 
             allDeclarations.add(declaration)
-            if (declaration is JetNamedFunction) {
+            if (declaration is KtNamedFunction) {
                 functions.put(safeNameForLazyResolve(declaration), declaration)
             }
-            else if (declaration is JetProperty) {
+            else if (declaration is KtProperty) {
                 properties.put(safeNameForLazyResolve(declaration), declaration)
             }
-            else if (declaration is JetClassOrObject) {
+            else if (declaration is KtClassOrObject) {
                 classesAndObjects.put(safeNameForLazyResolve(declaration.getNameAsName()), JetClassInfoUtil.createClassLikeInfo(declaration))
             }
-            else if (declaration is JetScript) {
+            else if (declaration is KtScript) {
                 val scriptInfo = JetScriptInfo(declaration)
                 classesAndObjects.put(scriptInfo.fqName.shortName(), scriptInfo)
             }
-            else if (declaration is JetParameter || declaration is JetTypedef || declaration is JetMultiDeclaration) {
+            else if (declaration is KtParameter || declaration is KtTypedef || declaration is KtMultiDeclaration) {
                 // Do nothing, just put it into allDeclarations is enough
             }
             else {
@@ -71,13 +71,13 @@ public abstract class AbstractPsiBasedDeclarationProvider(storageManager: Storag
 
     protected abstract fun doCreateIndex(index: Index)
 
-    override fun getDeclarations(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): List<JetDeclaration>
+    override fun getDeclarations(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): List<KtDeclaration>
             = index().allDeclarations
 
-    override fun getFunctionDeclarations(name: Name): List<JetNamedFunction>
+    override fun getFunctionDeclarations(name: Name): List<KtNamedFunction>
             = index().functions[ResolveSessionUtils.safeNameForLazyResolve(name)].toList()
 
-    override fun getPropertyDeclarations(name: Name): List<JetProperty>
+    override fun getPropertyDeclarations(name: Name): List<KtProperty>
             = index().properties[ResolveSessionUtils.safeNameForLazyResolve(name)].toList()
 
     override fun getClassOrObjectDeclarations(name: Name): Collection<JetClassLikeInfo>
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/CliDeclarationProviderFactoryService.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/CliDeclarationProviderFactoryService.kt
index 613212c1dcd..639c4f8449f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/CliDeclarationProviderFactoryService.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/CliDeclarationProviderFactoryService.kt
@@ -18,20 +18,20 @@ package org.jetbrains.kotlin.resolve.lazy.declarations
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.utils.sure
 import java.util.ArrayList
 
-public class CliDeclarationProviderFactoryService(private val sourceFiles: Collection<JetFile>) : DeclarationProviderFactoryService() {
+public class CliDeclarationProviderFactoryService(private val sourceFiles: Collection<KtFile>) : DeclarationProviderFactoryService() {
 
     override fun create(
             project: Project,
             storageManager: StorageManager,
-            syntheticFiles: Collection<JetFile>,
+            syntheticFiles: Collection<KtFile>,
             filesScope: GlobalSearchScope
     ): DeclarationProviderFactory {
-        val allFiles = ArrayList<JetFile>()
+        val allFiles = ArrayList<KtFile>()
         sourceFiles.filterTo(allFiles) {
             val vFile = it.getVirtualFile().sure { "Source files should be physical files" }
             filesScope.contains(vFile)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/DeclarationProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/DeclarationProvider.kt
index 034f6854b20..7cf02985f4f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/DeclarationProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/DeclarationProvider.kt
@@ -16,19 +16,19 @@
 
 package org.jetbrains.kotlin.resolve.lazy.declarations
 
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 
 public interface DeclarationProvider {
-    public fun getDeclarations(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): List<JetDeclaration>
+    public fun getDeclarations(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): List<KtDeclaration>
 
-    public fun getFunctionDeclarations(name: Name): Collection<JetNamedFunction>
+    public fun getFunctionDeclarations(name: Name): Collection<KtNamedFunction>
 
-    public fun getPropertyDeclarations(name: Name): Collection<JetProperty>
+    public fun getPropertyDeclarations(name: Name): Collection<KtProperty>
 
     public fun getClassOrObjectDeclarations(name: Name): Collection<JetClassLikeInfo>
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/DeclarationProviderFactoryService.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/DeclarationProviderFactoryService.kt
index 96434756491..a1ccf7a4ac4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/DeclarationProviderFactoryService.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/DeclarationProviderFactoryService.kt
@@ -20,7 +20,7 @@ import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.DelegatingGlobalSearchScope
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.storage.StorageManager
 import com.intellij.openapi.vfs.VirtualFile
 import java.util.HashSet
@@ -30,7 +30,7 @@ public abstract class DeclarationProviderFactoryService {
     public abstract fun create(
             project: Project,
             storageManager: StorageManager,
-            syntheticFiles: Collection<JetFile>,
+            syntheticFiles: Collection<KtFile>,
             filesScope: GlobalSearchScope
     ): DeclarationProviderFactory
 
@@ -39,14 +39,14 @@ public abstract class DeclarationProviderFactoryService {
         public fun createDeclarationProviderFactory(
                 project: Project,
                 storageManager: StorageManager,
-                syntheticFiles: Collection<JetFile>,
+                syntheticFiles: Collection<KtFile>,
                 filesScope: GlobalSearchScope
         ): DeclarationProviderFactory {
             return ServiceManager.getService(project, javaClass<DeclarationProviderFactoryService>())!!
                     .create(project, storageManager, syntheticFiles, filteringScope(syntheticFiles, filesScope))
         }
 
-        private fun filteringScope(syntheticFiles: Collection<JetFile>, baseScope: GlobalSearchScope): GlobalSearchScope {
+        private fun filteringScope(syntheticFiles: Collection<KtFile>, baseScope: GlobalSearchScope): GlobalSearchScope {
             if (syntheticFiles.isEmpty()) {
                 return baseScope
             }
@@ -55,7 +55,7 @@ public abstract class DeclarationProviderFactoryService {
     }
 
 
-    private class SyntheticFilesFilteringScope(syntheticFiles: Collection<JetFile>, baseScope: GlobalSearchScope)
+    private class SyntheticFilesFilteringScope(syntheticFiles: Collection<KtFile>, baseScope: GlobalSearchScope)
         : DelegatingGlobalSearchScope(baseScope) {
 
         private val originals = syntheticFiles
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java
index 77c9087bf2f..22c7da2e1ab 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java
@@ -25,7 +25,7 @@ import kotlin.jvm.functions.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo;
 import org.jetbrains.kotlin.storage.NotNullLazyValue;
 import org.jetbrains.kotlin.storage.StorageManager;
@@ -36,14 +36,14 @@ import java.util.Set;
 public class FileBasedDeclarationProviderFactory extends AbstractDeclarationProviderFactory  {
 
     private static class Index {
-        private final Multimap<FqName, JetFile> filesByPackage = HashMultimap.create();
+        private final Multimap<FqName, KtFile> filesByPackage = HashMultimap.create();
         private final Set<FqName> declaredPackages = Sets.newHashSet();
     }
 
     private final StorageManager storageManager;
     private final NotNullLazyValue<Index> index;
 
-    public FileBasedDeclarationProviderFactory(@NotNull StorageManager storageManager, @NotNull final Collection<JetFile> files) {
+    public FileBasedDeclarationProviderFactory(@NotNull StorageManager storageManager, @NotNull final Collection<KtFile> files) {
         super(storageManager);
         this.storageManager = storageManager;
         this.index = storageManager.createLazyValue(new Function0<Index>() {
@@ -55,9 +55,9 @@ public class FileBasedDeclarationProviderFactory extends AbstractDeclarationProv
     }
 
     @NotNull
-    private static Index computeFilesByPackage(@NotNull Collection<JetFile> files) {
+    private static Index computeFilesByPackage(@NotNull Collection<KtFile> files) {
         Index index = new Index();
-        for (JetFile file : files) {
+        for (KtFile file : files) {
             FqName packageFqName = file.getPackageFqName();
             addMeAndParentPackages(index, packageFqName);
             index.filesByPackage.put(packageFqName, file);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.kt
index 7c706d12849..eb8cbe7df4b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.kt
@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.resolve.lazy.declarations
 
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.storage.StorageManager
@@ -25,7 +25,7 @@ public class FileBasedPackageMemberDeclarationProvider(
         storageManager: StorageManager,
         private val fqName: FqName,
         private val factory: FileBasedDeclarationProviderFactory,
-        private val packageFiles: Collection<JetFile>)
+        private val packageFiles: Collection<KtFile>)
 : AbstractPsiBasedDeclarationProvider(storageManager), PackageMemberDeclarationProvider {
 
     private val allDeclaredSubPackages = storageManager.createLazyValue<Collection<FqName>> {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/PackageMemberDeclarationProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/PackageMemberDeclarationProvider.kt
index 627f346ea18..7f22d99b2ed 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/PackageMemberDeclarationProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/PackageMemberDeclarationProvider.kt
@@ -17,12 +17,12 @@
 package org.jetbrains.kotlin.resolve.lazy.declarations
 
 import org.jetbrains.annotations.ReadOnly
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
 public interface PackageMemberDeclarationProvider : DeclarationProvider {
     public fun getAllDeclaredSubPackages(nameFilter: (Name) -> Boolean): Collection<FqName>
 
-    public fun getPackageFiles(): Collection<JetFile>
+    public fun getPackageFiles(): Collection<KtFile>
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt
index 1343d8fbac7..5f31030e7f1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.data.JetScriptInfo
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProvider
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
+import org.jetbrains.kotlin.resolve.scopes.KtScopeImpl
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.storage.MemoizedFunctionToNotNull
 import org.jetbrains.kotlin.storage.StorageManager
@@ -46,7 +46,7 @@ protected constructor(
         protected val declarationProvider: DP,
         protected val thisDescriptor: D,
         protected val trace: BindingTrace
-) : JetScopeImpl() {
+) : KtScopeImpl() {
 
     protected val storageManager: StorageManager = c.storageManager
     private val classDescriptors: MemoizedFunctionToNotNull<Name, List<ClassDescriptor>> = storageManager.createMemoizedFunction { resolveClassDescriptor(it) }
@@ -94,7 +94,7 @@ protected constructor(
         return result.toReadOnlyList()
     }
 
-    protected abstract fun getScopeForMemberDeclarationResolution(declaration: JetDeclaration): LexicalScope
+    protected abstract fun getScopeForMemberDeclarationResolution(declaration: KtDeclaration): LexicalScope
 
     protected abstract fun getNonDeclaredFunctions(name: Name, result: MutableSet<FunctionDescriptor>)
 
@@ -133,37 +133,37 @@ protected constructor(
         val declarations = declarationProvider.getDeclarations(kindFilter, nameFilter)
         val result = LinkedHashSet<DeclarationDescriptor>(declarations.size())
         for (declaration in declarations) {
-            if (declaration is JetClassOrObject) {
+            if (declaration is KtClassOrObject) {
                 val name = declaration.nameAsSafeName
                 if (nameFilter(name)) {
                     result.addAll(classDescriptors(name))
                 }
             }
-            else if (declaration is JetFunction) {
+            else if (declaration is KtFunction) {
                 val name = declaration.nameAsSafeName
                 if (nameFilter(name)) {
                     result.addAll(getFunctions(name, location))
                 }
             }
-            else if (declaration is JetProperty) {
+            else if (declaration is KtProperty) {
                 val name = declaration.nameAsSafeName
                 if (nameFilter(name)) {
                     result.addAll(getProperties(name, location))
                 }
             }
-            else if (declaration is JetParameter) {
+            else if (declaration is KtParameter) {
                 val name = declaration.nameAsSafeName
                 if (nameFilter(name)) {
                     result.addAll(getProperties(name, location))
                 }
             }
-            else if (declaration is JetScript) {
+            else if (declaration is KtScript) {
                 val name = ScriptNameUtil.classNameForScript(declaration).shortName()
                 if (nameFilter(name)) {
                     result.addAll(classDescriptors(name))
                 }
             }
-            else if (declaration is JetTypedef || declaration is JetMultiDeclaration) {
+            else if (declaration is KtTypedef || declaration is KtMultiDeclaration) {
                 // Do nothing for typedefs as they are not supported.
                 // MultiDeclarations are not supported on global level too.
             }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt
index 75d809e0b3b..e6737d4ae2b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt
@@ -19,9 +19,9 @@ package org.jetbrains.kotlin.resolve.lazy.descriptors
 import com.intellij.util.SmartList
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.psi.JetParameter
+import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.LexicalChainedScope
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.resolve.scopes.LexicalScopeImpl
@@ -33,7 +33,7 @@ class ClassResolutionScopesSupport(
         private val classDescriptor: ClassDescriptor,
         storageManager: StorageManager,
         private val getOuterScope: () -> LexicalScope,
-        private val primaryConstructorParameters: List<JetParameter>? = null
+        private val primaryConstructorParameters: List<KtParameter>? = null
 ) {
     private fun scopeWithGenerics(parent: LexicalScope, debugName: String): LexicalScopeImpl {
         return LexicalScopeImpl(parent, classDescriptor, false, null, debugName) {
@@ -108,7 +108,7 @@ class ClassResolutionScopesSupport(
             ownerDescriptor: DeclarationDescriptor,
             classDescriptor: ClassDescriptor
     ): LexicalScope {
-        val staticScopes = ArrayList<JetScope>(3)
+        val staticScopes = ArrayList<KtScope>(3)
 
         // todo filter fake overrides
         staticScopes.add(classDescriptor.staticScope)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt
index b692c7ba434..c2165be19a6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt
@@ -21,10 +21,10 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetAnnotationEntry
-import org.jetbrains.kotlin.psi.JetAnnotationUseSiteTarget
+import org.jetbrains.kotlin.psi.KtAnnotationEntry
+import org.jetbrains.kotlin.psi.KtAnnotationUseSiteTarget
 import org.jetbrains.kotlin.resolve.AnnotationResolver
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
@@ -53,12 +53,12 @@ class LazyAnnotationsContextImpl(
 
 public class LazyAnnotations(
         val c: LazyAnnotationsContext,
-        val annotationEntries: List<JetAnnotationEntry>
+        val annotationEntries: List<KtAnnotationEntry>
 ) : Annotations, LazyEntity {
     override fun isEmpty() = annotationEntries.isEmpty()
 
     private val annotation = c.storageManager.createMemoizedFunction {
-        entry: JetAnnotationEntry ->
+        entry: KtAnnotationEntry ->
 
         val descriptor = LazyAnnotationDescriptor(c, entry)
         val target = entry.getUseSiteTarget()?.getAnnotationUseSiteTarget()
@@ -112,7 +112,7 @@ public class LazyAnnotations(
 
 public class LazyAnnotationDescriptor(
         val c: LazyAnnotationsContext,
-        val annotationEntry: JetAnnotationEntry
+        val annotationEntry: KtAnnotationEntry
 ) : AnnotationDescriptor, LazyEntity {
 
     init {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java
index 7c4489459d7..cda0ff41515 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorBase;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.*;
@@ -46,7 +46,7 @@ import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo;
 import org.jetbrains.kotlin.resolve.lazy.data.JetClassOrObjectInfo;
 import org.jetbrains.kotlin.resolve.lazy.data.JetObjectInfo;
 import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProvider;
-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.resolve.scopes.StaticScopeForKotlinClass;
 import org.jetbrains.kotlin.resolve.source.KotlinSourceElementKt;
@@ -55,7 +55,7 @@ import org.jetbrains.kotlin.storage.NotNullLazyValue;
 import org.jetbrains.kotlin.storage.NullableLazyValue;
 import org.jetbrains.kotlin.storage.StorageManager;
 import org.jetbrains.kotlin.types.AbstractClassTypeConstructor;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeConstructor;
 import org.jetbrains.kotlin.types.TypeUtils;
 
@@ -68,9 +68,9 @@ import static org.jetbrains.kotlin.resolve.BindingContext.TYPE;
 import static org.jetbrains.kotlin.resolve.ModifiersChecker.*;
 
 public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDescriptorWithResolutionScopes, LazyEntity {
-    private static final Predicate<JetType> VALID_SUPERTYPE = new Predicate<JetType>() {
+    private static final Predicate<KtType> VALID_SUPERTYPE = new Predicate<KtType>() {
         @Override
-        public boolean apply(JetType type) {
+        public boolean apply(KtType type) {
             assert !type.isError() : "Error types must be filtered out in DescriptorResolver";
             return TypeUtils.getClassDescriptor(type) != null;
         }
@@ -89,10 +89,10 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
     private final Annotations annotations;
     private final Annotations danglingAnnotations;
     private final NullableLazyValue<LazyClassDescriptor> companionObjectDescriptor;
-    private final MemoizedFunctionToNotNull<JetObjectDeclaration, ClassDescriptor> extraCompanionObjectDescriptors;
+    private final MemoizedFunctionToNotNull<KtObjectDeclaration, ClassDescriptor> extraCompanionObjectDescriptors;
 
     private final LazyClassMemberScope unsubstitutedMemberScope;
-    private final JetScope staticScope;
+    private final KtScope staticScope;
 
     private final NullableLazyValue<Void> forceResolveAllContents;
     private final boolean isCompanionObject;
@@ -110,7 +110,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
         );
         this.c = c;
 
-        JetClassOrObject classOrObject = classLikeInfo.getCorrespondingClassOrObject();
+        KtClassOrObject classOrObject = classLikeInfo.getCorrespondingClassOrObject();
         if (classOrObject != null) {
             this.c.getTrace().record(BindingContext.CLASS, classOrObject, this);
         }
@@ -126,7 +126,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
         final ClassKind syntaxKind = classLikeInfo.getClassKind();
         this.isCompanionObject = classLikeInfo instanceof JetObjectInfo && ((JetObjectInfo) classLikeInfo).isCompanionObject();
 
-        final JetModifierList modifierList = classLikeInfo.getModifierList();
+        final KtModifierList modifierList = classLikeInfo.getModifierList();
         if (syntaxKind.isSingleton()) {
             this.modality = Modality.FINAL;
         }
@@ -135,7 +135,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
             this.modality = resolveModalityFromModifiers(modifierList, defaultModality);
         }
 
-        boolean isLocal = classOrObject != null && JetPsiUtil.isLocal(classOrObject);
+        boolean isLocal = classOrObject != null && KtPsiUtil.isLocal(classOrObject);
         Visibility defaultVisibility;
         if (syntaxKind == ClassKind.ENUM_ENTRY || (syntaxKind == ClassKind.OBJECT && isCompanionObject)) {
             defaultVisibility = Visibilities.PUBLIC;
@@ -158,14 +158,14 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
         this.isData = storageManager.createLazyValue(new Function0<Boolean>() {
             @Override
             public Boolean invoke() {
-                return modifierList != null && modifierList.hasModifier(JetTokens.DATA_KEYWORD);
+                return modifierList != null && modifierList.hasModifier(KtTokens.DATA_KEYWORD);
             }
         });
 
         this.kind = storageManager.createLazyValue(new Function0<ClassKind>() {
             @Override
             public ClassKind invoke() {
-                return (syntaxKind == ClassKind.CLASS && modifierList != null && modifierList.hasModifier(JetTokens.ANNOTATION_KEYWORD)) ? ClassKind.ANNOTATION_CLASS : syntaxKind;
+                return (syntaxKind == ClassKind.CLASS && modifierList != null && modifierList.hasModifier(KtTokens.ANNOTATION_KEYWORD)) ? ClassKind.ANNOTATION_CLASS : syntaxKind;
             }
         });
 
@@ -189,7 +189,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
             this.annotations = Annotations.Companion.getEMPTY();
         }
 
-        List<JetAnnotationEntry> jetDanglingAnnotations = classLikeInfo.getDanglingAnnotations();
+        List<KtAnnotationEntry> jetDanglingAnnotations = classLikeInfo.getDanglingAnnotations();
         if (jetDanglingAnnotations.isEmpty()) {
             this.danglingAnnotations = Annotations.Companion.getEMPTY();
         }
@@ -216,9 +216,9 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
                 return computeCompanionObjectDescriptor(getCompanionObjectIfAllowed());
             }
         });
-        this.extraCompanionObjectDescriptors = storageManager.createMemoizedFunction(new Function1<JetObjectDeclaration, ClassDescriptor>() {
+        this.extraCompanionObjectDescriptors = storageManager.createMemoizedFunction(new Function1<KtObjectDeclaration, ClassDescriptor>() {
             @Override
-            public ClassDescriptor invoke(JetObjectDeclaration companionObject) {
+            public ClassDescriptor invoke(KtObjectDeclaration companionObject) {
                 return computeCompanionObjectDescriptor(companionObject);
             }
         });
@@ -249,7 +249,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
 
     @NotNull
     @Override
-    public JetScope getUnsubstitutedMemberScope() {
+    public KtScope getUnsubstitutedMemberScope() {
         return unsubstitutedMemberScope;
     }
 
@@ -300,7 +300,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
 
     @NotNull
     @Override
-    public JetScope getStaticScope() {
+    public KtScope getStaticScope() {
         return staticScope;
     }
 
@@ -329,21 +329,21 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
     @NotNull
     @ReadOnly
     public List<ClassDescriptor> getDescriptorsForExtraCompanionObjects() {
-        final JetObjectDeclaration allowedCompanionObject = getCompanionObjectIfAllowed();
+        final KtObjectDeclaration allowedCompanionObject = getCompanionObjectIfAllowed();
 
         return CollectionsKt.map(
                 CollectionsKt.filter(
                         declarationProvider.getOwnerInfo().getCompanionObjects(),
-                        new Function1<JetObjectDeclaration, Boolean>() {
+                        new Function1<KtObjectDeclaration, Boolean>() {
                             @Override
-                            public Boolean invoke(JetObjectDeclaration companionObject) {
+                            public Boolean invoke(KtObjectDeclaration companionObject) {
                                 return companionObject != allowedCompanionObject;
                             }
                         }
                 ),
-                new Function1<JetObjectDeclaration, ClassDescriptor>() {
+                new Function1<KtObjectDeclaration, ClassDescriptor>() {
                     @Override
-                    public ClassDescriptor invoke(JetObjectDeclaration companionObject) {
+                    public ClassDescriptor invoke(KtObjectDeclaration companionObject) {
                         return extraCompanionObjectDescriptors.invoke(companionObject);
                     }
                 }
@@ -351,7 +351,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
     }
 
     @Nullable
-    private LazyClassDescriptor computeCompanionObjectDescriptor(@Nullable JetObjectDeclaration companionObject) {
+    private LazyClassDescriptor computeCompanionObjectDescriptor(@Nullable KtObjectDeclaration companionObject) {
         JetClassLikeInfo companionObjectInfo = getCompanionObjectInfo(companionObject);
         if (!(companionObjectInfo instanceof JetClassOrObjectInfo)) {
             return null;
@@ -370,7 +370,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
     }
 
     @Nullable
-    private static JetClassLikeInfo getCompanionObjectInfo(@Nullable JetObjectDeclaration companionObject) {
+    private static JetClassLikeInfo getCompanionObjectInfo(@Nullable KtObjectDeclaration companionObject) {
         if (companionObject != null) {
             return JetClassInfoUtil.createClassLikeInfo(companionObject);
         }
@@ -379,8 +379,8 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
     }
 
     @Nullable
-    private JetObjectDeclaration getCompanionObjectIfAllowed() {
-        JetObjectDeclaration companionObject = firstOrNull(declarationProvider.getOwnerInfo().getCompanionObjects());
+    private KtObjectDeclaration getCompanionObjectIfAllowed() {
+        KtObjectDeclaration companionObject = firstOrNull(declarationProvider.getOwnerInfo().getCompanionObjects());
         return (companionObject != null && isCompanionObjectAllowed()) ? companionObject : null;
     }
 
@@ -488,21 +488,21 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
 
     private static class Supertypes {
         @Mutable
-        public final Collection<JetType> trueSupertypes;
+        public final Collection<KtType> trueSupertypes;
         @Mutable
-        public final Collection<JetType> cyclicSupertypes;
+        public final Collection<KtType> cyclicSupertypes;
 
-        private Supertypes(@Mutable @NotNull Collection<JetType> trueSupertypes) {
-            this(trueSupertypes, new ArrayList<JetType>(0));
+        private Supertypes(@Mutable @NotNull Collection<KtType> trueSupertypes) {
+            this(trueSupertypes, new ArrayList<KtType>(0));
         }
 
-        private Supertypes(@Mutable @NotNull Collection<JetType> trueSupertypes, @Mutable @NotNull Collection<JetType> cyclicSupertypes) {
+        private Supertypes(@Mutable @NotNull Collection<KtType> trueSupertypes, @Mutable @NotNull Collection<KtType> cyclicSupertypes) {
             this.trueSupertypes = trueSupertypes;
             this.cyclicSupertypes = cyclicSupertypes;
         }
 
         @NotNull
-        public Collection<JetType> getAllSupertypes() {
+        public Collection<KtType> getAllSupertypes() {
             return CollectionsKt.plus(trueSupertypes, cyclicSupertypes);
         }
     }
@@ -513,15 +513,15 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
                     @Override
                     public Supertypes invoke() {
                         if (KotlinBuiltIns.isSpecialClassWithNoSupertypes(LazyClassDescriptor.this)) {
-                            return new Supertypes(Collections.<JetType>emptyList());
+                            return new Supertypes(Collections.<KtType>emptyList());
                         }
 
-                        JetClassOrObject classOrObject = declarationProvider.getOwnerInfo().getCorrespondingClassOrObject();
+                        KtClassOrObject classOrObject = declarationProvider.getOwnerInfo().getCorrespondingClassOrObject();
                         if (classOrObject == null) {
                             return new Supertypes(Collections.singleton(c.getModuleDescriptor().getBuiltIns().getAnyType()));
                         }
 
-                        List<JetType> allSupertypes = c.getDescriptorResolver()
+                        List<KtType> allSupertypes = c.getDescriptorResolver()
                                 .resolveSupertypes(getScopeForClassHeaderResolution(), LazyClassDescriptor.this, classOrObject,
                                                    c.getTrace());
 
@@ -531,7 +531,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
                 new Function1<Boolean, Supertypes>() {
                     @Override
                     public Supertypes invoke(Boolean firstTime) {
-                        return new Supertypes(Collections.<JetType>emptyList());
+                        return new Supertypes(Collections.<KtType>emptyList());
                     }
                 },
                 new Function1<Supertypes, Unit>() {
@@ -547,14 +547,14 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
             @Override
             public List<TypeParameterDescriptor> invoke() {
                 JetClassLikeInfo classInfo = declarationProvider.getOwnerInfo();
-                JetTypeParameterList typeParameterList = classInfo.getTypeParameterList();
+                KtTypeParameterList typeParameterList = classInfo.getTypeParameterList();
                 if (typeParameterList == null) return Collections.emptyList();
 
                 if (classInfo.getClassKind() == ClassKind.ENUM_CLASS) {
                     c.getTrace().report(TYPE_PARAMETERS_IN_ENUM.on(typeParameterList));
                 }
 
-                List<JetTypeParameter> typeParameters = typeParameterList.getParameters();
+                List<KtTypeParameter> typeParameters = typeParameterList.getParameters();
                 List<TypeParameterDescriptor> parameters = new ArrayList<TypeParameterDescriptor>(typeParameters.size());
                 for (int i = 0; i < typeParameters.size(); i++) {
                     parameters.add(new LazyTypeParameterDescriptor(c, LazyClassDescriptor.this, typeParameters.get(i), i));
@@ -581,13 +581,13 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
 
         @NotNull
         @Override
-        public Collection<JetType> getSupertypes() {
+        public Collection<KtType> getSupertypes() {
             return supertypes.invoke().trueSupertypes;
         }
 
         private void findAndDisconnectLoopsInTypeHierarchy(Supertypes supertypes) {
-            for (Iterator<JetType> iterator = supertypes.trueSupertypes.iterator(); iterator.hasNext(); ) {
-                JetType supertype = iterator.next();
+            for (Iterator<KtType> iterator = supertypes.trueSupertypes.iterator(); iterator.hasNext(); ) {
+                KtType supertype = iterator.next();
                 if (isReachable(supertype.getConstructor(), this, new HashSet<TypeConstructor>())) {
                     iterator.remove();
                     supertypes.cyclicSupertypes.add(supertype);
@@ -609,12 +609,12 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
             PsiElement psiElement = DescriptorToSourceUtils.getSourceFromDescriptor(classDescriptor);
 
             PsiElement elementToMark = null;
-            if (psiElement instanceof JetClassOrObject) {
-                JetClassOrObject classOrObject = (JetClassOrObject) psiElement;
-                for (JetDelegationSpecifier delegationSpecifier : classOrObject.getDelegationSpecifiers()) {
-                    JetTypeReference typeReference = delegationSpecifier.getTypeReference();
+            if (psiElement instanceof KtClassOrObject) {
+                KtClassOrObject classOrObject = (KtClassOrObject) psiElement;
+                for (KtDelegationSpecifier delegationSpecifier : classOrObject.getDelegationSpecifiers()) {
+                    KtTypeReference typeReference = delegationSpecifier.getTypeReference();
                     if (typeReference == null) continue;
-                    JetType supertype = trace.get(TYPE, typeReference);
+                    KtType supertype = trace.get(TYPE, typeReference);
                     if (supertype != null && supertype.getConstructor() == superclass.getTypeConstructor()) {
                         elementToMark = typeReference;
                     }
@@ -634,7 +634,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
 
         private boolean isReachable(TypeConstructor from, TypeConstructor to, Set<TypeConstructor> visited) {
             if (!visited.add(from)) return false;
-            for (JetType supertype : getNeighbors(from)) {
+            for (KtType supertype : getNeighbors(from)) {
                 TypeConstructor supertypeConstructor = supertype.getConstructor();
                 if (supertypeConstructor == to) {
                     return true;
@@ -646,9 +646,9 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
             return false;
         }
 
-        private Collection<JetType> getNeighbors(TypeConstructor from) {
+        private Collection<KtType> getNeighbors(TypeConstructor from) {
             // Supertypes + type for container
-            Collection<JetType> neighbours = new ArrayList<JetType>(
+            Collection<KtType> neighbours = new ArrayList<KtType>(
                     from instanceof LazyClassTypeConstructor
                              ? ((LazyClassTypeConstructor) from).supertypes.invoke().getAllSupertypes()
                              : from.getSupertypes()
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt
index 12d5f0170be..61d8a5140da 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt
@@ -25,8 +25,8 @@ import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.DelegationResolver.generateDelegatedMembers
 import org.jetbrains.kotlin.resolve.dataClassUtils.createComponentName
@@ -34,13 +34,13 @@ import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike
 import org.jetbrains.kotlin.resolve.lazy.LazyClassContext
 import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProvider
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-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.resolve.varianceChecker.VarianceChecker
 import org.jetbrains.kotlin.storage.NotNullLazyValue
 import org.jetbrains.kotlin.storage.NullableLazyValue
 import org.jetbrains.kotlin.types.DeferredType
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.util.*
 
 public open class LazyClassMemberScope(
@@ -51,7 +51,7 @@ public open class LazyClassMemberScope(
 ) : AbstractLazyMemberScope<LazyClassDescriptor, ClassMemberDeclarationProvider>(c, declarationProvider, thisClass, trace) {
 
     private val descriptorsFromDeclaredElements = storageManager.createLazyValue {
-        computeDescriptorsFromDeclaredElements(DescriptorKindFilter.ALL, JetScope.ALL_NAME_FILTER, NoLookupLocation.WHEN_GET_ALL_DESCRIPTORS)
+        computeDescriptorsFromDeclaredElements(DescriptorKindFilter.ALL, KtScope.ALL_NAME_FILTER, NoLookupLocation.WHEN_GET_ALL_DESCRIPTORS)
     }
     private val extraDescriptors: NotNullLazyValue<Collection<DeclarationDescriptor>> = storageManager.createLazyValue {
         computeExtraDescriptors(NoLookupLocation.FOR_ALREADY_TRACKED)
@@ -85,14 +85,14 @@ public open class LazyClassMemberScope(
     }
 
     private interface MemberExtractor<T : CallableMemberDescriptor> {
-        public fun extract(extractFrom: JetType, name: Name): Collection<T>
+        public fun extract(extractFrom: KtType, name: Name): Collection<T>
     }
 
     private val primaryConstructor: NullableLazyValue<ConstructorDescriptor>
             = c.storageManager.createNullableLazyValue { resolvePrimaryConstructor() }
 
-    override fun getScopeForMemberDeclarationResolution(declaration: JetDeclaration): LexicalScope {
-        if (declaration is JetProperty) {
+    override fun getScopeForMemberDeclarationResolution(declaration: KtDeclaration): LexicalScope {
+        if (declaration is KtProperty) {
             return thisDescriptor.getScopeForInitializerResolution()
         }
         return thisDescriptor.getScopeForMemberDeclarationResolution()
@@ -107,7 +107,7 @@ public open class LazyClassMemberScope(
             }
 
             override fun conflict(fromSuper: CallableMemberDescriptor, fromCurrent: CallableMemberDescriptor) {
-                val declaration = DescriptorToSourceUtils.descriptorToDeclaration(fromCurrent) as JetDeclaration?
+                val declaration = DescriptorToSourceUtils.descriptorToDeclaration(fromCurrent) as KtDeclaration?
                 assert(declaration != null) { "fromCurrent can not be a fake override" }
                 trace.report(Errors.CONFLICTING_OVERLOADS.on(declaration, fromCurrent, fromCurrent.getContainingDeclaration().getName().asString()))
             }
@@ -315,13 +315,13 @@ public open class LazyClassMemberScope(
 
     companion object {
         private val EXTRACT_FUNCTIONS: MemberExtractor<FunctionDescriptor> = object : MemberExtractor<FunctionDescriptor> {
-            override fun extract(extractFrom: JetType, name: Name): Collection<FunctionDescriptor> {
+            override fun extract(extractFrom: KtType, name: Name): Collection<FunctionDescriptor> {
                 return extractFrom.memberScope.getFunctions(name, NoLookupLocation.FOR_ALREADY_TRACKED)
             }
         }
 
         private val EXTRACT_PROPERTIES: MemberExtractor<PropertyDescriptor> = object : MemberExtractor<PropertyDescriptor> {
-            override fun extract(extractFrom: JetType, name: Name): Collection<PropertyDescriptor> {
+            override fun extract(extractFrom: KtType, name: Name): Collection<PropertyDescriptor> {
                 @Suppress("UNCHECKED_CAST")
                 return extractFrom.memberScope.getProperties(name, NoLookupLocation.FOR_ALREADY_TRACKED) as Collection<PropertyDescriptor>
             }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageDescriptor.java
index 2b7de45d7b5..031e7b3e2fb 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageDescriptor.java
@@ -20,16 +20,16 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.PackageFragmentDescriptorImpl;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
 import org.jetbrains.kotlin.resolve.lazy.LazyEntity;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
 import org.jetbrains.kotlin.resolve.lazy.declarations.PackageMemberDeclarationProvider;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 
 public class LazyPackageDescriptor extends PackageFragmentDescriptorImpl implements LazyEntity {
-    private final JetScope memberScope;
+    private final KtScope memberScope;
     private final PackageMemberDeclarationProvider declarationProvider;
 
     public LazyPackageDescriptor(
@@ -43,14 +43,14 @@ public class LazyPackageDescriptor extends PackageFragmentDescriptorImpl impleme
 
         this.memberScope = new LazyPackageMemberScope(resolveSession, declarationProvider, this);
 
-        for (JetFile file : declarationProvider.getPackageFiles()) {
+        for (KtFile file : declarationProvider.getPackageFiles()) {
             resolveSession.getTrace().record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file, this);
         }
     }
 
     @NotNull
     @Override
-    public JetScope getMemberScope() {
+    public KtScope getMemberScope() {
         return memberScope;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageMemberScope.kt
index 4d37ed1a09c..3be138a26b2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageMemberScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageMemberScope.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve.lazy.descriptors
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.PackageMemberDeclarationProvider
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
@@ -36,7 +36,7 @@ public class LazyPackageMemberScope(
 
     override fun getPackage(name: Name): PackageViewDescriptor? = null
 
-    override fun getScopeForMemberDeclarationResolution(declaration: JetDeclaration)
+    override fun getScopeForMemberDeclarationResolution(declaration: KtDeclaration)
             = resolveSession.getFileScopeProvider().getFileScope(declaration.getContainingJetFile())
 
     override fun getNonDeclaredFunctions(name: Name, result: MutableSet<FunctionDescriptor>) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt
index 3e9245010d0..dfece414ead 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.descriptors.impl.ReceiverParameterDescriptorImpl
 import org.jetbrains.kotlin.descriptors.impl.ScriptCodeDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.parsing.JetScriptDefinitionProvider
-import org.jetbrains.kotlin.psi.JetScript
+import org.jetbrains.kotlin.psi.KtScript
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.ScriptBodyResolver
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.utils.sure
 public class LazyScriptDescriptor(
         private val resolveSession: ResolveSession,
         scriptBodyResolver: ScriptBodyResolver,
-        private val jetScript: JetScript,
+        private val jetScript: KtScript,
         private val priority: Int
 ) : ScriptDescriptor, LazyEntity, DeclarationDescriptorNonRootImpl(
         jetScript.getContainingJetFile().getPackageFqName().let {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java
index 258ad677946..460cc6bf0b1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java
@@ -19,33 +19,33 @@ package org.jetbrains.kotlin.resolve.lazy.descriptors;
 import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.impl.AbstractLazyTypeParameterDescriptor;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
 import org.jetbrains.kotlin.resolve.lazy.LazyClassContext;
 import org.jetbrains.kotlin.resolve.lazy.LazyEntity;
 import org.jetbrains.kotlin.resolve.source.KotlinSourceElementKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Set;
 
 public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescriptor implements LazyEntity {
     private final LazyClassContext c;
 
-    private final JetTypeParameter jetTypeParameter;
+    private final KtTypeParameter jetTypeParameter;
 
     public LazyTypeParameterDescriptor(
             @NotNull LazyClassContext c,
             @NotNull LazyClassDescriptor containingDeclaration,
-            @NotNull JetTypeParameter jetTypeParameter,
+            @NotNull KtTypeParameter jetTypeParameter,
             int index) {
         super(
                 c.getStorageManager(),
                 containingDeclaration,
                 jetTypeParameter.getNameAsSafeName(),
                 jetTypeParameter.getVariance(),
-                jetTypeParameter.hasModifier(JetTokens.REIFIED_KEYWORD),
+                jetTypeParameter.hasModifier(KtTokens.REIFIED_KEYWORD),
                 index,
                 KotlinSourceElementKt.toSourceElement(jetTypeParameter)
         );
@@ -57,14 +57,14 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri
 
     @NotNull
     @Override
-    protected Set<JetType> resolveUpperBounds() {
-        Set<JetType> upperBounds = Sets.newLinkedHashSet();
+    protected Set<KtType> resolveUpperBounds() {
+        Set<KtType> upperBounds = Sets.newLinkedHashSet();
 
-        JetTypeParameter jetTypeParameter = this.jetTypeParameter;
+        KtTypeParameter jetTypeParameter = this.jetTypeParameter;
 
-        JetTypeReference extendsBound = jetTypeParameter.getExtendsBound();
+        KtTypeReference extendsBound = jetTypeParameter.getExtendsBound();
         if (extendsBound != null) {
-            JetType boundType = c.getDescriptorResolver().resolveTypeParameterExtendsBound(
+            KtType boundType = c.getDescriptorResolver().resolveTypeParameterExtendsBound(
                     this, extendsBound, getContainingDeclaration().getScopeForClassHeaderResolution(), c.getTrace());
             upperBounds.add(boundType);
         }
@@ -78,19 +78,19 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri
         return upperBounds;
     }
 
-    private void resolveUpperBoundsFromWhereClause(Set<JetType> upperBounds) {
-        JetClassOrObject classOrObject = JetStubbedPsiUtil.getPsiOrStubParent(jetTypeParameter, JetClassOrObject.class, true);
-        if (classOrObject instanceof JetClass) {
-            JetClass jetClass = (JetClass) classOrObject;
-            for (JetTypeConstraint jetTypeConstraint : jetClass.getTypeConstraints()) {
-                JetSimpleNameExpression constrainedParameterName = jetTypeConstraint.getSubjectTypeParameterName();
+    private void resolveUpperBoundsFromWhereClause(Set<KtType> upperBounds) {
+        KtClassOrObject classOrObject = KtStubbedPsiUtil.getPsiOrStubParent(jetTypeParameter, KtClassOrObject.class, true);
+        if (classOrObject instanceof KtClass) {
+            KtClass ktClass = (KtClass) classOrObject;
+            for (KtTypeConstraint jetTypeConstraint : ktClass.getTypeConstraints()) {
+                KtSimpleNameExpression constrainedParameterName = jetTypeConstraint.getSubjectTypeParameterName();
                 if (constrainedParameterName != null) {
                     if (getName().equals(constrainedParameterName.getReferencedNameAsName())) {
                         c.getTrace().record(BindingContext.REFERENCE_TARGET, constrainedParameterName, this);
 
-                        JetTypeReference boundTypeReference = jetTypeConstraint.getBoundTypeReference();
+                        KtTypeReference boundTypeReference = jetTypeConstraint.getBoundTypeReference();
                         if (boundTypeReference != null) {
-                            JetType boundType = resolveBoundType(boundTypeReference);
+                            KtType boundType = resolveBoundType(boundTypeReference);
                             upperBounds.add(boundType);
                         }
                     }
@@ -100,7 +100,7 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri
 
     }
 
-    private JetType resolveBoundType(@NotNull JetTypeReference boundTypeReference) {
+    private KtType resolveBoundType(@NotNull KtTypeReference boundTypeReference) {
         return c.getTypeResolver()
                     .resolveType(getContainingDeclaration().getScopeForClassHeaderResolution(), boundTypeReference,
                                  c.getTrace(), false);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/JetScopeUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/JetScopeUtils.java
index 982431cb2c0..971e1a394b2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/JetScopeUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/JetScopeUtils.java
@@ -39,7 +39,7 @@ public final class JetScopeUtils {
     private JetScopeUtils() {}
 
     @NotNull
-    public static List<ReceiverValue> getImplicitReceiversHierarchyValues(@NotNull JetScope scope) {
+    public static List<ReceiverValue> getImplicitReceiversHierarchyValues(@NotNull KtScope scope) {
         Collection<ReceiverParameterDescriptor> hierarchy = scope.getImplicitReceiversHierarchy();
 
         return Lists.newArrayList(
@@ -136,7 +136,7 @@ public final class JetScopeUtils {
 
     @TestOnly
     @NotNull
-    public static String printStructure(@Nullable JetScope scope) {
+    public static String printStructure(@Nullable KtScope scope) {
         StringBuilder out = new StringBuilder();
         Printer p = new Printer(out);
         if (scope == null) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/LexicalChainedScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/LexicalChainedScope.kt
index 0b84e2f29a5..e2459c10f6a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/LexicalChainedScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/LexicalChainedScope.kt
@@ -31,7 +31,7 @@ public class LexicalChainedScope(
         override val isOwnerDescriptorAccessibleByLabel: Boolean,
         override val implicitReceiver: ReceiverParameterDescriptor?,
         private val debugName: String,
-        vararg memberScopes: JetScope, // todo JetScope -> MemberScope
+        vararg memberScopes: KtScope, // todo JetScope -> MemberScope
         @Deprecated("This value is temporary hack for resolve -- don't use it!")
         val isStaticScope: Boolean = false
 ): LexicalScope {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/WritableScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/WritableScope.kt
index 6949c3c8457..7e195a6b755 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/WritableScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/WritableScope.kt
@@ -20,14 +20,14 @@ import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 
-public interface WritableScope : JetScope {
+public interface WritableScope : KtScope {
     public enum class LockLevel {
         WRITING,
         BOTH,
         READING
     }
 
-    public fun takeSnapshot(): JetScope
+    public fun takeSnapshot(): KtScope
 
     public fun changeLockLevel(lockLevel: LockLevel)
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/WritableScopeImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/WritableScopeImpl.kt
index e8a8567476e..6c43171dd6d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/WritableScopeImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/WritableScopeImpl.kt
@@ -31,7 +31,7 @@ import java.util.*
 // Writes to: maps
 
 public class WritableScopeImpl @JvmOverloads constructor(
-        outerScope: JetScope,
+        outerScope: KtScope,
         private val ownerDeclarationDescriptor: DeclarationDescriptor,
         override val redeclarationHandler: RedeclarationHandler,
         private val debugName: String,
@@ -39,7 +39,7 @@ public class WritableScopeImpl @JvmOverloads constructor(
         private val labeledDeclaration: DeclarationDescriptor? = null
 ) : AbstractScopeAdapter(), WritableScope, WritableScopeStorage {
 
-    override val workerScope: JetScope = if (outerScope is WritableScope) outerScope.takeSnapshot() else outerScope
+    override val workerScope: KtScope = if (outerScope is WritableScope) outerScope.takeSnapshot() else outerScope
 
     override val addedDescriptors = SmartList<DeclarationDescriptor>()
 
@@ -76,7 +76,7 @@ public class WritableScopeImpl @JvmOverloads constructor(
         }
     }
 
-    override fun takeSnapshot(): JetScope {
+    override fun takeSnapshot(): KtScope {
         checkMayRead()
         if (lastSnapshot == null || lastSnapshot!!.descriptorLimit != addedDescriptors.size()) {
             lastSnapshot = Snapshot(addedDescriptors.size())
@@ -165,7 +165,7 @@ public class WritableScopeImpl @JvmOverloads constructor(
         p.println("}")
     }
 
-    private inner class Snapshot(val descriptorLimit: Int) : JetScope by this@WritableScopeImpl {
+    private inner class Snapshot(val descriptorLimit: Int) : KtScope by this@WritableScopeImpl {
         override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
             checkMayRead()
             changeLockLevel(WritableScope.LockLevel.READING)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExpressionReceiver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExpressionReceiver.java
index f7b682dadf6..dd2e04c5c1f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExpressionReceiver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExpressionReceiver.java
@@ -17,20 +17,20 @@
 package org.jetbrains.kotlin.resolve.scopes.receivers;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.types.KtType;
 
 public class ExpressionReceiver extends AbstractReceiverValue implements ReceiverValue {
 
-    private final JetExpression expression;
+    private final KtExpression expression;
 
-    public ExpressionReceiver(@NotNull JetExpression expression, @NotNull JetType type) {
+    public ExpressionReceiver(@NotNull KtExpression expression, @NotNull KtType type) {
         super(type);
         this.expression = expression;
     }
 
     @NotNull
-    public JetExpression getExpression() {
+    public KtExpression getExpression() {
         return expression;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt
index 1a828021afe..ec7dac60d45 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt
@@ -22,8 +22,8 @@ import org.jetbrains.kotlin.diagnostics.Errors.NO_COMPANION_OBJECT
 import org.jetbrains.kotlin.diagnostics.Errors.TYPE_PARAMETER_IS_NOT_AN_EXPRESSION
 import org.jetbrains.kotlin.diagnostics.Errors.TYPE_PARAMETER_ON_LHS_OF_DOT
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.psiUtil.getTopmostParentQualifiedExpressionForSelector
 import org.jetbrains.kotlin.resolve.BindingContext.QUALIFIER
 import org.jetbrains.kotlin.resolve.BindingContext.REFERENCE_TARGET
@@ -35,10 +35,10 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.classObjectType
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasClassObjectType
 import org.jetbrains.kotlin.resolve.scopes.ChainedScope
 import org.jetbrains.kotlin.resolve.scopes.FilteringScope
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.utils.asJetScope
 import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext
 import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.*
@@ -46,7 +46,7 @@ import kotlin.properties.Delegates
 
 public interface Qualifier: ReceiverValue {
 
-    public val expression: JetExpression
+    public val expression: KtExpression
 
     public val packageView: PackageViewDescriptor?
 
@@ -58,23 +58,23 @@ public interface Qualifier: ReceiverValue {
     // package, classifier or companion object descriptor
     public val resultingDescriptor: DeclarationDescriptor
 
-    public val scope: JetScope
+    public val scope: KtScope
 }
 
 class QualifierReceiver (
-        val referenceExpression: JetSimpleNameExpression,
+        val referenceExpression: KtSimpleNameExpression,
         override val packageView: PackageViewDescriptor?,
         override val classifier: ClassifierDescriptor?
 ) : Qualifier {
 
-    override val expression: JetExpression = referenceExpression.getTopmostParentQualifiedExpressionForSelector() ?: referenceExpression
+    override val expression: KtExpression = referenceExpression.getTopmostParentQualifiedExpressionForSelector() ?: referenceExpression
 
     val descriptor: DeclarationDescriptor
         get() = classifier ?: packageView ?: throw AssertionError("PackageView and classifier both are null")
 
     override var resultingDescriptor: DeclarationDescriptor by Delegates.notNull()
 
-    override val scope: JetScope get() {
+    override val scope: KtScope get() {
         val classObjectTypeScope = (classifier as? ClassDescriptor)?.classObjectType?.getMemberScope()?.let {
             FilteringScope(it) { it !is ClassDescriptor }
         }
@@ -86,8 +86,8 @@ class QualifierReceiver (
             (classifier as? ClassDescriptor)?.classObjectType?.let { ExpressionReceiver(referenceExpression, it) }
             ?: ReceiverValue.NO_RECEIVER
 
-    fun getNestedClassesAndPackageMembersScope(): JetScope {
-        val scopes = ArrayList<JetScope>(4)
+    fun getNestedClassesAndPackageMembersScope(): KtScope {
+        val scopes = ArrayList<KtScope>(4)
 
         scopes.addIfNotNull(packageView?.memberScope)
 
@@ -102,7 +102,7 @@ class QualifierReceiver (
         return ChainedScope(descriptor, "Static scope for " + name + " as package or class or object", *scopes.toTypedArray())
     }
 
-    override fun getType(): JetType = throw IllegalStateException("No type corresponds to QualifierReceiver '$this'")
+    override fun getType(): KtType = throw IllegalStateException("No type corresponds to QualifierReceiver '$this'")
 
     override fun exists() = true
 
@@ -110,7 +110,7 @@ class QualifierReceiver (
 }
 
 fun createQualifier(
-        expression: JetSimpleNameExpression,
+        expression: KtSimpleNameExpression,
         receiver: ReceiverValue,
         context: ExpressionTypingContext
 ): QualifierReceiver? {
@@ -136,7 +136,7 @@ fun createQualifier(
 fun QualifierReceiver.resolveAsStandaloneExpression(
         context: ExpressionTypingContext,
         symbolUsageValidator: SymbolUsageValidator
-): JetType? {
+): KtType? {
     resolveAndRecordReferenceTarget(context, symbolUsageValidator, selector = null)
     if (classifier is TypeParameterDescriptor) {
         context.trace.report(TYPE_PARAMETER_IS_NOT_AN_EXPRESSION.on(referenceExpression, classifier))
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ScriptReceiver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ScriptReceiver.java
index ad8571c1a20..1225149a436 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ScriptReceiver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ScriptReceiver.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve.scopes.receivers;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 // SCRIPT: script receiver
 public class ScriptReceiver implements ThisReceiver {
@@ -40,7 +40,7 @@ public class ScriptReceiver implements ThisReceiver {
 
     @NotNull
     @Override
-    public JetType getType() {
+    public KtType getType() {
         // not sure
         return DescriptorUtilsKt.getBuiltIns(scriptDescriptor).getAnyType();
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt
index 3944f962bab..acc9006bf03 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.lazy.LazyFileScope
 import org.jetbrains.kotlin.resolve.scopes.*
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.util.collectionUtils.concat
 import org.jetbrains.kotlin.utils.Printer
 
@@ -43,7 +43,7 @@ public fun LexicalScope.getFileScope(): FileScope {
  */
 public fun LexicalScope.getImplicitReceiversHierarchy(): List<ReceiverParameterDescriptor> {
     // todo remove hack
-    var jetScopeRefactoringHack: JetScope? = null
+    var jetScopeRefactoringHack: KtScope? = null
     val receivers = collectFromMeAndParent {
         if (it is MemberScopeToFileScopeAdapter) {
             jetScopeRefactoringHack = it.memberScope
@@ -115,16 +115,16 @@ public fun LexicalScope.getClassifier(name: Name, location: LookupLocation): Cla
 
 public fun LexicalScope.takeSnapshot(): LexicalScope = if (this is LexicalWritableScope) takeSnapshot() else this
 
-public fun LexicalScope.asJetScope(): JetScope {
-    if (this is JetScope) return this
+public fun LexicalScope.asJetScope(): KtScope {
+    if (this is KtScope) return this
     if (this is MemberScopeToFileScopeAdapter) return this.memberScope
     return LexicalToJetScopeAdapter(this)
 }
 
-public fun JetScope.memberScopeAsFileScope(): FileScope = MemberScopeToFileScopeAdapter(this)
+public fun KtScope.memberScopeAsFileScope(): FileScope = MemberScopeToFileScopeAdapter(this)
 
 @Deprecated("Remove this method after scope refactoring")
-public fun JetScope.asLexicalScope(): LexicalScope
+public fun KtScope.asLexicalScope(): LexicalScope
         = if (this is LexicalToJetScopeAdapter) {
             lexicalScope
         }
@@ -132,7 +132,7 @@ public fun JetScope.asLexicalScope(): LexicalScope
             memberScopeAsFileScope()
         }
 
-private class LexicalToJetScopeAdapter(lexicalScope: LexicalScope): JetScope {
+private class LexicalToJetScopeAdapter(lexicalScope: LexicalScope): KtScope {
     val lexicalScope = lexicalScope.takeSnapshot()
 
     override fun getClassifier(name: Name, location: LookupLocation) = lexicalScope.getClassifier(name, location)
@@ -155,16 +155,16 @@ private class LexicalToJetScopeAdapter(lexicalScope: LexicalScope): JetScope {
         it.getDeclaredFunctions(name, location)
     }
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation)
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation)
             = lexicalScope.getFileScope().getSyntheticExtensionProperties(receiverTypes, name, location)
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation)
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation)
             = lexicalScope.getFileScope().getSyntheticExtensionFunctions(receiverTypes, name, location)
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>)
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>)
         = lexicalScope.getFileScope().getSyntheticExtensionProperties(receiverTypes)
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>)
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>)
         = lexicalScope.getFileScope().getSyntheticExtensionFunctions(receiverTypes)
 
     override fun getContainingDeclaration() = lexicalScope.ownerDescriptor
@@ -197,19 +197,19 @@ private class LexicalToJetScopeAdapter(lexicalScope: LexicalScope): JetScope {
     }
 }
 
-private class MemberScopeToFileScopeAdapter(val memberScope: JetScope) : FileScope {
+private class MemberScopeToFileScopeAdapter(val memberScope: KtScope) : FileScope {
     override fun getPackage(name: Name): PackageViewDescriptor? = memberScope.getPackage(name)
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation)
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation)
             = memberScope.getSyntheticExtensionProperties(receiverTypes, name, location)
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation)
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation)
             = memberScope.getSyntheticExtensionFunctions(receiverTypes, name, location)
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>)
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>)
             = memberScope.getSyntheticExtensionProperties(receiverTypes)
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>)
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>)
             = memberScope.getSyntheticExtensionFunctions(receiverTypes)
 
     override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean)
@@ -277,7 +277,7 @@ internal inline fun <T: Any> LexicalScope.collectAllFromMeAndParent(
     return result ?: emptySet()
 }
 
-public fun LexicalScope.addImportScope(importScope: JetScope): LexicalScope {
+public fun LexicalScope.addImportScope(importScope: KtScope): LexicalScope {
     val fileScope = getFileScope()
     val scopeWithAdditionImport =
             LexicalChainedScope(fileScope, fileScope.ownerDescriptor, false, null, "Scope with addition import", importScope)
@@ -290,7 +290,7 @@ public fun LexicalScope.replaceFileScope(fileScopeReplace: LexicalScope): Lexica
     return LexicalScopeWrapper(this, fileScopeReplace)
 }
 
-public fun LexicalScope.withNoFileScope(): LexicalScope = replaceFileScope(MemberScopeToFileScopeAdapter(JetScope.Empty))
+public fun LexicalScope.withNoFileScope(): LexicalScope = replaceFileScope(MemberScopeToFileScopeAdapter(KtScope.Empty))
 
 private class LexicalScopeWrapper(val delegate: LexicalScope, val fileScopeReplace: LexicalScope): LexicalScope by delegate {
     override val parent: LexicalScope? by lazy(LazyThreadSafetyMode.NONE) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/source/KotlinSourceElement.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/source/KotlinSourceElement.kt
index da37734c6cc..6b45fd729a9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/source/KotlinSourceElement.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/source/KotlinSourceElement.kt
@@ -16,12 +16,12 @@
 
 package org.jetbrains.kotlin.resolve.source
 
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.descriptors.SourceElement
 import com.intellij.psi.PsiElement
 
-public class KotlinSourceElement(override val psi: JetElement) : PsiSourceElement
+public class KotlinSourceElement(override val psi: KtElement) : PsiSourceElement
 
-public fun JetElement?.toSourceElement(): SourceElement = if (this == null) SourceElement.NO_SOURCE else KotlinSourceElement(this)
+public fun KtElement?.toSourceElement(): SourceElement = if (this == null) SourceElement.NO_SOURCE else KotlinSourceElement(this)
 
 public fun SourceElement.getPsi(): PsiElement? = (this as? PsiSourceElement)?.psi
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt
index 83a58e6b149..65077024705 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.DeprecationLevelValue
@@ -50,12 +50,12 @@ public class DeprecatedSymbolValidator : SymbolUsageValidator {
 
     override fun validateTypeUsage(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement) {
         // Do not check types in annotation entries to prevent cycles in resolve, rely on call message
-        val annotationEntry = JetStubbedPsiUtil.getPsiOrStubParent(element, javaClass<JetAnnotationEntry>(), true)
+        val annotationEntry = KtStubbedPsiUtil.getPsiOrStubParent(element, javaClass<KtAnnotationEntry>(), true)
         if (annotationEntry != null && annotationEntry.getCalleeExpression()!!.getConstructorReferenceExpression() == element)
             return
 
         // Do not check types in calls to super constructor in extends list, rely on call message
-        val superExpression = JetStubbedPsiUtil.getPsiOrStubParent(element, javaClass<JetDelegatorToSuperCall>(), true)
+        val superExpression = KtStubbedPsiUtil.getPsiOrStubParent(element, javaClass<KtDelegatorToSuperCall>(), true)
         if (superExpression != null && superExpression.getCalleeExpression().getConstructorReferenceExpression() == element)
             return
 
@@ -76,8 +76,8 @@ public class DeprecatedSymbolValidator : SymbolUsageValidator {
         return Errors.DEPRECATION.on(element, descriptor.original, message)
     }
 
-    private val PROPERTY_SET_OPERATIONS = TokenSet.create(JetTokens.EQ, JetTokens.PLUSEQ, JetTokens.MINUSEQ, JetTokens.MULTEQ,
-                                                          JetTokens.DIVEQ, JetTokens.PERCEQ, JetTokens.PLUSPLUS, JetTokens.MINUSMINUS)
+    private val PROPERTY_SET_OPERATIONS = TokenSet.create(KtTokens.EQ, KtTokens.PLUSEQ, KtTokens.MINUSEQ, KtTokens.MULTEQ,
+                                                          KtTokens.DIVEQ, KtTokens.PERCEQ, KtTokens.PLUSPLUS, KtTokens.MINUSMINUS)
 
     fun propertyGetterWorkaround(
             resolvedCall: ResolvedCall<*>?,
@@ -86,7 +86,7 @@ public class DeprecatedSymbolValidator : SymbolUsageValidator {
             expression: PsiElement
     ) {
         // property getters do not come as callable yet, so we analyse surroundings to check for deprecation annotation on getter
-        val binaryExpression = PsiTreeUtil.getParentOfType<JetBinaryExpression>(expression, javaClass<JetBinaryExpression>())
+        val binaryExpression = PsiTreeUtil.getParentOfType<KtBinaryExpression>(expression, javaClass<KtBinaryExpression>())
         if (binaryExpression != null) {
             val left = binaryExpression.getLeft()
             if (left == expression) {
@@ -95,7 +95,7 @@ public class DeprecatedSymbolValidator : SymbolUsageValidator {
                     return
             }
 
-            val jetReferenceExpressions = PsiTreeUtil.getChildrenOfType<JetReferenceExpression>(left, javaClass<JetReferenceExpression>())
+            val jetReferenceExpressions = PsiTreeUtil.getChildrenOfType<KtReferenceExpression>(left, javaClass<KtReferenceExpression>())
             if (jetReferenceExpressions != null) {
                 for (expr in jetReferenceExpressions) {
                     if (expr == expression) {
@@ -107,7 +107,7 @@ public class DeprecatedSymbolValidator : SymbolUsageValidator {
             }
         }
 
-        val unaryExpression = PsiTreeUtil.getParentOfType(expression, javaClass<JetUnaryExpression>())
+        val unaryExpression = PsiTreeUtil.getParentOfType(expression, javaClass<KtUnaryExpression>())
         if (unaryExpression != null) {
             val operation = unaryExpression.getOperationReference().getReferencedNameElementType()
             if (operation != null && operation in PROPERTY_SET_OPERATIONS)
@@ -115,7 +115,7 @@ public class DeprecatedSymbolValidator : SymbolUsageValidator {
 
         }
 
-        val callableExpression = PsiTreeUtil.getParentOfType(expression, javaClass<JetCallableReferenceExpression>())
+        val callableExpression = PsiTreeUtil.getParentOfType(expression, javaClass<KtCallableReferenceExpression>())
         if (callableExpression != null && callableExpression.getCallableReference() == expression) {
             return // skip Type::property
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/InfixValidator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/InfixValidator.kt
index 970a6ff5e72..a7e4b1d0f5b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/InfixValidator.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/InfixValidator.kt
@@ -20,8 +20,8 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetOperationReferenceExpression
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtOperationReferenceExpression
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.tasks.isDynamic
@@ -39,7 +39,7 @@ public class InfixValidator : SymbolUsageValidator {
         val functionDescriptor = targetDescriptor as? FunctionDescriptor ?: return
         if (functionDescriptor.isDynamic() || ErrorUtils.isError(functionDescriptor)) return
         if (isInfixCall(element) && !functionDescriptor.isInfix) {
-            val operationRefExpression = element as? JetOperationReferenceExpression ?: return
+            val operationRefExpression = element as? KtOperationReferenceExpression ?: return
             val containingDeclarationName = functionDescriptor.containingDeclaration.fqNameUnsafe.asString()
             trace.report(Errors.INFIX_MODIFIER_REQUIRED.on(operationRefExpression, functionDescriptor, containingDeclarationName))
         }
@@ -47,8 +47,8 @@ public class InfixValidator : SymbolUsageValidator {
 
     companion object {
         fun isInfixCall(element: PsiElement?): Boolean {
-            val operationRefExpression = element as? JetOperationReferenceExpression ?: return false
-            val binaryExpression = operationRefExpression.parent as? JetBinaryExpression ?: return false
+            val operationRefExpression = element as? KtOperationReferenceExpression ?: return false
+            val binaryExpression = operationRefExpression.parent as? KtBinaryExpression ?: return false
             return binaryExpression.operationReference === operationRefExpression && !operationRefExpression.isPredefinedOperator()
         }
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/OperatorValidator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/OperatorValidator.kt
index fa5691256fe..3f46d1b60e2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/OperatorValidator.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/OperatorValidator.kt
@@ -41,7 +41,7 @@ public class OperatorValidator : SymbolUsageValidator {
         val functionDescriptor = targetDescriptor as? FunctionDescriptor ?: return
         if (!checkNotErrorOrDynamic(functionDescriptor)) return
 
-        val jetElement = element as? JetElement ?: return
+        val jetElement = element as? KtElement ?: return
         val call = resolvedCall?.call ?: trace.bindingContext[BindingContext.CALL, jetElement]
 
         fun isInvokeCall(): Boolean {
@@ -49,15 +49,15 @@ public class OperatorValidator : SymbolUsageValidator {
         }
 
         fun isMultiDeclaration(): Boolean {
-            return (resolvedCall != null) && (call?.callElement is JetMultiDeclarationEntry)
+            return (resolvedCall != null) && (call?.callElement is KtMultiDeclarationEntry)
         }
 
         fun isConventionOperator(): Boolean {
-            if (jetElement !is JetOperationReferenceExpression) return false
+            if (jetElement !is KtOperationReferenceExpression) return false
             return jetElement.getNameForConventionalOperation() != null
         }
 
-        fun isArrayAccessExpression() = jetElement is JetArrayAccessExpression
+        fun isArrayAccessExpression() = jetElement is KtArrayAccessExpression
 
         if (isMultiDeclaration() || isInvokeCall()) {
             if (!functionDescriptor.isOperator && call != null) {
@@ -78,7 +78,7 @@ public class OperatorValidator : SymbolUsageValidator {
     }
 
     private fun checkDeprecatedUnaryConventions(call: Call, functionDescriptor: FunctionDescriptor, sink: DiagnosticSink) {
-        (call.callElement as? JetPrefixExpression)?.let { expr ->
+        (call.callElement as? KtPrefixExpression)?.let { expr ->
             val functionName = functionDescriptor.name
             if (functionName == PLUS || functionName == MINUS) {
                 val newName = if (functionName == PLUS) UNARY_PLUS else UNARY_MINUS
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/storage/LockBasedLazyResolveStorageManager.kt b/compiler/frontend/src/org/jetbrains/kotlin/storage/LockBasedLazyResolveStorageManager.kt
index 69c403b5130..42739c86138 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/storage/LockBasedLazyResolveStorageManager.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/storage/LockBasedLazyResolveStorageManager.kt
@@ -25,8 +25,8 @@ import org.jetbrains.kotlin.util.slicedMap.WritableSlice
 import org.jetbrains.kotlin.resolve.TraceEntryFilter
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import com.intellij.util.containers.ContainerUtil
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.types.KtType
 
 public class LockBasedLazyResolveStorageManager(private val storageManager: StorageManager): StorageManager by storageManager, LazyResolveStorageManager {
     override fun <K, V : Any> createSoftlyRetainedMemoizedFunction(compute: Function1<K, V>) =
@@ -39,7 +39,7 @@ public class LockBasedLazyResolveStorageManager(private val storageManager: Stor
             LockProtectedTrace(storageManager, originalTrace)
 
     private class LockProtectedContext(private val storageManager: StorageManager, private val context: BindingContext) : BindingContext {
-        override fun getType(expression: JetExpression): JetType? = storageManager.compute { context.getType(expression) }
+        override fun getType(expression: KtExpression): KtType? = storageManager.compute { context.getType(expression) }
 
         override fun getDiagnostics(): Diagnostics = storageManager.compute { context.getDiagnostics() }
 
@@ -56,11 +56,11 @@ public class LockBasedLazyResolveStorageManager(private val storageManager: Stor
     }
 
     private class LockProtectedTrace(private val storageManager: StorageManager, private val trace: BindingTrace) : BindingTrace {
-        override fun recordType(expression: JetExpression, type: JetType?) {
+        override fun recordType(expression: KtExpression, type: KtType?) {
             storageManager.compute { trace.recordType(expression, type) }
         }
 
-        override fun getType(expression: JetExpression): JetType? = storageManager.compute { trace.getType(expression) }
+        override fun getType(expression: KtExpression): KtType? = storageManager.compute { trace.getType(expression) }
 
         private val context: BindingContext = LockProtectedContext(storageManager, trace.getBindingContext())
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/BoundsSubstitutor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/BoundsSubstitutor.java
index 6ffc611ffed..a7127c475cb 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/BoundsSubstitutor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/BoundsSubstitutor.java
@@ -30,9 +30,9 @@ import java.util.List;
 import java.util.Map;
 
 public class BoundsSubstitutor {
-    private static final Function<TypeProjection,JetType> PROJECTIONS_TO_TYPES = new Function<TypeProjection, JetType>() {
+    private static final Function<TypeProjection,KtType> PROJECTIONS_TO_TYPES = new Function<TypeProjection, KtType>() {
         @Override
-        public JetType apply(TypeProjection projection) {
+        public KtType apply(TypeProjection projection) {
             return projection.getType();
         }
     };
@@ -60,8 +60,8 @@ public class BoundsSubstitutor {
 
         // todo assert: no loops
         for (TypeParameterDescriptor descriptor : topologicallySortTypeParameters(typeParameters)) {
-            JetType upperBoundsAsType = descriptor.getUpperBoundsAsType();
-            JetType substitutedUpperBoundsAsType = substitutor.substitute(upperBoundsAsType, Variance.INVARIANT);
+            KtType upperBoundsAsType = descriptor.getUpperBoundsAsType();
+            KtType substitutedUpperBoundsAsType = substitutor.substitute(upperBoundsAsType, Variance.INVARIANT);
             mutableSubstitution.put(descriptor.getTypeConstructor(), new TypeProjectionImpl(substitutedUpperBoundsAsType));
         }
 
@@ -96,16 +96,16 @@ public class BoundsSubstitutor {
     ) {
         return DFS.dfs(
                 current.getUpperBounds(),
-                new DFS.Neighbors<JetType>() {
+                new DFS.Neighbors<KtType>() {
                     @NotNull
                     @Override
-                    public Iterable<JetType> getNeighbors(JetType current) {
+                    public Iterable<KtType> getNeighbors(KtType current) {
                         return Collections2.transform(current.getArguments(), PROJECTIONS_TO_TYPES);
                     }
                 },
-                new DFS.NodeHandlerWithListResult<JetType, TypeParameterDescriptor>() {
+                new DFS.NodeHandlerWithListResult<KtType, TypeParameterDescriptor>() {
                     @Override
-                    public boolean beforeChildren(JetType current) {
+                    public boolean beforeChildren(KtType current) {
                         ClassifierDescriptor declarationDescriptor = current.getConstructor().getDeclarationDescriptor();
                         // typeParameters in a list, but it contains very few elements, so it's fine to call contains() on it
                         //noinspection SuspiciousMethodCalls
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/CastDiagnosticsUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/types/CastDiagnosticsUtil.java
index 118e38ecd50..8d1f05560ce 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/CastDiagnosticsUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/CastDiagnosticsUtil.java
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.ClassKind;
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 
@@ -39,8 +39,8 @@ public class CastDiagnosticsUtil {
     // As this method produces a warning, it must be _complete_ (not sound), i.e. every time it says "cast impossible",
     // it must be really impossible
     public static boolean isCastPossible(
-            @NotNull JetType lhsType,
-            @NotNull JetType rhsType,
+            @NotNull KtType lhsType,
+            @NotNull KtType rhsType,
             @NotNull PlatformToKotlinClassMap platformToKotlinClassMap
     ) {
         if (KotlinBuiltIns.isNullableNothing(lhsType) && !TypeUtils.isNullableType(rhsType)) return false;
@@ -62,22 +62,22 @@ public class CastDiagnosticsUtil {
      * Due to limitations in PlatformToKotlinClassMap, we only consider mapping of platform classes to Kotlin classed
      * (i.e. java.lang.String -> kotlin.String) and ignore mappings that go the other way.
      */
-    private static boolean isRelated(@NotNull JetType a, @NotNull JetType b, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) {
-        List<JetType> aTypes = mapToPlatformIndependentTypes(TypeUtils.makeNotNullable(a), platformToKotlinClassMap);
-        List<JetType> bTypes = mapToPlatformIndependentTypes(TypeUtils.makeNotNullable(b), platformToKotlinClassMap);
+    private static boolean isRelated(@NotNull KtType a, @NotNull KtType b, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) {
+        List<KtType> aTypes = mapToPlatformIndependentTypes(TypeUtils.makeNotNullable(a), platformToKotlinClassMap);
+        List<KtType> bTypes = mapToPlatformIndependentTypes(TypeUtils.makeNotNullable(b), platformToKotlinClassMap);
 
-        for (JetType aType : aTypes) {
-            for (JetType bType : bTypes) {
-                if (JetTypeChecker.DEFAULT.isSubtypeOf(aType, bType)) return true;
-                if (JetTypeChecker.DEFAULT.isSubtypeOf(bType, aType)) return true;
+        for (KtType aType : aTypes) {
+            for (KtType bType : bTypes) {
+                if (KotlinTypeChecker.DEFAULT.isSubtypeOf(aType, bType)) return true;
+                if (KotlinTypeChecker.DEFAULT.isSubtypeOf(bType, aType)) return true;
             }
         }
 
         return false;
     }
 
-    private static List<JetType> mapToPlatformIndependentTypes(
-            @NotNull JetType type,
+    private static List<KtType> mapToPlatformIndependentTypes(
+            @NotNull KtType type,
             @NotNull PlatformToKotlinClassMap platformToKotlinClassMap
     ) {
         ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
@@ -87,21 +87,21 @@ public class CastDiagnosticsUtil {
         Collection<ClassDescriptor> kotlinClasses = platformToKotlinClassMap.mapPlatformClass(originalClass);
         if (kotlinClasses.isEmpty()) return Collections.singletonList(type);
 
-        List<JetType> result = Lists.newArrayListWithCapacity(2);
+        List<KtType> result = Lists.newArrayListWithCapacity(2);
         result.add(type);
         for (ClassDescriptor classDescriptor : kotlinClasses) {
-            JetType kotlinType = TypeUtils.substituteProjectionsForParameters(classDescriptor, type.getArguments());
+            KtType kotlinType = TypeUtils.substituteProjectionsForParameters(classDescriptor, type.getArguments());
             result.add(kotlinType);
         }
 
         return result;
     }
 
-    private static boolean isFinal(@NotNull JetType type) {
-        return !TypeUtils.canHaveSubtypes(JetTypeChecker.DEFAULT, type);
+    private static boolean isFinal(@NotNull KtType type) {
+        return !TypeUtils.canHaveSubtypes(KotlinTypeChecker.DEFAULT, type);
     }
 
-    private static boolean isTrait(@NotNull JetType type) {
+    private static boolean isTrait(@NotNull KtType type) {
         ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
         return descriptor instanceof ClassDescriptor && ((ClassDescriptor) descriptor).getKind() == ClassKind.INTERFACE;
     }
@@ -110,7 +110,7 @@ public class CastDiagnosticsUtil {
      * Check if cast from supertype to subtype is erased.
      * It is an error in "is" statement and warning in "as".
      */
-    public static boolean isCastErased(@NotNull JetType supertype, @NotNull JetType subtype, @NotNull JetTypeChecker typeChecker) {
+    public static boolean isCastErased(@NotNull KtType supertype, @NotNull KtType subtype, @NotNull KotlinTypeChecker typeChecker) {
         // cast between T and T? is always OK
         if (supertype.isMarkedNullable() || subtype.isMarkedNullable()) {
             return isCastErased(TypeUtils.makeNotNullable(supertype), TypeUtils.makeNotNullable(subtype), typeChecker);
@@ -126,7 +126,7 @@ public class CastDiagnosticsUtil {
         // NOTE: this does not account for 'as Array<List<T>>'
         if (allParametersReified(subtype)) return false;
 
-        JetType staticallyKnownSubtype = findStaticallyKnownSubtype(supertype, subtype.getConstructor()).getResultingType();
+        KtType staticallyKnownSubtype = findStaticallyKnownSubtype(supertype, subtype.getConstructor()).getResultingType();
 
         // If the substitution failed, it means that the result is an impossible type, e.g. something like Out<in Foo>
         // In this case, we can't guarantee anything, so the cast is considered to be erased
@@ -153,18 +153,18 @@ public class CastDiagnosticsUtil {
      *  subtype = List<...>
      *  result = List<*>, some arguments were not inferred, replaced with '*'
      */
-    public static TypeReconstructionResult findStaticallyKnownSubtype(@NotNull JetType supertype, @NotNull TypeConstructor subtypeConstructor) {
+    public static TypeReconstructionResult findStaticallyKnownSubtype(@NotNull KtType supertype, @NotNull TypeConstructor subtypeConstructor) {
         assert !supertype.isMarkedNullable() : "This method only makes sense for non-nullable types";
 
         // Assume we are casting an expression of type Collection<Foo> to List<Bar>
         // First, let's make List<T>, where T is a type variable
         ClassifierDescriptor descriptor = subtypeConstructor.getDeclarationDescriptor();
         assert descriptor != null : "Can't create default type for " + subtypeConstructor;
-        JetType subtypeWithVariables = descriptor.getDefaultType();
+        KtType subtypeWithVariables = descriptor.getDefaultType();
 
         // Now, let's find a supertype of List<T> that is a Collection of something,
         // in this case it will be Collection<T>
-        JetType supertypeWithVariables = TypeCheckingProcedure.findCorrespondingSupertype(subtypeWithVariables, supertype);
+        KtType supertypeWithVariables = TypeCheckingProcedure.findCorrespondingSupertype(subtypeWithVariables, supertype);
 
         final List<TypeParameterDescriptor> variables = subtypeWithVariables.getConstructor().getParameters();
 
@@ -204,12 +204,12 @@ public class CastDiagnosticsUtil {
 
         // At this point we have values for all type parameters of List
         // Let's make a type by substituting them: List<T> -> List<Foo>
-        JetType substituted = TypeSubstitutor.create(substitution).substitute(subtypeWithVariables, Variance.INVARIANT);
+        KtType substituted = TypeSubstitutor.create(substitution).substitute(subtypeWithVariables, Variance.INVARIANT);
 
         return new TypeReconstructionResult(substituted, allArgumentsInferred);
     }
 
-    private static boolean allParametersReified(JetType subtype) {
+    private static boolean allParametersReified(KtType subtype) {
         for (TypeParameterDescriptor parameterDescriptor : subtype.getConstructor().getParameters()) {
             if (!parameterDescriptor.isReified()) return false;
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/DeferredType.java b/compiler/frontend/src/org/jetbrains/kotlin/types/DeferredType.java
index d995b5e51d7..df7d958d228 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/DeferredType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/DeferredType.java
@@ -36,9 +36,9 @@ public class DeferredType extends DelegatingType implements LazyType {
         }
     };
 
-    private static final Function1<Boolean,JetType> RECURSION_PREVENTER = new Function1<Boolean, JetType>() {
+    private static final Function1<Boolean,KtType> RECURSION_PREVENTER = new Function1<Boolean, KtType>() {
         @Override
-        public JetType invoke(Boolean firstTime) {
+        public KtType invoke(Boolean firstTime) {
             if (firstTime) throw new ReenteringLazyValueComputationException();
             return ErrorUtils.createErrorType("Recursive dependency");
         }
@@ -48,7 +48,7 @@ public class DeferredType extends DelegatingType implements LazyType {
     public static DeferredType create(
             @NotNull StorageManager storageManager,
             @NotNull BindingTrace trace,
-            @NotNull Function0<JetType> compute
+            @NotNull Function0<KtType> compute
     ) {
         DeferredType deferredType = new DeferredType(storageManager.createLazyValue(compute));
         trace.record(DEFERRED_TYPE, new Box<DeferredType>(deferredType));
@@ -59,7 +59,7 @@ public class DeferredType extends DelegatingType implements LazyType {
     public static DeferredType createRecursionIntolerant(
             @NotNull StorageManager storageManager,
             @NotNull BindingTrace trace,
-            @NotNull Function0<JetType> compute
+            @NotNull Function0<KtType> compute
     ) {
         //noinspection unchecked
         DeferredType deferredType = new DeferredType(storageManager.createLazyValueWithPostCompute(
@@ -71,9 +71,9 @@ public class DeferredType extends DelegatingType implements LazyType {
         return deferredType;
     }
 
-    private final NotNullLazyValue<JetType> lazyValue;
+    private final NotNullLazyValue<KtType> lazyValue;
 
-    private DeferredType(@NotNull NotNullLazyValue<JetType> lazyValue) {
+    private DeferredType(@NotNull NotNullLazyValue<KtType> lazyValue) {
         this.lazyValue = lazyValue;
     }
 
@@ -82,7 +82,7 @@ public class DeferredType extends DelegatingType implements LazyType {
     }
 
     @Override
-    public JetType getDelegate() {
+    public KtType getDelegate() {
         return lazyValue.invoke();
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/SubstitutionUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/SubstitutionUtils.java
index 70de4f1462f..1cda6693af2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/SubstitutionUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/SubstitutionUtils.java
@@ -35,7 +35,7 @@ public class SubstitutionUtils {
      * Builds a context with all the supertypes' parameters substituted
      */
     @NotNull
-    public static TypeSubstitutor buildDeepSubstitutor(@NotNull JetType type) {
+    public static TypeSubstitutor buildDeepSubstitutor(@NotNull KtType type) {
         Map<TypeConstructor, TypeProjection> substitution = Maps.newHashMap();
         TypeSubstitutor typeSubstitutor = TypeSubstitutor.create(substitution);
         // we use the mutability of the map here
@@ -57,7 +57,7 @@ public class SubstitutionUtils {
           F declared in MyFooCollection -> out CharSequence
      */
     @NotNull
-    public static Multimap<TypeConstructor, TypeProjection> buildDeepSubstitutionMultimap(@NotNull JetType type) {
+    public static Multimap<TypeConstructor, TypeProjection> buildDeepSubstitutionMultimap(@NotNull KtType type) {
         Multimap<TypeConstructor, TypeProjection> fullSubstitution = LinkedHashMultimap.create();
         Map<TypeConstructor, TypeProjection> substitution = Maps.newHashMap();
         TypeSubstitutor typeSubstitutor = TypeSubstitutor.create(substitution);
@@ -68,7 +68,7 @@ public class SubstitutionUtils {
 
     // we use the mutability of the substitution map here
     private static void fillInDeepSubstitutor(
-            @NotNull JetType context,
+            @NotNull KtType context,
             @NotNull TypeSubstitutor substitutor,
             @NotNull Map<TypeConstructor, TypeProjection> substitution,
             @Nullable Multimap<TypeConstructor, TypeProjection> fullSubstitution
@@ -92,7 +92,7 @@ public class SubstitutionUtils {
             }
         }
         if (KotlinBuiltIns.isNothingOrNullableNothing(context)) return;
-        for (JetType supertype : context.getConstructor().getSupertypes()) {
+        for (KtType supertype : context.getConstructor().getSupertypes()) {
             fillInDeepSubstitutor(supertype, substitutor, substitution, fullSubstitution);
         }
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/TypeReconstructionResult.java b/compiler/frontend/src/org/jetbrains/kotlin/types/TypeReconstructionResult.java
index de78b0beb74..45137973fd4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/TypeReconstructionResult.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/TypeReconstructionResult.java
@@ -19,16 +19,16 @@ package org.jetbrains.kotlin.types;
 import org.jetbrains.annotations.Nullable;
 
 public class TypeReconstructionResult {
-    private final JetType resultingType;
+    private final KtType resultingType;
     private final boolean allArgumentsInferred;
 
-    public TypeReconstructionResult(@Nullable JetType resultingType, boolean allArgumentsInferred) {
+    public TypeReconstructionResult(@Nullable KtType resultingType, boolean allArgumentsInferred) {
         this.resultingType = resultingType;
         this.allArgumentsInferred = allArgumentsInferred;
     }
 
     @Nullable
-    public JetType getResultingType() {
+    public KtType getResultingType() {
         return resultingType;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/TypeUnifier.java b/compiler/frontend/src/org/jetbrains/kotlin/types/TypeUnifier.java
index 369ab09490f..61025fed5e5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/TypeUnifier.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/TypeUnifier.java
@@ -63,8 +63,8 @@ public class TypeUnifier {
             Predicate<TypeConstructor> isVariable,
             UnificationResultImpl result
     ) {
-        JetType known = knownProjection.getType();
-        JetType withVariables = projectWithVariables.getType();
+        KtType known = knownProjection.getType();
+        KtType withVariables = projectWithVariables.getType();
 
         // in Foo ~ in X  =>  Foo ~ X
         Variance knownProjectionKind = knownProjection.getProjectionKind();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/AssignedVariablesSearcher.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/AssignedVariablesSearcher.kt
index 8bafcd0abc9..920db4a1527 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/AssignedVariablesSearcher.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/AssignedVariablesSearcher.kt
@@ -19,44 +19,44 @@ package org.jetbrains.kotlin.types.expressions
 import com.google.common.collect.LinkedHashMultimap
 import com.google.common.collect.SetMultimap
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 
-abstract class AssignedVariablesSearcher: JetTreeVisitorVoid() {
+abstract class AssignedVariablesSearcher: KtTreeVisitorVoid() {
 
-    private val assignedNames: SetMultimap<Name, JetDeclaration?> = LinkedHashMultimap.create()
+    private val assignedNames: SetMultimap<Name, KtDeclaration?> = LinkedHashMultimap.create()
 
     public open fun writers(variableDescriptor: VariableDescriptor) = assignedNames[variableDescriptor.name]
 
     public fun hasWriters(variableDescriptor: VariableDescriptor) = writers(variableDescriptor).isNotEmpty()
 
-    private var currentDeclaration: JetDeclaration? = null
+    private var currentDeclaration: KtDeclaration? = null
 
-    override fun visitDeclaration(declaration: JetDeclaration) {
+    override fun visitDeclaration(declaration: KtDeclaration) {
         val previous = currentDeclaration
-        if (declaration is JetDeclarationWithBody || declaration is JetClassOrObject) {
+        if (declaration is KtDeclarationWithBody || declaration is KtClassOrObject) {
             currentDeclaration = declaration
         }
-        else if (declaration is JetClassInitializer) {
+        else if (declaration is KtClassInitializer) {
             // Go to class declaration: init -> body -> class
-            currentDeclaration = declaration.parent.parent as JetDeclaration
+            currentDeclaration = declaration.parent.parent as KtDeclaration
         }
         super.visitDeclaration(declaration)
         currentDeclaration = previous
     }
 
-    override fun visitFunctionLiteralExpression(functionLiteralExpression: JetFunctionLiteralExpression) {
+    override fun visitFunctionLiteralExpression(functionLiteralExpression: KtFunctionLiteralExpression) {
         val previous = currentDeclaration
         currentDeclaration = functionLiteralExpression.functionLiteral
         super.visitFunctionLiteralExpression(functionLiteralExpression)
         currentDeclaration = previous
     }
 
-    override fun visitBinaryExpression(binaryExpression: JetBinaryExpression) {
-        if (binaryExpression.operationToken === JetTokens.EQ) {
-            val left = JetPsiUtil.deparenthesize(binaryExpression.left)
-            if (left is JetNameReferenceExpression) {
+    override fun visitBinaryExpression(binaryExpression: KtBinaryExpression) {
+        if (binaryExpression.operationToken === KtTokens.EQ) {
+            val left = KtPsiUtil.deparenthesize(binaryExpression.left)
+            if (left is KtNameReferenceExpression) {
                 assignedNames.put(left.getReferencedNameAsName(), currentDeclaration)
             }
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
index 1d7c4fa4c68..dde1fb84831 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
@@ -26,14 +26,14 @@ import kotlin.jvm.functions.Function0;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.Errors;
-import org.jetbrains.kotlin.lexer.JetKeywordToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtKeywordToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.*;
@@ -63,7 +63,7 @@ import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
 import org.jetbrains.kotlin.types.*;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt;
 import org.jetbrains.kotlin.types.expressions.unqualifiedSuper.UnqualifiedSuperKt;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
@@ -75,7 +75,7 @@ import java.util.Iterator;
 import java.util.List;
 
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
+import static org.jetbrains.kotlin.lexer.KtTokens.*;
 import static org.jetbrains.kotlin.resolve.BindingContext.*;
 import static org.jetbrains.kotlin.resolve.calls.context.ContextDependency.DEPENDENT;
 import static org.jetbrains.kotlin.resolve.calls.context.ContextDependency.INDEPENDENT;
@@ -97,7 +97,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression, ExpressionTypingContext context) {
         // TODO : other members
         // TODO : type substitutions???
         CallExpressionResolver callExpressionResolver = components.callExpressionResolver;
@@ -106,8 +106,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression, ExpressionTypingContext context) {
-        JetExpression innerExpression = expression.getExpression();
+    public JetTypeInfo visitParenthesizedExpression(@NotNull KtParenthesizedExpression expression, ExpressionTypingContext context) {
+        KtExpression innerExpression = expression.getExpression();
         if (innerExpression == null) {
             return TypeInfoFactoryKt.noTypeInfo(context);
         }
@@ -115,8 +115,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitConstantExpression(@NotNull JetConstantExpression expression, ExpressionTypingContext context) {
-        if (expression.getNode().getElementType() == JetNodeTypes.CHARACTER_CONSTANT) {
+    public JetTypeInfo visitConstantExpression(@NotNull KtConstantExpression expression, ExpressionTypingContext context) {
+        if (expression.getNode().getElementType() == KtNodeTypes.CHARACTER_CONSTANT) {
             checkStringPrefixAndSuffix(expression, context);
         }
 
@@ -139,21 +139,21 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @NotNull
-    public JetType getDefaultType(IElementType constantType) {
+    public KtType getDefaultType(IElementType constantType) {
         KotlinBuiltIns builtIns = components.builtIns;
-        if (constantType == JetNodeTypes.INTEGER_CONSTANT) {
+        if (constantType == KtNodeTypes.INTEGER_CONSTANT) {
             return builtIns.getIntType();
         }
-        else if (constantType == JetNodeTypes.FLOAT_CONSTANT) {
+        else if (constantType == KtNodeTypes.FLOAT_CONSTANT) {
             return builtIns.getDoubleType();
         }
-        else if (constantType == JetNodeTypes.BOOLEAN_CONSTANT) {
+        else if (constantType == KtNodeTypes.BOOLEAN_CONSTANT) {
             return builtIns.getBooleanType();
         }
-        else if (constantType == JetNodeTypes.CHARACTER_CONSTANT) {
+        else if (constantType == KtNodeTypes.CHARACTER_CONSTANT) {
             return builtIns.getCharType();
         }
-        else if (constantType == JetNodeTypes.NULL) {
+        else if (constantType == KtNodeTypes.NULL) {
             return builtIns.getNullableNothingType();
         }
         else {
@@ -162,11 +162,11 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitBinaryWithTypeRHSExpression(@NotNull KtBinaryExpressionWithTypeRHS expression, ExpressionTypingContext context) {
         ExpressionTypingContext contextWithNoExpectedType =
                 context.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT);
-        JetExpression left = expression.getLeft();
-        JetTypeReference right = expression.getRight();
+        KtExpression left = expression.getLeft();
+        KtTypeReference right = expression.getRight();
         if (right == null) {
             return facade.getTypeInfo(left, contextWithNoExpectedType).clearType();
         }
@@ -179,8 +179,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
         JetTypeInfo typeInfo = facade.getTypeInfo(left, contextWithNoExpectedType);
 
-        JetType subjectType = typeInfo.getType();
-        JetType targetType = reconstructBareType(right, possiblyBareTarget, subjectType, context.trace, components.builtIns);
+        KtType subjectType = typeInfo.getType();
+        KtType targetType = reconstructBareType(right, possiblyBareTarget, subjectType, context.trace, components.builtIns);
 
         if (subjectType != null) {
             checkBinaryWithTypeRHS(expression, contextWithNoExpectedType, targetType, subjectType);
@@ -191,20 +191,20 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             }
         }
 
-        JetType result = operationType == AS_SAFE ? TypeUtils.makeNullable(targetType) : targetType;
+        KtType result = operationType == AS_SAFE ? TypeUtils.makeNullable(targetType) : targetType;
         return components.dataFlowAnalyzer.checkType(typeInfo.replaceType(result), expression, context);
     }
 
     private void checkBinaryWithTypeRHS(
-            @NotNull JetBinaryExpressionWithTypeRHS expression,
+            @NotNull KtBinaryExpressionWithTypeRHS expression,
             @NotNull ExpressionTypingContext context,
-            @NotNull JetType targetType,
-            @Nullable JetType actualType
+            @NotNull KtType targetType,
+            @Nullable KtType actualType
     ) {
         if (actualType == null) return;
-        JetSimpleNameExpression operationSign = expression.getOperationReference();
+        KtSimpleNameExpression operationSign = expression.getOperationReference();
         IElementType operationType = operationSign.getReferencedNameElementType();
-        if (operationType != JetTokens.AS_KEYWORD && operationType != JetTokens.AS_SAFE) {
+        if (operationType != KtTokens.AS_KEYWORD && operationType != KtTokens.AS_SAFE) {
             context.trace.report(UNSUPPORTED.on(operationSign, "binary operation with type RHS"));
             return;
         }
@@ -212,15 +212,15 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     private void checkForCastImpossibilityOrRedundancy(
-            JetBinaryExpressionWithTypeRHS expression,
-            JetType actualType,
-            JetType targetType,
+            KtBinaryExpressionWithTypeRHS expression,
+            KtType actualType,
+            KtType targetType,
             ExpressionTypingContext context
     ) {
         if (actualType == null || noExpectedType(targetType) || targetType.isError()) return;
 
         if (DynamicTypesKt.isDynamic(targetType)) {
-            JetTypeReference right = expression.getRight();
+            KtTypeReference right = expression.getRight();
             assert right != null : "We know target is dynamic, but RHS is missing";
             context.trace.report(DYNAMIC_NOT_ALLOWED.on(right));
             return;
@@ -230,17 +230,17 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             context.trace.report(CAST_NEVER_SUCCEEDS.on(expression.getOperationReference()));
             return;
         }
-        JetTypeChecker typeChecker = JetTypeChecker.DEFAULT;
+        KotlinTypeChecker typeChecker = KotlinTypeChecker.DEFAULT;
         if (actualType.equals(targetType)) {
             // cast to itself: String as String
             context.trace.report(USELESS_CAST.on(expression));
             return;
         }
-        Collection<JetType> possibleTypes = components.dataFlowAnalyzer.getAllPossibleTypes(
+        Collection<KtType> possibleTypes = components.dataFlowAnalyzer.getAllPossibleTypes(
                 expression.getLeft(), context.dataFlowInfo, actualType, context);
 
         boolean checkExactType = checkExactTypeForUselessCast(expression);
-        for (JetType possibleType : possibleTypes) {
+        for (KtType possibleType : possibleTypes) {
             boolean castIsUseless = checkExactType
                                     ? possibleType.equals(targetType)
                                     : typeChecker.isSubtypeOf(possibleType, targetType);
@@ -256,26 +256,26 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
     // Casting an argument or a receiver to a supertype may be useful to select an exact overload of a method.
     // Casting to a supertype in other contexts is unlikely to be useful.
-    private static boolean checkExactTypeForUselessCast(JetBinaryExpressionWithTypeRHS expression) {
+    private static boolean checkExactTypeForUselessCast(KtBinaryExpressionWithTypeRHS expression) {
         PsiElement parent = expression.getParent();
-        while (parent instanceof JetParenthesizedExpression ||
-               parent instanceof JetLabeledExpression ||
-               parent instanceof JetAnnotatedExpression) {
+        while (parent instanceof KtParenthesizedExpression ||
+               parent instanceof KtLabeledExpression ||
+               parent instanceof KtAnnotatedExpression) {
             parent = parent.getParent();
         }
-        if (parent instanceof JetValueArgument) {
+        if (parent instanceof KtValueArgument) {
             return true;
         }
-        if (parent instanceof JetQualifiedExpression) {
-            JetExpression receiver = ((JetQualifiedExpression) parent).getReceiverExpression();
+        if (parent instanceof KtQualifiedExpression) {
+            KtExpression receiver = ((KtQualifiedExpression) parent).getReceiverExpression();
             return PsiTreeUtil.isAncestor(receiver, expression, false);
         }
         return false;
     }
 
     @Override
-    public JetTypeInfo visitThisExpression(@NotNull JetThisExpression expression, ExpressionTypingContext context) {
-        JetType result = null;
+    public JetTypeInfo visitThisExpression(@NotNull KtThisExpression expression, ExpressionTypingContext context) {
+        KtType result = null;
         LabelResolver.LabeledReceiverResolutionResult resolutionResult = resolveToReceiver(expression, context, false);
 
         switch (resolutionResult.getCode()) {
@@ -294,10 +294,10 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitSuperExpression(@NotNull JetSuperExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitSuperExpression(@NotNull KtSuperExpression expression, ExpressionTypingContext context) {
         LabelResolver.LabeledReceiverResolutionResult resolutionResult = resolveToReceiver(expression, context, true);
 
-        if (!JetPsiUtil.isLHSOfDot(expression)) {
+        if (!KtPsiUtil.isLHSOfDot(expression)) {
             context.trace.report(SUPER_IS_NOT_AN_EXPRESSION.on(expression, expression.getText()));
             return errorInSuper(expression, context);
         }
@@ -310,7 +310,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                 context.trace.report(SUPER_NOT_AVAILABLE.on(expression));
                 return errorInSuper(expression, context);
             case SUCCESS:
-                JetType result = checkPossiblyQualifiedSuper(expression, context, resolutionResult.getReceiverParameterDescriptor());
+                KtType result = checkPossiblyQualifiedSuper(expression, context, resolutionResult.getReceiverParameterDescriptor());
                 if (result != null) {
                     context.trace.recordType(expression.getInstanceReference(), result);
                 }
@@ -319,33 +319,33 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         throw new IllegalStateException("Unknown code: " + resolutionResult.getCode());
     }
 
-    private JetTypeInfo errorInSuper(JetSuperExpression expression, ExpressionTypingContext context) {
-        JetTypeReference superTypeQualifier = expression.getSuperTypeQualifier();
+    private JetTypeInfo errorInSuper(KtSuperExpression expression, ExpressionTypingContext context) {
+        KtTypeReference superTypeQualifier = expression.getSuperTypeQualifier();
         if (superTypeQualifier != null) {
             components.typeResolver.resolveType(context.scope, superTypeQualifier, context.trace, true);
         }
         return TypeInfoFactoryKt.noTypeInfo(context);
     }
 
-    private JetType checkPossiblyQualifiedSuper(
-            JetSuperExpression expression,
+    private KtType checkPossiblyQualifiedSuper(
+            KtSuperExpression expression,
             ExpressionTypingContext context,
             ReceiverParameterDescriptor thisReceiver
     ) {
-        JetType result = null;
-        JetType thisType = thisReceiver.getType();
-        Collection<JetType> supertypes = thisType.getConstructor().getSupertypes();
+        KtType result = null;
+        KtType thisType = thisReceiver.getType();
+        Collection<KtType> supertypes = thisType.getConstructor().getSupertypes();
         TypeSubstitutor substitutor = TypeSubstitutor.create(thisType);
 
-        JetTypeReference superTypeQualifier = expression.getSuperTypeQualifier();
+        KtTypeReference superTypeQualifier = expression.getSuperTypeQualifier();
         if (superTypeQualifier != null) {
-            JetTypeElement typeElement = superTypeQualifier.getTypeElement();
+            KtTypeElement typeElement = superTypeQualifier.getTypeElement();
 
             DeclarationDescriptor classifierCandidate = null;
-            JetType supertype = null;
+            KtType supertype = null;
             PsiElement redundantTypeArguments = null;
-            if (typeElement instanceof JetUserType) {
-                JetUserType userType = (JetUserType) typeElement;
+            if (typeElement instanceof KtUserType) {
+                KtUserType userType = (KtUserType) typeElement;
                 // This may be just a superclass name even if the superclass is generic
                 if (userType.getTypeArguments().isEmpty()) {
                     classifierCandidate = components.typeResolver.resolveClass(context.scope, userType, context.trace);
@@ -367,7 +367,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             else if (classifierCandidate instanceof ClassDescriptor) {
                 ClassDescriptor superclass = (ClassDescriptor) classifierCandidate;
 
-                for (JetType declaredSupertype : supertypes) {
+                for (KtType declaredSupertype : supertypes) {
                     if (declaredSupertype.getConstructor().equals(superclass.getTypeConstructor())) {
                         result = substitutor.safeSubstitute(declaredSupertype, Variance.INVARIANT);
                         break;
@@ -386,11 +386,11 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         }
         else {
             if (UnqualifiedSuperKt.isPossiblyAmbiguousUnqualifiedSuper(expression, supertypes)) {
-                Collection<JetType> supertypesResolvedFromContext =
+                Collection<KtType> supertypesResolvedFromContext =
                         UnqualifiedSuperKt.resolveUnqualifiedSuperFromExpressionContext(
                                 expression, supertypes, components.builtIns.getAnyType());
                 if (supertypesResolvedFromContext.size() == 1) {
-                    JetType singleResolvedType = supertypesResolvedFromContext.iterator().next();
+                    KtType singleResolvedType = supertypesResolvedFromContext.iterator().next();
                     result = substitutor.substitute(singleResolvedType, Variance.INVARIANT);
                 }
                 else if (supertypesResolvedFromContext.isEmpty()) {
@@ -404,7 +404,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             }
             else {
                 // supertypes may be empty when all the supertypes are error types (are not resolved, for example)
-                JetType type = supertypes.isEmpty()
+                KtType type = supertypes.isEmpty()
                                ? components.builtIns.getAnyType()
                                : supertypes.iterator().next();
                 result = substitutor.substitute(type, Variance.INVARIANT);
@@ -426,7 +426,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
     @NotNull // No class receivers
     private LabelResolver.LabeledReceiverResolutionResult resolveToReceiver(
-            JetInstanceExpressionWithLabel expression,
+            KtInstanceExpressionWithLabel expression,
             ExpressionTypingContext context,
             boolean onlyClassReceivers
     ) {
@@ -468,7 +468,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     private void recordThisOrSuperCallInTraceAndCallExtension(
             ExpressionTypingContext context,
             ReceiverParameterDescriptor descriptor,
-            JetExpression expression
+            KtExpression expression
     ) {
         BindingTrace trace = context.trace;
         Call call = CallMaker.makeCall(expression, NO_RECEIVER, null, expression, Collections.<ValueArgument>emptyList());
@@ -500,13 +500,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitBlockExpression(@NotNull JetBlockExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitBlockExpression(@NotNull KtBlockExpression expression, ExpressionTypingContext context) {
         return components.expressionTypingServices.getBlockReturnedType(expression, context, false);
     }
 
     @Override
-    public JetTypeInfo visitClassLiteralExpression(@NotNull JetClassLiteralExpression expression, ExpressionTypingContext c) {
-        JetType type = resolveClassLiteral(expression, c);
+    public JetTypeInfo visitClassLiteralExpression(@NotNull KtClassLiteralExpression expression, ExpressionTypingContext c) {
+        KtType type = resolveClassLiteral(expression, c);
         if (type != null && !type.isError()) {
             return components.dataFlowAnalyzer.createCheckedTypeInfo(
                     components.reflectionTypes.getKClassType(Annotations.Companion.getEMPTY(), type), c, expression
@@ -517,8 +517,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Nullable
-    private JetType resolveClassLiteral(@NotNull JetClassLiteralExpression expression, ExpressionTypingContext c) {
-        JetTypeReference typeReference = expression.getTypeReference();
+    private KtType resolveClassLiteral(@NotNull KtClassLiteralExpression expression, ExpressionTypingContext c) {
+        KtTypeReference typeReference = expression.getTypeReference();
 
         if (typeReference == null) {
             // "::class" will mean "this::class", a class of "this" instance
@@ -531,7 +531,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         PossiblyBareType possiblyBareType =
                 components.typeResolver.resolvePossiblyBareType(context, typeReference);
 
-        JetType type = null;
+        KtType type = null;
         if (possiblyBareType.isBare()) {
             if (!possiblyBareType.isNullable()) {
                 ClassifierDescriptor descriptor = possiblyBareType.getBareTypeConstructor().getDeclarationDescriptor();
@@ -546,7 +546,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             }
         }
         else {
-            JetType actualType = possiblyBareType.getActualType();
+            KtType actualType = possiblyBareType.getActualType();
             if (actualType.isError()) return null;
             if (isAllowedInClassLiteral(actualType)) {
                 type = actualType;
@@ -562,7 +562,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @NotNull
-    private static JetType substituteWithStarProjections(@NotNull ClassDescriptor descriptor) {
+    private static KtType substituteWithStarProjections(@NotNull ClassDescriptor descriptor) {
         TypeConstructor typeConstructor = descriptor.getTypeConstructor();
         List<TypeProjection> arguments =
                 CollectionsKt.map(typeConstructor.getParameters(), new Function1<TypeParameterDescriptor, TypeProjection>() {
@@ -572,14 +572,14 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                     }
                 });
 
-        return JetTypeImpl.create(Annotations.Companion.getEMPTY(), descriptor, false, arguments);
+        return KtTypeImpl.create(Annotations.Companion.getEMPTY(), descriptor, false, arguments);
     }
 
-    private static boolean isAllowedInClassLiteral(@NotNull JetType type) {
+    private static boolean isAllowedInClassLiteral(@NotNull KtType type) {
         return isClassAvailableAtRuntime(type, false);
     }
 
-    private static boolean isClassAvailableAtRuntime(@NotNull JetType type, boolean canBeNullable) {
+    private static boolean isClassAvailableAtRuntime(@NotNull KtType type, boolean canBeNullable) {
         if (type.isMarkedNullable() && !canBeNullable) return false;
 
         TypeConstructor typeConstructor = type.getConstructor();
@@ -611,28 +611,28 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitCallableReferenceExpression(@NotNull JetCallableReferenceExpression expression, ExpressionTypingContext c) {
-        JetTypeReference typeReference = expression.getTypeReference();
+    public JetTypeInfo visitCallableReferenceExpression(@NotNull KtCallableReferenceExpression expression, ExpressionTypingContext c) {
+        KtTypeReference typeReference = expression.getTypeReference();
 
-        JetType receiverType =
+        KtType receiverType =
                 typeReference == null
                 ? null
                 : components.typeResolver.resolveType(c.scope, typeReference, c.trace, false);
 
-        JetSimpleNameExpression callableReference = expression.getCallableReference();
+        KtSimpleNameExpression callableReference = expression.getCallableReference();
         if (callableReference.getReferencedName().isEmpty()) {
             c.trace.report(UNRESOLVED_REFERENCE.on(callableReference, callableReference));
-            JetType errorType = ErrorUtils.createErrorType("Empty callable reference");
+            KtType errorType = ErrorUtils.createErrorType("Empty callable reference");
             return components.dataFlowAnalyzer.createCheckedTypeInfo(errorType, c, expression);
         }
 
-        JetType result = getCallableReferenceType(expression, receiverType, c);
+        KtType result = getCallableReferenceType(expression, receiverType, c);
         return components.dataFlowAnalyzer.createCheckedTypeInfo(result, c, expression);
     }
 
     @Override
-    public JetTypeInfo visitObjectLiteralExpression(@NotNull final JetObjectLiteralExpression expression, final ExpressionTypingContext context) {
-        final JetType[] result = new JetType[1];
+    public JetTypeInfo visitObjectLiteralExpression(@NotNull final KtObjectLiteralExpression expression, final ExpressionTypingContext context) {
+        final KtType[] result = new KtType[1];
         TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace,
                                                                             "trace to resolve object literal expression", expression);
         ObservableBindingTrace.RecordHandler<PsiElement, ClassDescriptor> handler = new ObservableBindingTrace.RecordHandler<PsiElement, ClassDescriptor>() {
@@ -640,11 +640,11 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             @Override
             public void handleRecord(WritableSlice<PsiElement, ClassDescriptor> slice, PsiElement declaration, final ClassDescriptor descriptor) {
                 if (slice == CLASS && declaration == expression.getObjectDeclaration()) {
-                    JetType defaultType = DeferredType.createRecursionIntolerant(components.globalContext.getStorageManager(),
-                                                                                 context.trace,
-                                                                                 new Function0<JetType>() {
+                    KtType defaultType = DeferredType.createRecursionIntolerant(components.globalContext.getStorageManager(),
+                                                                                context.trace,
+                                                                                new Function0<KtType>() {
                                                                                      @Override
-                                                                                     public JetType invoke() {
+                                                                                     public KtType invoke() {
                                                                                          return descriptor.getDefaultType();
                                                                                      }
                                                                                  });
@@ -660,9 +660,9 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                                                                 expression.getObjectDeclaration());
         temporaryTrace.commit();
         DataFlowInfo resultFlowInfo = context.dataFlowInfo;
-        for (JetDelegationSpecifier specifier: expression.getObjectDeclaration().getDelegationSpecifiers()) {
-            if (specifier instanceof JetDelegatorToSuperCall) {
-                JetDelegatorToSuperCall delegator = (JetDelegatorToSuperCall)specifier;
+        for (KtDelegationSpecifier specifier: expression.getObjectDeclaration().getDelegationSpecifiers()) {
+            if (specifier instanceof KtDelegatorToSuperCall) {
+                KtDelegatorToSuperCall delegator = (KtDelegatorToSuperCall)specifier;
                 JetTypeInfo delegatorTypeInfo = context.trace.get(EXPRESSION_TYPE_INFO, delegator.getCalleeExpression());
                 if (delegatorTypeInfo != null) {
                     resultFlowInfo = resultFlowInfo.and(delegatorTypeInfo.getDataFlowInfo());
@@ -681,12 +681,12 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Nullable
-    private JetType getCallableReferenceType(
-            @NotNull JetCallableReferenceExpression expression,
-            @Nullable JetType lhsType,
+    private KtType getCallableReferenceType(
+            @NotNull KtCallableReferenceExpression expression,
+            @Nullable KtType lhsType,
             @NotNull ExpressionTypingContext context
     ) {
-        JetSimpleNameExpression reference = expression.getCallableReference();
+        KtSimpleNameExpression reference = expression.getCallableReference();
 
         boolean[] resolved = new boolean[1];
         CallableDescriptor descriptor = CallableReferencesResolutionUtilsKt.resolveCallableReferenceTarget(
@@ -711,38 +711,38 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitQualifiedExpression(@NotNull JetQualifiedExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitQualifiedExpression(@NotNull KtQualifiedExpression expression, ExpressionTypingContext context) {
         CallExpressionResolver callExpressionResolver = components.callExpressionResolver;
         return callExpressionResolver.getQualifiedExpressionTypeInfo(expression, context);
     }
 
     @Override
-    public JetTypeInfo visitCallExpression(@NotNull JetCallExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitCallExpression(@NotNull KtCallExpression expression, ExpressionTypingContext context) {
         CallExpressionResolver callExpressionResolver = components.callExpressionResolver;
         return callExpressionResolver.getCallExpressionTypeInfo(expression, NO_RECEIVER, null, context);
     }
 
     @Override
-    public JetTypeInfo visitUnaryExpression(@NotNull JetUnaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
+    public JetTypeInfo visitUnaryExpression(@NotNull KtUnaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
         ExpressionTypingContext context = isUnaryExpressionDependentOnExpectedType(expression)
                 ? contextWithExpectedType
                 : contextWithExpectedType.replaceContextDependency(INDEPENDENT).replaceExpectedType(NO_EXPECTED_TYPE);
 
-        JetExpression baseExpression = expression.getBaseExpression();
+        KtExpression baseExpression = expression.getBaseExpression();
         if (baseExpression == null) return TypeInfoFactoryKt.noTypeInfo(context);
 
-        JetSimpleNameExpression operationSign = expression.getOperationReference();
+        KtSimpleNameExpression operationSign = expression.getOperationReference();
 
         IElementType operationType = operationSign.getReferencedNameElementType();
 
         // Special case for expr!!
-        if (operationType == JetTokens.EXCLEXCL) {
+        if (operationType == KtTokens.EXCLEXCL) {
             return visitExclExclExpression(expression, context);
         }
 
         // Type check the base expression
         JetTypeInfo typeInfo = facade.safeGetTypeInfo(baseExpression, context);
-        JetType type = ExpressionTypingUtils.safeGetType(typeInfo);
+        KtType type = ExpressionTypingUtils.safeGetType(typeInfo);
         ExpressionReceiver receiver = new ExpressionReceiver(baseExpression, type);
 
         Call call = CallMaker.makeCall(receiver, expression);
@@ -755,12 +755,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         }
 
         // a[i]++/-- takes special treatment because it is actually let j = i, arr = a in arr.set(j, a.get(j).inc())
-        if ((operationType == JetTokens.PLUSPLUS || operationType == JetTokens.MINUSMINUS) && baseExpression instanceof JetArrayAccessExpression) {
-            JetExpression stubExpression = ExpressionTypingUtils.createFakeExpressionOfType(baseExpression.getProject(), context.trace, "$e", type);
+        if ((operationType == KtTokens.PLUSPLUS || operationType == KtTokens.MINUSMINUS) && baseExpression instanceof KtArrayAccessExpression) {
+            KtExpression
+                    stubExpression = ExpressionTypingUtils.createFakeExpressionOfType(baseExpression.getProject(), context.trace, "$e", type);
             TemporaryBindingTrace temporaryBindingTrace = TemporaryBindingTrace
                     .create(context.trace, "trace to resolve array access set method for unary expression", expression);
             ExpressionTypingContext newContext = context.replaceBindingTrace(temporaryBindingTrace);
-            resolveArrayAccessSetMethod((JetArrayAccessExpression) baseExpression, stubExpression, newContext, context.trace);
+            resolveArrayAccessSetMethod((KtArrayAccessExpression) baseExpression, stubExpression, newContext, context.trace);
         }
 
         // Resolve the operation reference
@@ -772,27 +773,27 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         }
 
         // Computing the return type
-        JetType returnType = resolutionResults.getResultingDescriptor().getReturnType();
-        JetType result;
-        if (operationType == JetTokens.PLUSPLUS || operationType == JetTokens.MINUSMINUS) {
+        KtType returnType = resolutionResults.getResultingDescriptor().getReturnType();
+        KtType result;
+        if (operationType == KtTokens.PLUSPLUS || operationType == KtTokens.MINUSMINUS) {
             assert returnType != null : "returnType is null for " + resolutionResults.getResultingDescriptor();
             if (KotlinBuiltIns.isUnit(returnType)) {
                 result = ErrorUtils.createErrorType(components.builtIns.getUnit().getName().asString());
                 context.trace.report(INC_DEC_SHOULD_NOT_RETURN_UNIT.on(operationSign));
             }
             else {
-                JetType receiverType = receiver.getType();
-                if (!JetTypeChecker.DEFAULT.isSubtypeOf(returnType, receiverType)) {
+                KtType receiverType = receiver.getType();
+                if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(returnType, receiverType)) {
                     context.trace.report(RESULT_TYPE_MISMATCH.on(operationSign, name.asString(), receiverType, returnType));
                 }
                 else {
                     context.trace.record(BindingContext.VARIABLE_REASSIGNMENT, expression);
-                    JetExpression stubExpression = ExpressionTypingUtils.createFakeExpressionOfType(baseExpression.getProject(), context.trace, "$e", type);
+                    KtExpression stubExpression = ExpressionTypingUtils.createFakeExpressionOfType(baseExpression.getProject(), context.trace, "$e", type);
                     checkLValue(context.trace, context, baseExpression, stubExpression);
                 }
                 // x++ type is x type, but ++x type is x.inc() type
                 DataFlowValue receiverValue = DataFlowValueFactory.createDataFlowValue(call.getExplicitReceiver(), contextWithExpectedType);
-                if (expression instanceof JetPrefixExpression) {
+                if (expression instanceof KtPrefixExpression) {
                     result = returnType;
                 }
                 else {
@@ -819,11 +820,11 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                                           contextWithExpectedType.replaceDataFlowInfo(typeInfo.getDataFlowInfo()));
     }
 
-    private JetTypeInfo visitExclExclExpression(@NotNull JetUnaryExpression expression, @NotNull ExpressionTypingContext context) {
-        JetExpression baseExpression = expression.getBaseExpression();
+    private JetTypeInfo visitExclExclExpression(@NotNull KtUnaryExpression expression, @NotNull ExpressionTypingContext context) {
+        KtExpression baseExpression = expression.getBaseExpression();
         assert baseExpression != null;
-        JetSimpleNameExpression operationSign = expression.getOperationReference();
-        assert operationSign.getReferencedNameElementType() == JetTokens.EXCLEXCL;
+        KtSimpleNameExpression operationSign = expression.getOperationReference();
+        assert operationSign.getReferencedNameElementType() == KtTokens.EXCLEXCL;
 
         // TODO: something must be done for not to lose safe call chain information here
         // See also CallExpressionResolver.getSimpleNameExpressionTypeInfo, .getQualifiedExpressionTypeInfo
@@ -837,7 +838,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             return baseTypeInfo;
         }
         assert baseTypeInfo != null : "Base expression was not processed: " + expression;
-        JetType baseType = baseTypeInfo.getType();
+        KtType baseType = baseTypeInfo.getType();
         if (baseType == null) {
             return baseTypeInfo;
         }
@@ -849,7 +850,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             DataFlowValue value = createDataFlowValue(baseExpression, baseType, context);
             baseTypeInfo = baseTypeInfo.replaceDataFlowInfo(dataFlowInfo.disequate(value, DataFlowValue.nullValue(components.builtIns)));
         }
-        JetType resultingType = TypeUtils.makeNotNullable(baseType);
+        KtType resultingType = TypeUtils.makeNotNullable(baseType);
         if (context.contextDependency == DEPENDENT) {
             return baseTypeInfo.replaceType(resultingType);
         }
@@ -860,35 +861,35 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
     @Override
     public JetTypeInfo visitLabeledExpression(
-            @NotNull JetLabeledExpression expression, ExpressionTypingContext context
+            @NotNull KtLabeledExpression expression, ExpressionTypingContext context
     ) {
         return visitLabeledExpression(expression, context, false);
     }
 
     @NotNull
     public JetTypeInfo visitLabeledExpression(
-            @NotNull JetLabeledExpression expression,
+            @NotNull KtLabeledExpression expression,
             @NotNull ExpressionTypingContext context,
             boolean isStatement
     ) {
-        JetSimpleNameExpression labelExpression = expression.getTargetLabel();
+        KtSimpleNameExpression labelExpression = expression.getTargetLabel();
         if (labelExpression != null) {
             PsiElement labelIdentifier = labelExpression.getIdentifier();
             UnderscoreChecker.INSTANCE$.checkIdentifier(labelIdentifier, context.trace);
         }
-        JetExpression baseExpression = expression.getBaseExpression();
+        KtExpression baseExpression = expression.getBaseExpression();
         if (baseExpression == null) return TypeInfoFactoryKt.noTypeInfo(context);
 
         return facade.getTypeInfo(baseExpression, context, isStatement);
     }
 
-    private static boolean isKnownToBeNotNull(JetExpression expression, ExpressionTypingContext context) {
-        JetType type = context.trace.getType(expression);
+    private static boolean isKnownToBeNotNull(KtExpression expression, ExpressionTypingContext context) {
+        KtType type = context.trace.getType(expression);
         assert type != null : "This method is only supposed to be called when the type is not null";
         return isKnownToBeNotNull(expression, type, context);
     }
 
-    private static boolean isKnownToBeNotNull(JetExpression expression, JetType jetType, ExpressionTypingContext context) {
+    private static boolean isKnownToBeNotNull(KtExpression expression, KtType jetType, ExpressionTypingContext context) {
         DataFlowValue dataFlowValue = createDataFlowValue(expression, jetType, context);
         return !context.dataFlowInfo.getNullability(dataFlowValue).canBeNull();
     }
@@ -899,8 +900,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     public boolean checkLValue(
             @NotNull BindingTrace trace,
             @NotNull ExpressionTypingContext context,
-            @NotNull JetExpression expression,
-            @Nullable JetExpression rightHandSide
+            @NotNull KtExpression expression,
+            @Nullable KtExpression rightHandSide
     ) {
         return checkLValue(trace, context, expression, rightHandSide, false);
     }
@@ -908,14 +909,14 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     private boolean checkLValue(
             @NotNull BindingTrace trace,
             @NotNull ExpressionTypingContext context,
-            @NotNull JetExpression expressionWithParenthesis,
-            @Nullable JetExpression rightHandSide,
+            @NotNull KtExpression expressionWithParenthesis,
+            @Nullable KtExpression rightHandSide,
             boolean canBeThis
     ) {
-        JetExpression expression = JetPsiUtil.deparenthesize(expressionWithParenthesis);
-        if (expression instanceof JetArrayAccessExpression) {
-            JetArrayAccessExpression arrayAccessExpression = (JetArrayAccessExpression) expression;
-            JetExpression arrayExpression = arrayAccessExpression.getArrayExpression();
+        KtExpression expression = KtPsiUtil.deparenthesize(expressionWithParenthesis);
+        if (expression instanceof KtArrayAccessExpression) {
+            KtArrayAccessExpression arrayAccessExpression = (KtArrayAccessExpression) expression;
+            KtExpression arrayExpression = arrayAccessExpression.getArrayExpression();
             if (arrayExpression == null || rightHandSide == null) return false;
 
             TemporaryBindingTrace ignoreReportsTrace = TemporaryBindingTrace.create(trace, "Trace for checking set function");
@@ -924,13 +925,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             return info.getType() != null;
         }
 
-        if (canBeThis && expression instanceof JetThisExpression) return true;
+        if (canBeThis && expression instanceof KtThisExpression) return true;
         VariableDescriptor variable = BindingContextUtils.extractVariableDescriptorIfAny(trace.getBindingContext(), expression, true);
 
         boolean result = true;
-        JetExpression reportOn = expression != null ? expression : expressionWithParenthesis;
-        if (reportOn instanceof JetQualifiedExpression) {
-            JetExpression selector = ((JetQualifiedExpression) reportOn).getSelectorExpression();
+        KtExpression reportOn = expression != null ? expression : expressionWithParenthesis;
+        if (reportOn instanceof KtQualifiedExpression) {
+            KtExpression selector = ((KtQualifiedExpression) reportOn).getSelectorExpression();
             if (selector != null)
                 reportOn = selector;
         }
@@ -960,20 +961,20 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitBinaryExpression(@NotNull JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
+    public JetTypeInfo visitBinaryExpression(@NotNull KtBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
         ExpressionTypingContext context = isBinaryExpressionDependentOnExpectedType(expression)
                 ? contextWithExpectedType
                 : contextWithExpectedType.replaceContextDependency(INDEPENDENT).replaceExpectedType(NO_EXPECTED_TYPE);
 
-        JetSimpleNameExpression operationSign = expression.getOperationReference();
-        JetExpression left = expression.getLeft();
-        JetExpression right = expression.getRight();
+        KtSimpleNameExpression operationSign = expression.getOperationReference();
+        KtExpression left = expression.getLeft();
+        KtExpression right = expression.getRight();
         IElementType operationType = operationSign.getReferencedNameElementType();
 
         JetTypeInfo result;
 
         //Expressions that can depend on expected type
-        if (operationType == JetTokens.IDENTIFIER) {
+        if (operationType == KtTokens.IDENTIFIER) {
             Name referencedName = operationSign.getReferencedNameAsName();
             result = getTypeInfoForBinaryCall(referencedName, context, expression);
         }
@@ -981,13 +982,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             Name referencedName = OperatorConventions.BINARY_OPERATION_NAMES.get(operationType);
             result = getTypeInfoForBinaryCall(referencedName, context, expression);
         }
-        else if (operationType == JetTokens.ELVIS) {
+        else if (operationType == KtTokens.ELVIS) {
             //base expression of elvis operator is checked for 'type mismatch', so the whole expression shouldn't be checked
             return visitElvisExpression(expression, context);
         }
 
         //Expressions that don't depend on expected type
-        else if (operationType == JetTokens.EQ) {
+        else if (operationType == KtTokens.EQ) {
             result = visitAssignment(expression, context);
         }
         else if (OperatorConventions.ASSIGNMENT_OPERATIONS.containsKey(operationType)) {
@@ -1026,11 +1027,11 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     private JetTypeInfo visitEquality(
-            JetBinaryExpression expression,
+            KtBinaryExpression expression,
             ExpressionTypingContext context,
-            JetSimpleNameExpression operationSign,
-            final JetExpression left,
-            final JetExpression right
+            KtSimpleNameExpression operationSign,
+            final KtExpression left,
+            final KtExpression right
     ) {
         if (right == null || left == null) {
             ExpressionTypingUtils.getTypeInfoOrNullType(right, context, facade);
@@ -1050,7 +1051,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         traceInterpretingRightAsNullableAny.recordType(right, components.builtIns.getNullableAnyType());
 
         // Nothing? has no members, and `equals()` would be unresolved on it
-        JetType leftType = leftTypeInfo.getType();
+        KtType leftType = leftTypeInfo.getType();
         if (leftType != null && KotlinBuiltIns.isNothingOrNullableNothing(leftType)) {
             traceInterpretingRightAsNullableAny.recordType(left, components.builtIns.getNullableAnyType());
         }
@@ -1061,7 +1062,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                 expression,
                 receiver,
                 // semantically, a call to `==` is a safe call
-                new JetPsiFactory(expression.getProject()).createSafeCallNode(),
+                new KtPsiFactory(expression.getProject()).createSafeCallNode(),
                 operationSign,
                 Collections.singletonList(right)
         );
@@ -1103,15 +1104,15 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
     @NotNull
     private JetTypeInfo visitComparison(
-            @NotNull JetBinaryExpression expression,
+            @NotNull KtBinaryExpression expression,
             @NotNull ExpressionTypingContext context,
-            @NotNull JetSimpleNameExpression operationSign
+            @NotNull KtSimpleNameExpression operationSign
     ) {
         JetTypeInfo typeInfo = getTypeInfoForBinaryCall(OperatorNameConventions.COMPARE_TO, context, expression);
-        JetType compareToReturnType = typeInfo.getType();
-        JetType type = null;
+        KtType compareToReturnType = typeInfo.getType();
+        KtType type = null;
         if (compareToReturnType != null && !compareToReturnType.isError()) {
-            if (JetTypeChecker.DEFAULT.equalTypes(components.builtIns.getIntType(), compareToReturnType)) {
+            if (KotlinTypeChecker.DEFAULT.equalTypes(components.builtIns.getIntType(), compareToReturnType)) {
                 type = components.builtIns.getBooleanType();
             }
             else {
@@ -1124,17 +1125,17 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     @NotNull
     private JetTypeInfo visitBooleanOperationExpression(
             @Nullable IElementType operationType,
-            @Nullable JetExpression left,
-            @Nullable JetExpression right,
+            @Nullable KtExpression left,
+            @Nullable KtExpression right,
             @NotNull ExpressionTypingContext context
     ) {
-        JetType booleanType = components.builtIns.getBooleanType();
+        KtType booleanType = components.builtIns.getBooleanType();
         JetTypeInfo leftTypeInfo = getTypeInfoOrNullType(left, context.replaceExpectedType(booleanType), facade);
         DataFlowInfo dataFlowInfo = leftTypeInfo.getDataFlowInfo();
 
         LexicalWritableScope leftScope = newWritableScopeImpl(context, "Left scope of && or ||");
         // TODO: This gets computed twice: here and in extractDataFlowInfoFromCondition() for the whole condition
-        boolean isAnd = operationType == JetTokens.ANDAND;
+        boolean isAnd = operationType == KtTokens.ANDAND;
         DataFlowInfo flowInfoLeft = components.dataFlowAnalyzer.extractDataFlowInfoFromCondition(left, isAnd, context).and(dataFlowInfo);
         LexicalWritableScope rightScope = isAnd ? leftScope : newWritableScopeImpl(context, "Right scope of && or ||");
 
@@ -1148,12 +1149,12 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
     @NotNull
     private JetTypeInfo visitElvisExpression(
-            @NotNull JetBinaryExpression expression,
+            @NotNull KtBinaryExpression expression,
             @NotNull ExpressionTypingContext contextWithExpectedType
     ) {
         ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE);
-        JetExpression left = expression.getLeft();
-        JetExpression right = expression.getRight();
+        KtExpression left = expression.getLeft();
+        KtExpression right = expression.getRight();
 
         if (left == null || right == null) {
             getTypeInfoOrNullType(left, context, facade);
@@ -1169,7 +1170,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             if (leftTypeInfo == null) return TypeInfoFactoryKt.noTypeInfo(context);
         }
         assert leftTypeInfo != null : "Left expression was not processed: " + expression;
-        JetType leftType = leftTypeInfo.getType();
+        KtType leftType = leftTypeInfo.getType();
         if (leftType != null && isKnownToBeNotNull(left, leftType, context)) {
             context.trace.report(USELESS_ELVIS.on(expression, leftType));
         }
@@ -1180,7 +1181,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         }
         assert rightTypeInfo != null : "Right expression was not processed: " + expression;
         boolean loopBreakContinuePossible = leftTypeInfo.getJumpOutPossible() || rightTypeInfo.getJumpOutPossible();
-        JetType rightType = rightTypeInfo.getType();
+        KtType rightType = rightTypeInfo.getType();
 
         // Only left argument DFA is taken into account here: we cannot be sure that right argument is executed
         DataFlowInfo dataFlowInfo = resolvedCall.getDataFlowInfoForArguments().getInfo(call.getValueArguments().get(1));
@@ -1193,7 +1194,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                 dataFlowInfo = dataFlowInfo.disequate(leftValue, DataFlowValue.nullValue(components.builtIns));
             }
         }
-        JetType type = resolvedCall.getResultingDescriptor().getReturnType();
+        KtType type = resolvedCall.getResultingDescriptor().getReturnType();
         if (type == null || rightType == null) return TypeInfoFactoryKt.noTypeInfo(dataFlowInfo);
 
         // Sometimes return type for special call for elvis operator might be nullable,
@@ -1214,13 +1215,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
     @NotNull
     public JetTypeInfo checkInExpression(
-            @NotNull JetElement callElement,
-            @NotNull JetSimpleNameExpression operationSign,
+            @NotNull KtElement callElement,
+            @NotNull KtSimpleNameExpression operationSign,
             @NotNull ValueArgument leftArgument,
-            @Nullable JetExpression right,
+            @Nullable KtExpression right,
             @NotNull ExpressionTypingContext context
     ) {
-        JetExpression left = leftArgument.getArgumentExpression();
+        KtExpression left = leftArgument.getArgumentExpression();
         ExpressionTypingContext contextWithNoExpectedType = context.replaceExpectedType(NO_EXPECTED_TYPE);
         if (right == null) {
             if (left != null) facade.getTypeInfo(left, contextWithNoExpectedType);
@@ -1238,7 +1239,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                 CallMaker.makeCall(callElement, receiver, null, operationSign, Collections.singletonList(leftArgument)),
                 operationSign,
                 OperatorNameConventions.CONTAINS);
-        JetType containsType = OverloadResolutionResultsUtil.getResultingType(resolutionResult, context.contextDependency);
+        KtType containsType = OverloadResolutionResultsUtil.getResultingType(resolutionResult, context.contextDependency);
         ensureBooleanResult(operationSign, OperatorNameConventions.CONTAINS, containsType, context);
 
         if (left != null) {
@@ -1255,11 +1256,11 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
 
-    private boolean ensureBooleanResult(JetExpression operationSign, Name name, JetType resultType, ExpressionTypingContext context) {
+    private boolean ensureBooleanResult(KtExpression operationSign, Name name, KtType resultType, ExpressionTypingContext context) {
         return ensureBooleanResultWithCustomSubject(operationSign, resultType, "'" + name + "'", context);
     }
 
-    private boolean ensureBooleanResultWithCustomSubject(JetExpression operationSign, JetType resultType, String subjectName, ExpressionTypingContext context) {
+    private boolean ensureBooleanResultWithCustomSubject(KtExpression operationSign, KtType resultType, String subjectName, ExpressionTypingContext context) {
         if (resultType != null) {
             // TODO : Relax?
             if (!components.builtIns.isBooleanOrSubtype(resultType)) {
@@ -1270,16 +1271,16 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         return true;
     }
 
-    private void ensureNonemptyIntersectionOfOperandTypes(JetBinaryExpression expression, final ExpressionTypingContext context) {
-        JetExpression left = expression.getLeft();
+    private void ensureNonemptyIntersectionOfOperandTypes(KtBinaryExpression expression, final ExpressionTypingContext context) {
+        KtExpression left = expression.getLeft();
         if (left == null) return;
 
-        JetExpression right = expression.getRight();
+        KtExpression right = expression.getRight();
 
         // TODO : duplicated effort for == and !=
-        JetType leftType = facade.getTypeInfo(left, context).getType();
+        KtType leftType = facade.getTypeInfo(left, context).getType();
         if (leftType != null && right != null) {
-            JetType rightType = facade.getTypeInfo(right, context).getType();
+            KtType rightType = facade.getTypeInfo(right, context).getType();
 
             if (rightType != null) {
                 if (TypeIntersector.isIntersectionEmpty(leftType, rightType)) {
@@ -1287,9 +1288,9 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                 }
                 SenselessComparisonChecker.checkSenselessComparisonWithNull(
                         expression, left, right, context,
-                        new Function1<JetExpression, JetType>() {
+                        new Function1<KtExpression, KtType>() {
                             @Override
-                            public JetType invoke(JetExpression expression) {
+                            public KtType invoke(KtExpression expression) {
                                 return facade.getTypeInfo(expression, context).getType();
                             }
                         },
@@ -1304,24 +1305,24 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @NotNull
-    private JetTypeInfo visitAssignmentOperation(JetBinaryExpression expression, ExpressionTypingContext context) {
+    private JetTypeInfo visitAssignmentOperation(KtBinaryExpression expression, ExpressionTypingContext context) {
         return assignmentIsNotAnExpressionError(expression, context);
     }
 
     @NotNull
-    private JetTypeInfo visitAssignment(JetBinaryExpression expression, ExpressionTypingContext context) {
+    private JetTypeInfo visitAssignment(KtBinaryExpression expression, ExpressionTypingContext context) {
         return assignmentIsNotAnExpressionError(expression, context);
     }
 
     @NotNull
-    private JetTypeInfo assignmentIsNotAnExpressionError(JetBinaryExpression expression, ExpressionTypingContext context) {
+    private JetTypeInfo assignmentIsNotAnExpressionError(KtBinaryExpression expression, ExpressionTypingContext context) {
         facade.checkStatementType(expression, context);
         context.trace.report(ASSIGNMENT_IN_EXPRESSION_CONTEXT.on(expression));
         return TypeInfoFactoryKt.noTypeInfo(context);
     }
 
     @Override
-    public JetTypeInfo visitArrayAccessExpression(@NotNull JetArrayAccessExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitArrayAccessExpression(@NotNull KtArrayAccessExpression expression, ExpressionTypingContext context) {
         return components.dataFlowAnalyzer.checkType(resolveArrayAccessGetMethod(expression, context), expression, context);
     }
 
@@ -1329,9 +1330,9 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     public JetTypeInfo getTypeInfoForBinaryCall(
             @NotNull Name name,
             @NotNull ExpressionTypingContext context,
-            @NotNull JetBinaryExpression binaryExpression
+            @NotNull KtBinaryExpression binaryExpression
     ) {
-        JetExpression left = binaryExpression.getLeft();
+        KtExpression left = binaryExpression.getLeft();
         JetTypeInfo typeInfo;
         if (left != null) {
             //left here is a receiver, so it doesn't depend on expected type
@@ -1361,38 +1362,38 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitDeclaration(@NotNull JetDeclaration dcl, ExpressionTypingContext context) {
+    public JetTypeInfo visitDeclaration(@NotNull KtDeclaration dcl, ExpressionTypingContext context) {
         context.trace.report(DECLARATION_IN_ILLEGAL_CONTEXT.on(dcl));
         return TypeInfoFactoryKt.noTypeInfo(context);
     }
 
     @Override
-    public JetTypeInfo visitRootPackageExpression(@NotNull JetRootPackageExpression expression, ExpressionTypingContext context) {
-        if (!JetPsiUtil.isLHSOfDot(expression)) {
+    public JetTypeInfo visitRootPackageExpression(@NotNull KtRootPackageExpression expression, ExpressionTypingContext context) {
+        if (!KtPsiUtil.isLHSOfDot(expression)) {
             context.trace.report(PACKAGE_IS_NOT_AN_EXPRESSION.on(expression));
         }
         return TypeInfoFactoryKt.noTypeInfo(context);
     }
 
     @Override
-    public JetTypeInfo visitStringTemplateExpression(@NotNull JetStringTemplateExpression expression, ExpressionTypingContext contextWithExpectedType) {
+    public JetTypeInfo visitStringTemplateExpression(@NotNull KtStringTemplateExpression expression, ExpressionTypingContext contextWithExpectedType) {
         final ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT);
 
         checkStringPrefixAndSuffix(expression, context);
 
-        class StringTemplateVisitor extends JetVisitorVoid {
+        class StringTemplateVisitor extends KtVisitorVoid {
             private JetTypeInfo typeInfo = TypeInfoFactoryKt.noTypeInfo(context);
 
             @Override
-            public void visitStringTemplateEntryWithExpression(@NotNull JetStringTemplateEntryWithExpression entry) {
-                JetExpression entryExpression = entry.getExpression();
+            public void visitStringTemplateEntryWithExpression(@NotNull KtStringTemplateEntryWithExpression entry) {
+                KtExpression entryExpression = entry.getExpression();
                 if (entryExpression != null) {
                     typeInfo = facade.getTypeInfo(entryExpression, context.replaceDataFlowInfo(typeInfo.getDataFlowInfo()));
                 }
             }
 
             @Override
-            public void visitEscapeStringTemplateEntry(@NotNull JetEscapeStringTemplateEntry entry) {
+            public void visitEscapeStringTemplateEntry(@NotNull KtEscapeStringTemplateEntry entry) {
                 CompileTimeConstantChecker.CharacterWithDiagnostic value = CompileTimeConstantChecker.escapedStringToCharacter(entry.getText(), entry);
                 Diagnostic diagnostic = value.getDiagnostic();
                 if (diagnostic != null) {
@@ -1401,7 +1402,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             }
         }
         StringTemplateVisitor visitor = new StringTemplateVisitor();
-        for (JetStringTemplateEntry entry : expression.getEntries()) {
+        for (KtStringTemplateEntry entry : expression.getEntries()) {
             entry.accept(visitor);
         }
         components.constantExpressionEvaluator.evaluateExpression(expression, context.trace, contextWithExpectedType.expectedType);
@@ -1428,18 +1429,18 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         return elementType == IDENTIFIER ||
                elementType == INTEGER_LITERAL ||
                elementType == FLOAT_LITERAL ||
-               elementType instanceof JetKeywordToken;
+               elementType instanceof KtKeywordToken;
     }
 
     @Override
-    public JetTypeInfo visitAnnotatedExpression(@NotNull JetAnnotatedExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitAnnotatedExpression(@NotNull KtAnnotatedExpression expression, ExpressionTypingContext context) {
         return visitAnnotatedExpression(expression, context, false);
     }
 
-    public JetTypeInfo visitAnnotatedExpression(JetAnnotatedExpression expression, ExpressionTypingContext context, boolean isStatement) {
+    public JetTypeInfo visitAnnotatedExpression(KtAnnotatedExpression expression, ExpressionTypingContext context, boolean isStatement) {
         components.annotationResolver.resolveAnnotationsWithArguments(context.scope, expression.getAnnotationEntries(), context.trace);
 
-        JetExpression baseExpression = expression.getBaseExpression();
+        KtExpression baseExpression = expression.getBaseExpression();
         if (baseExpression == null) {
             return TypeInfoFactoryKt.noTypeInfo(context);
         }
@@ -1447,34 +1448,34 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitJetElement(@NotNull JetElement element, ExpressionTypingContext context) {
+    public JetTypeInfo visitJetElement(@NotNull KtElement element, ExpressionTypingContext context) {
         context.trace.report(UNSUPPORTED.on(element, getClass().getCanonicalName()));
         return TypeInfoFactoryKt.noTypeInfo(context);
     }
 
     @NotNull
-    /*package*/ JetTypeInfo resolveArrayAccessSetMethod(@NotNull JetArrayAccessExpression arrayAccessExpression, @NotNull JetExpression rightHandSide, @NotNull ExpressionTypingContext context, @NotNull BindingTrace traceForResolveResult) {
+    /*package*/ JetTypeInfo resolveArrayAccessSetMethod(@NotNull KtArrayAccessExpression arrayAccessExpression, @NotNull KtExpression rightHandSide, @NotNull ExpressionTypingContext context, @NotNull BindingTrace traceForResolveResult) {
         return resolveArrayAccessSpecialMethod(arrayAccessExpression, rightHandSide, context, traceForResolveResult, false);
     }
 
     @NotNull
-    /*package*/ JetTypeInfo resolveArrayAccessGetMethod(@NotNull JetArrayAccessExpression arrayAccessExpression, @NotNull ExpressionTypingContext context) {
+    /*package*/ JetTypeInfo resolveArrayAccessGetMethod(@NotNull KtArrayAccessExpression arrayAccessExpression, @NotNull ExpressionTypingContext context) {
         return resolveArrayAccessSpecialMethod(arrayAccessExpression, null, context, context.trace, true);
     }
 
     @NotNull
-    private JetTypeInfo resolveArrayAccessSpecialMethod(@NotNull JetArrayAccessExpression arrayAccessExpression,
-                                                        @Nullable JetExpression rightHandSide, //only for 'set' method
+    private JetTypeInfo resolveArrayAccessSpecialMethod(@NotNull KtArrayAccessExpression arrayAccessExpression,
+                                                        @Nullable KtExpression rightHandSide, //only for 'set' method
                                                         @NotNull ExpressionTypingContext oldContext,
                                                         @NotNull BindingTrace traceForResolveResult,
                                                         boolean isGet) {
-        JetExpression arrayExpression = arrayAccessExpression.getArrayExpression();
+        KtExpression arrayExpression = arrayAccessExpression.getArrayExpression();
         if (arrayExpression == null) return TypeInfoFactoryKt.noTypeInfo(oldContext);
 
 
         JetTypeInfo arrayTypeInfo = facade.safeGetTypeInfo(arrayExpression, oldContext.replaceExpectedType(NO_EXPECTED_TYPE)
                 .replaceContextDependency(INDEPENDENT));
-        JetType arrayType = ExpressionTypingUtils.safeGetType(arrayTypeInfo);
+        KtType arrayType = ExpressionTypingUtils.safeGetType(arrayTypeInfo);
 
         ExpressionTypingContext context = oldContext.replaceDataFlowInfo(arrayTypeInfo.getDataFlowInfo());
         ExpressionReceiver receiver = new ExpressionReceiver(arrayExpression, arrayType);
@@ -1486,7 +1487,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         OverloadResolutionResults<FunctionDescriptor> functionResults = components.callResolver.resolveCallWithGivenName(
                 context, call, arrayAccessExpression, Name.identifier(isGet ? "get" : "set"));
 
-        List<JetExpression> indices = arrayAccessExpression.getIndexExpressions();
+        List<KtExpression> indices = arrayAccessExpression.getIndexExpressions();
         // The accumulated data flow info of all index expressions is saved on the last index
         JetTypeInfo resultTypeInfo = arrayTypeInfo;
         if (!indices.isEmpty()) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java
index 116406c992d..555babeb892 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
@@ -48,7 +48,7 @@ import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionCandidate;
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy;
 import org.jetbrains.kotlin.resolve.calls.util.CallMaker;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.kotlin.types.Variance;
 
@@ -110,12 +110,12 @@ public class ControlStructureTypingUtils {
                 function, Annotations.Companion.getEMPTY(), false, Variance.INVARIANT,
                 Name.identifier("<TYPE-PARAMETER-FOR-" + constructionName + "-RESOLVE>"), 0);
 
-        JetType type = typeParameter.getDefaultType();
-        JetType nullableType = TypeUtils.makeNullable(type);
+        KtType type = typeParameter.getDefaultType();
+        KtType nullableType = TypeUtils.makeNullable(type);
 
         List<ValueParameterDescriptor> valueParameters = new ArrayList<ValueParameterDescriptor>(argumentNames.size());
         for (int i = 0; i < argumentNames.size(); i++) {
-            JetType argumentType = isArgumentNullable.get(i) ? nullableType : type;
+            KtType argumentType = isArgumentNullable.get(i) ? nullableType : type;
             ValueParameterDescriptorImpl valueParameter = new ValueParameterDescriptorImpl(
                     function, null, i, Annotations.Companion.getEMPTY(), Name.identifier(argumentNames.get(i)),
                     argumentType,
@@ -181,12 +181,12 @@ public class ControlStructureTypingUtils {
     }
 
     /*package*/ static Call createCallForSpecialConstruction(
-            @NotNull final JetExpression expression,
-            @NotNull final JetExpression calleeExpression,
-            @NotNull List<? extends JetExpression> arguments
+            @NotNull final KtExpression expression,
+            @NotNull final KtExpression calleeExpression,
+            @NotNull List<? extends KtExpression> arguments
     ) {
         final List<ValueArgument> valueArguments = Lists.newArrayList();
-        for (JetExpression argument : arguments) {
+        for (KtExpression argument : arguments) {
             valueArguments.add(CallMaker.makeValueArgument(argument));
         }
         return new Call() {
@@ -210,13 +210,13 @@ public class ControlStructureTypingUtils {
 
             @Nullable
             @Override
-            public JetExpression getCalleeExpression() {
+            public KtExpression getCalleeExpression() {
                 return calleeExpression;
             }
 
             @Nullable
             @Override
-            public JetValueArgumentList getValueArgumentList() {
+            public KtValueArgumentList getValueArgumentList() {
                 return null;
             }
 
@@ -234,19 +234,19 @@ public class ControlStructureTypingUtils {
 
             @NotNull
             @Override
-            public List<JetTypeProjection> getTypeArguments() {
+            public List<KtTypeProjection> getTypeArguments() {
                 return Collections.emptyList();
             }
 
             @Nullable
             @Override
-            public JetTypeArgumentList getTypeArgumentList() {
+            public KtTypeArgumentList getTypeArgumentList() {
                 return null;
             }
 
             @NotNull
             @Override
-            public JetElement getCallElement() {
+            public KtElement getCallElement() {
                 return expression;
             }
 
@@ -266,9 +266,9 @@ public class ControlStructureTypingUtils {
     ) {
         class CheckTypeContext {
             public BindingTrace trace;
-            public JetType expectedType;
+            public KtType expectedType;
 
-            CheckTypeContext(@NotNull BindingTrace trace, @NotNull JetType expectedType) {
+            CheckTypeContext(@NotNull BindingTrace trace, @NotNull KtType expectedType) {
                 this.trace = trace;
                 this.expectedType = expectedType;
             }
@@ -279,9 +279,9 @@ public class ControlStructureTypingUtils {
             }
         }
 
-        final JetVisitor<Boolean, CheckTypeContext> checkTypeVisitor = new JetVisitor<Boolean, CheckTypeContext>() {
+        final KtVisitor<Boolean, CheckTypeContext> checkTypeVisitor = new KtVisitor<Boolean, CheckTypeContext>() {
 
-            private boolean checkExpressionType(@NotNull JetExpression expression, CheckTypeContext c) {
+            private boolean checkExpressionType(@NotNull KtExpression expression, CheckTypeContext c) {
                 JetTypeInfo typeInfo = BindingContextUtils.getRecordedTypeInfo(expression, c.trace.getBindingContext());
                 if (typeInfo == null) return false;
 
@@ -298,13 +298,13 @@ public class ControlStructureTypingUtils {
                 return hasError.get();
             }
 
-            private boolean checkExpressionTypeRecursively(@Nullable JetExpression expression, CheckTypeContext c) {
+            private boolean checkExpressionTypeRecursively(@Nullable KtExpression expression, CheckTypeContext c) {
                 if (expression == null) return false;
                 return expression.accept(this, c);
             }
 
             private boolean checkSubExpressions(
-                    JetExpression firstSub, JetExpression secondSub, JetExpression expression,
+                    KtExpression firstSub, KtExpression secondSub, KtExpression expression,
                     CheckTypeContext firstContext, CheckTypeContext secondContext, CheckTypeContext context
             ) {
                 boolean errorWasReported = checkExpressionTypeRecursively(firstSub, firstContext);
@@ -313,9 +313,9 @@ public class ControlStructureTypingUtils {
             }
 
             @Override
-            public Boolean visitIfExpression(@NotNull JetIfExpression ifExpression, CheckTypeContext c) {
-                JetExpression thenBranch = ifExpression.getThen();
-                JetExpression elseBranch = ifExpression.getElse();
+            public Boolean visitIfExpression(@NotNull KtIfExpression ifExpression, CheckTypeContext c) {
+                KtExpression thenBranch = ifExpression.getThen();
+                KtExpression elseBranch = ifExpression.getElse();
                 if (thenBranch == null || elseBranch == null) {
                     return checkExpressionType(ifExpression, c);
                 }
@@ -323,11 +323,11 @@ public class ControlStructureTypingUtils {
             }
 
             @Override
-            public Boolean visitBlockExpression(@NotNull JetBlockExpression expression, CheckTypeContext c) {
+            public Boolean visitBlockExpression(@NotNull KtBlockExpression expression, CheckTypeContext c) {
                 if (expression.getStatements().isEmpty()) {
                     return checkExpressionType(expression, c);
                 }
-                JetExpression lastStatement = JetPsiUtil.getLastStatementInABlock(expression);
+                KtExpression lastStatement = KtPsiUtil.getLastStatementInABlock(expression);
                 if (lastStatement != null) {
                     return checkExpressionTypeRecursively(lastStatement, c);
                 }
@@ -335,16 +335,16 @@ public class ControlStructureTypingUtils {
             }
 
             @Override
-            public Boolean visitPostfixExpression(@NotNull JetPostfixExpression expression, CheckTypeContext c) {
-                if (expression.getOperationReference().getReferencedNameElementType() == JetTokens.EXCLEXCL) {
+            public Boolean visitPostfixExpression(@NotNull KtPostfixExpression expression, CheckTypeContext c) {
+                if (expression.getOperationReference().getReferencedNameElementType() == KtTokens.EXCLEXCL) {
                     return checkExpressionTypeRecursively(expression.getBaseExpression(), c.makeTypeNullable());
                 }
                 return super.visitPostfixExpression(expression, c);
             }
 
             @Override
-            public Boolean visitBinaryExpression(@NotNull JetBinaryExpression expression, CheckTypeContext c) {
-                if (expression.getOperationReference().getReferencedNameElementType() == JetTokens.ELVIS) {
+            public Boolean visitBinaryExpression(@NotNull KtBinaryExpression expression, CheckTypeContext c) {
+                if (expression.getOperationReference().getReferencedNameElementType() == KtTokens.ELVIS) {
 
                     return checkSubExpressions(expression.getLeft(), expression.getRight(), expression, c.makeTypeNullable(), c, c);
                 }
@@ -352,7 +352,7 @@ public class ControlStructureTypingUtils {
             }
 
             @Override
-            public Boolean visitExpression(@NotNull JetExpression expression, CheckTypeContext c) {
+            public Boolean visitExpression(@NotNull KtExpression expression, CheckTypeContext c) {
                 return checkExpressionType(expression, c);
             }
         };
@@ -388,13 +388,13 @@ public class ControlStructureTypingUtils {
                 if (status.hasErrorInConstrainingTypes() || status.hasUnknownParameters()) {
                     return;
                 }
-                JetExpression expression = (JetExpression) call.getCallElement();
+                KtExpression expression = (KtExpression) call.getCallElement();
                 if (status.hasOnlyErrorsDerivedFrom(EXPECTED_TYPE_POSITION) || status.hasConflictingConstraints()
                         || status.hasTypeInferenceIncorporationError()) { // todo after KT-... remove this line
                     expression.accept(checkTypeVisitor, new CheckTypeContext(trace, data.expectedType));
                     return;
                 }
-                JetDeclaration parentDeclaration = PsiTreeUtil.getParentOfType(expression, JetNamedDeclaration.class);
+                KtDeclaration parentDeclaration = PsiTreeUtil.getParentOfType(expression, KtNamedDeclaration.class);
                 logError("Expression: " + (parentDeclaration != null ? parentDeclaration.getText() : expression.getText()) +
                          "\nConstraint system status: \n" + ConstraintsUtil.getDebugMessageForStatus(status));
             }
@@ -511,14 +511,14 @@ public class ControlStructureTypingUtils {
 
         @Override
         public void unsafeCall(
-                @NotNull BindingTrace trace, @NotNull JetType type, boolean isCallForImplicitInvoke
+                @NotNull BindingTrace trace, @NotNull KtType type, boolean isCallForImplicitInvoke
         ) {
             logError();
         }
 
         @Override
         public void unnecessarySafeCall(
-                @NotNull BindingTrace trace, @NotNull JetType type
+                @NotNull BindingTrace trace, @NotNull KtType type
         ) {
             logError();
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java
index 42ad71b9edb..a3494e7fc27 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java
@@ -39,9 +39,9 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver;
 import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
 import org.jetbrains.kotlin.types.CommonSupertypes;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt;
 
 import java.util.ArrayList;
@@ -65,11 +65,11 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @NotNull
-    private DataFlowInfo checkCondition(@NotNull LexicalScope scope, @Nullable JetExpression condition, ExpressionTypingContext context) {
+    private DataFlowInfo checkCondition(@NotNull LexicalScope scope, @Nullable KtExpression condition, ExpressionTypingContext context) {
         if (condition != null) {
             JetTypeInfo typeInfo = facade.getTypeInfo(condition, context.replaceScope(scope)
                     .replaceExpectedType(components.builtIns.getBooleanType()).replaceContextDependency(INDEPENDENT));
-            JetType conditionType = typeInfo.getType();
+            KtType conditionType = typeInfo.getType();
 
             if (conditionType != null && !components.builtIns.isBooleanOrSubtype(conditionType)) {
                 context.trace.report(TYPE_MISMATCH_IN_CONDITION.on(condition, conditionType));
@@ -84,17 +84,17 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
 
 
     @Override
-    public JetTypeInfo visitIfExpression(@NotNull JetIfExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitIfExpression(@NotNull KtIfExpression expression, ExpressionTypingContext context) {
         return visitIfExpression(expression, context, false);
     }
 
-    public JetTypeInfo visitIfExpression(JetIfExpression ifExpression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
+    public JetTypeInfo visitIfExpression(KtIfExpression ifExpression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
         ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE);
-        JetExpression condition = ifExpression.getCondition();
+        KtExpression condition = ifExpression.getCondition();
         DataFlowInfo conditionDataFlowInfo = checkCondition(context.scope, condition, context);
 
-        JetExpression elseBranch = ifExpression.getElse();
-        JetExpression thenBranch = ifExpression.getThen();
+        KtExpression elseBranch = ifExpression.getElse();
+        KtExpression thenBranch = ifExpression.getThen();
 
         LexicalWritableScope thenScope = newWritableScopeImpl(context, "Then scope");
         LexicalWritableScope elseScope = newWritableScopeImpl(context, "Else scope");
@@ -121,9 +121,9 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
             return getTypeInfoWhenOnlyOneBranchIsPresent(
                     elseBranch, elseScope, elseInfo, thenInfo, contextWithExpectedType, ifExpression, isStatement);
         }
-        JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(ifExpression);
-        JetBlockExpression thenBlock = psiFactory.wrapInABlockWrapper(thenBranch);
-        JetBlockExpression elseBlock = psiFactory.wrapInABlockWrapper(elseBranch);
+        KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(ifExpression);
+        KtBlockExpression thenBlock = psiFactory.wrapInABlockWrapper(thenBranch);
+        KtBlockExpression elseBlock = psiFactory.wrapInABlockWrapper(elseBranch);
         Call callForIf = createCallForSpecialConstruction(ifExpression, ifExpression, Lists.newArrayList(thenBlock, elseBlock));
         MutableDataFlowInfoForArguments dataFlowInfoForArguments =
                     createDataFlowInfoForArgumentsForIfCall(callForIf, thenInfo, elseInfo);
@@ -139,8 +139,8 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
         assert elseTypeInfo != null : "'Else' branch of if expression  was not processed: " + ifExpression;
         boolean loopBreakContinuePossible = thenTypeInfo.getJumpOutPossible() || elseTypeInfo.getJumpOutPossible();
 
-        JetType thenType = thenTypeInfo.getType();
-        JetType elseType = elseTypeInfo.getType();
+        KtType thenType = thenTypeInfo.getType();
+        KtType elseType = elseTypeInfo.getType();
         DataFlowInfo thenDataFlowInfo = thenTypeInfo.getDataFlowInfo();
         DataFlowInfo elseDataFlowInfo = elseTypeInfo.getDataFlowInfo();
 
@@ -161,7 +161,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
             resultDataFlowInfo = thenDataFlowInfo.or(elseDataFlowInfo);
         }
 
-        JetType resultType = resolvedCall.getResultingDescriptor().getReturnType();
+        KtType resultType = resolvedCall.getResultingDescriptor().getReturnType();
         // If break or continue was possible, take condition check info as the jump info
         return TypeInfoFactoryKt
                 .createTypeInfo(components.dataFlowAnalyzer.checkImplicitCast(resultType, ifExpression, contextWithExpectedType, isStatement),
@@ -170,19 +170,19 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
 
     @NotNull
     private JetTypeInfo getTypeInfoWhenOnlyOneBranchIsPresent(
-            @NotNull JetExpression presentBranch,
+            @NotNull KtExpression presentBranch,
             @NotNull LexicalWritableScope presentScope,
             @NotNull DataFlowInfo presentInfo,
             @NotNull DataFlowInfo otherInfo,
             @NotNull ExpressionTypingContext context,
-            @NotNull JetIfExpression ifExpression,
+            @NotNull KtIfExpression ifExpression,
             boolean isStatement
     ) {
         ExpressionTypingContext newContext = context.replaceDataFlowInfo(presentInfo).replaceExpectedType(NO_EXPECTED_TYPE)
                 .replaceContextDependency(INDEPENDENT);
         JetTypeInfo typeInfo = components.expressionTypingServices.getBlockReturnedTypeWithWritableScope(
                 presentScope, Collections.singletonList(presentBranch), CoercionStrategy.NO_COERCION, newContext);
-        JetType type = typeInfo.getType();
+        KtType type = typeInfo.getType();
         DataFlowInfo dataFlowInfo;
         if (type != null && KotlinBuiltIns.isNothing(type)) {
             dataFlowInfo = otherInfo;
@@ -202,11 +202,11 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitWhileExpression(@NotNull JetWhileExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitWhileExpression(@NotNull KtWhileExpression expression, ExpressionTypingContext context) {
         return visitWhileExpression(expression, context, false);
     }
 
-    public JetTypeInfo visitWhileExpression(JetWhileExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
+    public JetTypeInfo visitWhileExpression(KtWhileExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
         if (!isStatement) return components.dataFlowAnalyzer.illegalStatementType(expression, contextWithExpectedType, facade);
 
         ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(
@@ -217,11 +217,11 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
                 loopVisitor.clearDataFlowInfoForAssignedLocalVariables(context.dataFlowInfo)
         );
 
-        JetExpression condition = expression.getCondition();
+        KtExpression condition = expression.getCondition();
         // Extract data flow info from condition itself without taking value into account
         DataFlowInfo dataFlowInfo = checkCondition(context.scope, condition, context);
 
-        JetExpression body = expression.getBody();
+        KtExpression body = expression.getBody();
         JetTypeInfo bodyTypeInfo;
         DataFlowInfo conditionInfo = components.dataFlowAnalyzer.extractDataFlowInfoFromCondition(condition, true, context).and(dataFlowInfo);
         if (body != null) {
@@ -243,7 +243,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
         // In this case we must record data flow information at the nearest break / continue and
         // .and it with entrance data flow information, because while body until break is executed at least once in this case
         // See KT-6284
-        if (body != null && JetPsiUtil.isTrueConstant(condition)) {
+        if (body != null && KtPsiUtil.isTrueConstant(condition)) {
             // We should take data flow info from the first jump point,
             // but without affecting changing variables
             dataFlowInfo = dataFlowInfo.and(loopVisitor.clearDataFlowInfoForAssignedLocalVariables(bodyTypeInfo.getJumpFlowInfo()));
@@ -253,14 +253,14 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
                 .replaceDataFlowInfo(dataFlowInfo);
     }
 
-    private boolean containsJumpOutOfLoop(final JetLoopExpression loopExpression, final ExpressionTypingContext context) {
+    private boolean containsJumpOutOfLoop(final KtLoopExpression loopExpression, final ExpressionTypingContext context) {
         final boolean[] result = new boolean[1];
         result[0] = false;
         //todo breaks in inline function literals
-        loopExpression.accept(new JetTreeVisitor<List<JetLoopExpression>>() {
+        loopExpression.accept(new KtTreeVisitor<List<KtLoopExpression>>() {
             @Override
-            public Void visitBreakExpression(@NotNull JetBreakExpression breakExpression, List<JetLoopExpression> outerLoops) {
-                JetSimpleNameExpression targetLabel = breakExpression.getTargetLabel();
+            public Void visitBreakExpression(@NotNull KtBreakExpression breakExpression, List<KtLoopExpression> outerLoops) {
+                KtSimpleNameExpression targetLabel = breakExpression.getTargetLabel();
                 PsiElement element = targetLabel != null ? context.trace.get(LABEL_TARGET, targetLabel) : null;
                 if (element == loopExpression || (targetLabel == null && outerLoops.get(outerLoops.size() - 1) == loopExpression)) {
                     result[0] = true;
@@ -269,12 +269,12 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
             }
 
             @Override
-            public Void visitContinueExpression(@NotNull JetContinueExpression expression, List<JetLoopExpression> outerLoops) {
+            public Void visitContinueExpression(@NotNull KtContinueExpression expression, List<KtLoopExpression> outerLoops) {
                 // continue@someOuterLoop is also considered as break
-                JetSimpleNameExpression targetLabel = expression.getTargetLabel();
+                KtSimpleNameExpression targetLabel = expression.getTargetLabel();
                 if (targetLabel != null) {
                     PsiElement element = context.trace.get(LABEL_TARGET, targetLabel);
-                    if (element instanceof JetLoopExpression && !outerLoops.contains(element)) {
+                    if (element instanceof KtLoopExpression && !outerLoops.contains(element)) {
                         result[0] = true;
                     }
                 }
@@ -282,8 +282,8 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
             }
 
             @Override
-            public Void visitLoopExpression(@NotNull JetLoopExpression loopExpression, List<JetLoopExpression> outerLoops) {
-                List<JetLoopExpression> newOuterLoops = Lists.newArrayList(outerLoops);
+            public Void visitLoopExpression(@NotNull KtLoopExpression loopExpression, List<KtLoopExpression> outerLoops) {
+                List<KtLoopExpression> newOuterLoops = Lists.newArrayList(outerLoops);
                 newOuterLoops.add(loopExpression);
                 return super.visitLoopExpression(loopExpression, newOuterLoops);
             }
@@ -293,16 +293,16 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitDoWhileExpression(@NotNull JetDoWhileExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitDoWhileExpression(@NotNull KtDoWhileExpression expression, ExpressionTypingContext context) {
         return visitDoWhileExpression(expression, context, false);
     }
 
-    public JetTypeInfo visitDoWhileExpression(JetDoWhileExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
+    public JetTypeInfo visitDoWhileExpression(KtDoWhileExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
         if (!isStatement) return components.dataFlowAnalyzer.illegalStatementType(expression, contextWithExpectedType, facade);
 
         ExpressionTypingContext context =
                 contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT);
-        JetExpression body = expression.getBody();
+        KtExpression body = expression.getBody();
         LexicalScope conditionScope = context.scope;
         // Preliminary analysis
         PreliminaryLoopVisitor loopVisitor = PreliminaryLoopVisitor.visitLoop(expression);
@@ -313,16 +313,16 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
         // .and it with entrance data flow information, because do-while body is executed at least once
         // See KT-6283
         JetTypeInfo bodyTypeInfo;
-        if (body instanceof JetFunctionLiteralExpression) {
+        if (body instanceof KtFunctionLiteralExpression) {
             // As a matter of fact, function literal is always unused at this point
             bodyTypeInfo = facade.getTypeInfo(body, context.replaceScope(context.scope));
         }
         else if (body != null) {
             LexicalWritableScope writableScope = newWritableScopeImpl(context, "do..while body scope");
             conditionScope = writableScope;
-            List<JetExpression> block;
-            if (body instanceof JetBlockExpression) {
-                block = ((JetBlockExpression)body).getStatements();
+            List<KtExpression> block;
+            if (body instanceof KtBlockExpression) {
+                block = ((KtBlockExpression)body).getStatements();
             }
             else {
                 block = Collections.singletonList(body);
@@ -333,7 +333,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
         else {
             bodyTypeInfo = TypeInfoFactoryKt.noTypeInfo(context);
         }
-        JetExpression condition = expression.getCondition();
+        KtExpression condition = expression.getCondition();
         DataFlowInfo conditionDataFlowInfo = checkCondition(conditionScope, condition, context);
         DataFlowInfo dataFlowInfo;
         // Without jumps out, condition is entered and false, with jumps out, we know nothing about it
@@ -359,11 +359,11 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitForExpression(@NotNull JetForExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitForExpression(@NotNull KtForExpression expression, ExpressionTypingContext context) {
         return visitForExpression(expression, context, false);
     }
 
-    public JetTypeInfo visitForExpression(JetForExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
+    public JetTypeInfo visitForExpression(KtForExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
         if (!isStatement) return components.dataFlowAnalyzer.illegalStatementType(expression, contextWithExpectedType, facade);
 
         ExpressionTypingContext context =
@@ -372,8 +372,8 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
         PreliminaryLoopVisitor loopVisitor = PreliminaryLoopVisitor.visitLoop(expression);
         context = context.replaceDataFlowInfo(loopVisitor.clearDataFlowInfoForAssignedLocalVariables(context.dataFlowInfo));
 
-        JetExpression loopRange = expression.getLoopRange();
-        JetType expectedParameterType = null;
+        KtExpression loopRange = expression.getLoopRange();
+        KtType expectedParameterType = null;
         JetTypeInfo loopRangeInfo;
         if (loopRange != null) {
             ExpressionReceiver loopRangeReceiver = getExpressionReceiver(facade, loopRange, context.replaceScope(context.scope));
@@ -388,7 +388,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
 
         LexicalWritableScope loopScope = newWritableScopeImpl(context, "Scope with for-loop index");
 
-        JetParameter loopParameter = expression.getLoopParameter();
+        KtParameter loopParameter = expression.getLoopParameter();
         if (loopParameter != null) {
             VariableDescriptor variableDescriptor = createLoopParameterDescriptor(loopParameter, expectedParameterType, context);
             components.modifiersChecker.withTrace(context.trace).checkModifiersForLocalDeclaration(loopParameter, variableDescriptor);
@@ -397,9 +397,9 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
             loopScope.addVariableDescriptor(variableDescriptor);
         }
         else {
-            JetMultiDeclaration multiParameter = expression.getMultiParameter();
+            KtMultiDeclaration multiParameter = expression.getMultiParameter();
             if (multiParameter != null && loopRange != null) {
-                JetType elementType = expectedParameterType == null ? ErrorUtils.createErrorType("Loop range has no type") : expectedParameterType;
+                KtType elementType = expectedParameterType == null ? ErrorUtils.createErrorType("Loop range has no type") : expectedParameterType;
                 TransientReceiver iteratorNextAsReceiver = new TransientReceiver(elementType);
                 components.annotationResolver.resolveAnnotationsWithArguments(loopScope, multiParameter.getModifierList(), context.trace);
                 components.multiDeclarationResolver.defineLocalVariablesFromMultiDeclaration(
@@ -410,7 +410,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
             }
         }
 
-        JetExpression body = expression.getBody();
+        KtExpression body = expression.getBody();
         JetTypeInfo bodyTypeInfo;
         if (body != null) {
             bodyTypeInfo = components.expressionTypingServices.getBlockReturnedTypeWithWritableScope(loopScope, Collections.singletonList(body),
@@ -426,20 +426,20 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     private VariableDescriptor createLoopParameterDescriptor(
-            JetParameter loopParameter,
-            JetType expectedParameterType,
+            KtParameter loopParameter,
+            KtType expectedParameterType,
             ExpressionTypingContext context
     ) {
         components.modifiersChecker.withTrace(context.trace).checkParameterHasNoValOrVar(loopParameter, VAL_OR_VAR_ON_LOOP_PARAMETER);
 
-        JetTypeReference typeReference = loopParameter.getTypeReference();
+        KtTypeReference typeReference = loopParameter.getTypeReference();
         VariableDescriptor variableDescriptor;
         if (typeReference != null) {
             variableDescriptor = components.descriptorResolver.
                     resolveLocalVariableDescriptor(context.scope, loopParameter, context.trace);
-            JetType actualParameterType = variableDescriptor.getType();
+            KtType actualParameterType = variableDescriptor.getType();
             if (expectedParameterType != null &&
-                    !JetTypeChecker.DEFAULT.isSubtypeOf(expectedParameterType, actualParameterType)) {
+                    !KotlinTypeChecker.DEFAULT.isSubtypeOf(expectedParameterType, actualParameterType)) {
                 context.trace.report(TYPE_MISMATCH_IN_FOR_LOOP.on(typeReference, expectedParameterType, actualParameterType));
             }
         }
@@ -464,15 +464,15 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitTryExpression(@NotNull JetTryExpression expression, ExpressionTypingContext typingContext) {
+    public JetTypeInfo visitTryExpression(@NotNull KtTryExpression expression, ExpressionTypingContext typingContext) {
         ExpressionTypingContext context = typingContext.replaceContextDependency(INDEPENDENT);
-        JetExpression tryBlock = expression.getTryBlock();
-        List<JetCatchClause> catchClauses = expression.getCatchClauses();
-        JetFinallySection finallyBlock = expression.getFinallyBlock();
-        List<JetType> types = new ArrayList<JetType>();
-        for (JetCatchClause catchClause : catchClauses) {
-            JetParameter catchParameter = catchClause.getCatchParameter();
-            JetExpression catchBody = catchClause.getCatchBody();
+        KtExpression tryBlock = expression.getTryBlock();
+        List<KtCatchClause> catchClauses = expression.getCatchClauses();
+        KtFinallySection finallyBlock = expression.getFinallyBlock();
+        List<KtType> types = new ArrayList<KtType>();
+        for (KtCatchClause catchClause : catchClauses) {
+            KtParameter catchParameter = catchClause.getCatchParameter();
+            KtExpression catchBody = catchClause.getCatchBody();
             if (catchParameter != null) {
                 components.identifierChecker.checkDeclaration(catchParameter, context.trace);
                 ModifiersChecker.ModifiersCheckingProcedure modifiersChecking = components.modifiersChecker.withTrace(context.trace);
@@ -481,12 +481,12 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
 
                 VariableDescriptor variableDescriptor = components.descriptorResolver.resolveLocalVariableDescriptor(
                         context.scope, catchParameter, context.trace);
-                JetType throwableType = components.builtIns.getThrowable().getDefaultType();
+                KtType throwableType = components.builtIns.getThrowable().getDefaultType();
                 components.dataFlowAnalyzer.checkType(variableDescriptor.getType(), catchParameter, context.replaceExpectedType(throwableType));
                 if (catchBody != null) {
                     LexicalWritableScope catchScope = newWritableScopeImpl(context, "Catch scope");
                     catchScope.addVariableDescriptor(variableDescriptor);
-                    JetType type = facade.getTypeInfo(catchBody, context.replaceScope(catchScope)).getType();
+                    KtType type = facade.getTypeInfo(catchBody, context.replaceScope(catchScope)).getType();
                     if (type != null) {
                         types.add(type);
                     }
@@ -500,7 +500,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
                                         context.replaceExpectedType(NO_EXPECTED_TYPE));
         }
 
-        JetType type = facade.getTypeInfo(tryBlock, context).getType();
+        KtType type = facade.getTypeInfo(tryBlock, context).getType();
         if (type != null) {
             types.add(type);
         }
@@ -513,10 +513,10 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitThrowExpression(@NotNull JetThrowExpression expression, ExpressionTypingContext context) {
-        JetExpression thrownExpression = expression.getThrownExpression();
+    public JetTypeInfo visitThrowExpression(@NotNull KtThrowExpression expression, ExpressionTypingContext context) {
+        KtExpression thrownExpression = expression.getThrownExpression();
         if (thrownExpression != null) {
-            JetType throwableType = components.builtIns.getThrowable().getDefaultType();
+            KtType throwableType = components.builtIns.getThrowable().getDefaultType();
             facade.getTypeInfo(thrownExpression, context
                     .replaceExpectedType(throwableType).replaceScope(context.scope).replaceContextDependency(INDEPENDENT));
         }
@@ -524,24 +524,24 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitReturnExpression(@NotNull JetReturnExpression expression, ExpressionTypingContext context) {
-        JetElement labelTargetElement = LabelResolver.INSTANCE.resolveControlLabel(expression, context);
+    public JetTypeInfo visitReturnExpression(@NotNull KtReturnExpression expression, ExpressionTypingContext context) {
+        KtElement labelTargetElement = LabelResolver.INSTANCE.resolveControlLabel(expression, context);
 
-        JetExpression returnedExpression = expression.getReturnedExpression();
+        KtExpression returnedExpression = expression.getReturnedExpression();
 
-        JetType expectedType = NO_EXPECTED_TYPE;
-        JetType resultType = components.builtIns.getNothingType();
-        JetDeclaration parentDeclaration = PsiTreeUtil.getParentOfType(expression, JetDeclaration.class);
+        KtType expectedType = NO_EXPECTED_TYPE;
+        KtType resultType = components.builtIns.getNothingType();
+        KtDeclaration parentDeclaration = PsiTreeUtil.getParentOfType(expression, KtDeclaration.class);
 
-        if (parentDeclaration instanceof JetParameter) {
+        if (parentDeclaration instanceof KtParameter) {
             // In a default value for parameter
             context.trace.report(RETURN_NOT_ALLOWED.on(expression));
         }
 
         if (expression.getTargetLabel() == null) {
-            while (parentDeclaration instanceof JetMultiDeclaration) {
+            while (parentDeclaration instanceof KtMultiDeclaration) {
                 //TODO: It's hacking fix for KT-5100: Strange "Return is not allowed here" for multi-declaration initializer with elvis expression
-                parentDeclaration = PsiTreeUtil.getParentOfType(parentDeclaration, JetDeclaration.class);
+                parentDeclaration = PsiTreeUtil.getParentOfType(parentDeclaration, KtDeclaration.class);
             }
 
             assert parentDeclaration != null : "Can't find parent declaration for " + expression.getText();
@@ -558,7 +558,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
                     resultType = ErrorUtils.createErrorType(RETURN_NOT_ALLOWED_MESSAGE);
                 }
 
-                expectedType = getFunctionExpectedReturnType(containingFunctionDescriptor, (JetElement) containingFunInfo.getSecond(), context);
+                expectedType = getFunctionExpectedReturnType(containingFunctionDescriptor, (KtElement) containingFunInfo.getSecond(), context);
             }
             else {
                 // Outside a function
@@ -598,38 +598,38 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
 
     private static boolean isClassInitializer(@NotNull Pair<FunctionDescriptor, PsiElement> containingFunInfo) {
         return containingFunInfo.getFirst() instanceof ConstructorDescriptor &&
-               !(containingFunInfo.getSecond() instanceof JetSecondaryConstructor);
+               !(containingFunInfo.getSecond() instanceof KtSecondaryConstructor);
     }
 
     @Override
-    public JetTypeInfo visitBreakExpression(@NotNull JetBreakExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitBreakExpression(@NotNull KtBreakExpression expression, ExpressionTypingContext context) {
         LabelResolver.INSTANCE.resolveControlLabel(expression, context);
         return components.dataFlowAnalyzer.createCheckedTypeInfo(components.builtIns.getNothingType(), context, expression).
                 replaceJumpOutPossible(true);
     }
 
     @Override
-    public JetTypeInfo visitContinueExpression(@NotNull JetContinueExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitContinueExpression(@NotNull KtContinueExpression expression, ExpressionTypingContext context) {
         LabelResolver.INSTANCE.resolveControlLabel(expression, context);
         return components.dataFlowAnalyzer.createCheckedTypeInfo(components.builtIns.getNothingType(), context, expression).
                 replaceJumpOutPossible(true);
     }
 
     @NotNull
-    private static JetType getFunctionExpectedReturnType(
+    private static KtType getFunctionExpectedReturnType(
             @NotNull FunctionDescriptor descriptor,
-            @NotNull JetElement function,
+            @NotNull KtElement function,
             @NotNull ExpressionTypingContext context
     ) {
-        JetType expectedType;
-        if (function instanceof JetSecondaryConstructor) {
+        KtType expectedType;
+        if (function instanceof KtSecondaryConstructor) {
             expectedType = DescriptorUtilsKt.getBuiltIns(descriptor).getUnitType();
         }
-        else if (function instanceof JetFunction) {
-            JetFunction jetFunction = (JetFunction) function;
-            expectedType = context.trace.get(EXPECTED_RETURN_TYPE, jetFunction);
+        else if (function instanceof KtFunction) {
+            KtFunction ktFunction = (KtFunction) function;
+            expectedType = context.trace.get(EXPECTED_RETURN_TYPE, ktFunction);
 
-            if ((expectedType == null) && (jetFunction.getTypeReference() != null || jetFunction.hasBlockBody())) {
+            if ((expectedType == null) && (ktFunction.getTypeReference() != null || ktFunction.hasBlockBody())) {
                 expectedType = descriptor.getReturnType();
             }
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java
index 780e7a970fd..0e8a78c72d9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java
@@ -22,7 +22,7 @@ import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
@@ -32,9 +32,9 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.*;
 import org.jetbrains.kotlin.resolve.constants.*;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.types.DynamicTypesKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt;
 
 import java.util.Collection;
@@ -64,29 +64,29 @@ public class DataFlowAnalyzer {
 
     @NotNull
     public DataFlowInfo extractDataFlowInfoFromCondition(
-            @Nullable JetExpression condition,
+            @Nullable KtExpression condition,
             final boolean conditionValue,
             final ExpressionTypingContext context
     ) {
         if (condition == null) return context.dataFlowInfo;
         final Ref<DataFlowInfo> result = new Ref<DataFlowInfo>(null);
-        condition.accept(new JetVisitorVoid() {
+        condition.accept(new KtVisitorVoid() {
             @Override
-            public void visitIsExpression(@NotNull JetIsExpression expression) {
+            public void visitIsExpression(@NotNull KtIsExpression expression) {
                 if (conditionValue && !expression.isNegated() || !conditionValue && expression.isNegated()) {
                     result.set(context.trace.get(BindingContext.DATAFLOW_INFO_AFTER_CONDITION, expression));
                 }
             }
 
             @Override
-            public void visitBinaryExpression(@NotNull JetBinaryExpression expression) {
+            public void visitBinaryExpression(@NotNull KtBinaryExpression expression) {
                 IElementType operationToken = expression.getOperationToken();
                 if (OperatorConventions.BOOLEAN_OPERATIONS.containsKey(operationToken)) {
                     DataFlowInfo dataFlowInfo = extractDataFlowInfoFromCondition(expression.getLeft(), conditionValue, context);
-                    JetExpression expressionRight = expression.getRight();
+                    KtExpression expressionRight = expression.getRight();
                     if (expressionRight != null) {
                         DataFlowInfo rightInfo = extractDataFlowInfoFromCondition(expressionRight, conditionValue, context);
-                        boolean and = operationToken == JetTokens.ANDAND;
+                        boolean and = operationToken == KtTokens.ANDAND;
                         if (and == conditionValue) { // this means: and && conditionValue || !and && !conditionValue
                             dataFlowInfo = dataFlowInfo.and(rightInfo);
                         }
@@ -97,24 +97,24 @@ public class DataFlowAnalyzer {
                     result.set(dataFlowInfo);
                 }
                 else  {
-                    JetExpression left = expression.getLeft();
+                    KtExpression left = expression.getLeft();
                     if (left == null) return;
-                    JetExpression right = expression.getRight();
+                    KtExpression right = expression.getRight();
                     if (right == null) return;
 
-                    JetType lhsType = context.trace.getBindingContext().getType(left);
+                    KtType lhsType = context.trace.getBindingContext().getType(left);
                     if (lhsType == null) return;
-                    JetType rhsType = context.trace.getBindingContext().getType(right);
+                    KtType rhsType = context.trace.getBindingContext().getType(right);
                     if (rhsType == null) return;
 
                     DataFlowValue leftValue = DataFlowValueFactory.createDataFlowValue(left, lhsType, context);
                     DataFlowValue rightValue = DataFlowValueFactory.createDataFlowValue(right, rhsType, context);
 
                     Boolean equals = null;
-                    if (operationToken == JetTokens.EQEQ || operationToken == JetTokens.EQEQEQ) {
+                    if (operationToken == KtTokens.EQEQ || operationToken == KtTokens.EQEQEQ) {
                         equals = true;
                     }
-                    else if (operationToken == JetTokens.EXCLEQ || operationToken == JetTokens.EXCLEQEQEQ) {
+                    else if (operationToken == KtTokens.EXCLEQ || operationToken == KtTokens.EXCLEQEQEQ) {
                         equals = false;
                     }
                     if (equals != null) {
@@ -130,10 +130,10 @@ public class DataFlowAnalyzer {
             }
 
             @Override
-            public void visitUnaryExpression(@NotNull JetUnaryExpression expression) {
+            public void visitUnaryExpression(@NotNull KtUnaryExpression expression) {
                 IElementType operationTokenType = expression.getOperationReference().getReferencedNameElementType();
-                if (operationTokenType == JetTokens.EXCL) {
-                    JetExpression baseExpression = expression.getBaseExpression();
+                if (operationTokenType == KtTokens.EXCL) {
+                    KtExpression baseExpression = expression.getBaseExpression();
                     if (baseExpression != null) {
                         result.set(extractDataFlowInfoFromCondition(baseExpression, !conditionValue, context));
                     }
@@ -141,8 +141,8 @@ public class DataFlowAnalyzer {
             }
 
             @Override
-            public void visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression) {
-                JetExpression body = expression.getExpression();
+            public void visitParenthesizedExpression(@NotNull KtParenthesizedExpression expression) {
+                KtExpression body = expression.getExpression();
                 if (body != null) {
                     body.accept(this);
                 }
@@ -155,41 +155,41 @@ public class DataFlowAnalyzer {
     }
 
     @Nullable
-    public JetType checkType(@Nullable JetType expressionType, @NotNull JetExpression expression, @NotNull ResolutionContext context) {
+    public KtType checkType(@Nullable KtType expressionType, @NotNull KtExpression expression, @NotNull ResolutionContext context) {
         return checkType(expressionType, expression, context, null);
     }
 
     @NotNull
-    public JetTypeInfo checkType(@NotNull JetTypeInfo typeInfo, @NotNull JetExpression expression, @NotNull ResolutionContext context) {
+    public JetTypeInfo checkType(@NotNull JetTypeInfo typeInfo, @NotNull KtExpression expression, @NotNull ResolutionContext context) {
         return typeInfo.replaceType(checkType(typeInfo.getType(), expression, context));
     }
 
     @NotNull
-    private JetType checkTypeInternal(
-            @NotNull JetType expressionType,
-            @NotNull JetExpression expression,
+    private KtType checkTypeInternal(
+            @NotNull KtType expressionType,
+            @NotNull KtExpression expression,
             @NotNull ResolutionContext c,
             @NotNull Ref<Boolean> hasError
     ) {
         if (noExpectedType(c.expectedType) || !c.expectedType.getConstructor().isDenotable() ||
-            JetTypeChecker.DEFAULT.isSubtypeOf(expressionType, c.expectedType)) {
+            KotlinTypeChecker.DEFAULT.isSubtypeOf(expressionType, c.expectedType)) {
             return expressionType;
         }
 
-        if (expression instanceof JetConstantExpression) {
+        if (expression instanceof KtConstantExpression) {
             ConstantValue<?> constantValue = constantExpressionEvaluator.evaluateToConstantValue(expression, c.trace, c.expectedType);
             boolean error = new CompileTimeConstantChecker(c.trace, builtIns, true)
-                    .checkConstantExpressionType(constantValue, (JetConstantExpression) expression, c.expectedType);
+                    .checkConstantExpressionType(constantValue, (KtConstantExpression) expression, c.expectedType);
             if (hasError != null) hasError.set(error);
             return expressionType;
         }
 
-        if (expression instanceof JetWhenExpression) {
+        if (expression instanceof KtWhenExpression) {
             // No need in additional check because type mismatch is already reported for entries
             return expressionType;
         }
 
-        JetType possibleType = checkPossibleCast(expressionType, expression, c);
+        KtType possibleType = checkPossibleCast(expressionType, expression, c);
         if (possibleType != null) return possibleType;
 
         c.trace.report(TYPE_MISMATCH.on(expression, c.expectedType, expressionType));
@@ -198,9 +198,9 @@ public class DataFlowAnalyzer {
     }
 
     @Nullable
-    public JetType checkType(
-            @Nullable JetType expressionType,
-            @NotNull JetExpression expressionToCheck,
+    public KtType checkType(
+            @Nullable KtType expressionType,
+            @NotNull KtExpression expressionToCheck,
             @NotNull ResolutionContext c,
             @Nullable Ref<Boolean> hasError
     ) {
@@ -211,12 +211,12 @@ public class DataFlowAnalyzer {
             hasError.set(false);
         }
 
-        JetExpression expression = JetPsiUtil.safeDeparenthesize(expressionToCheck);
+        KtExpression expression = KtPsiUtil.safeDeparenthesize(expressionToCheck);
         recordExpectedType(c.trace, expression, c.expectedType);
 
         if (expressionType == null) return null;
 
-        JetType result = checkTypeInternal(expressionType, expression, c, hasError);
+        KtType result = checkTypeInternal(expressionType, expression, c, hasError);
         if (Boolean.FALSE.equals(hasError.get())) {
             for (AdditionalTypeChecker checker : additionalTypeCheckers) {
                 checker.checkType(expression, expressionType, result, c);
@@ -227,9 +227,9 @@ public class DataFlowAnalyzer {
     }
 
     @Nullable
-    public JetType checkPossibleCast(
-            @NotNull JetType expressionType,
-            @NotNull JetExpression expression,
+    public KtType checkPossibleCast(
+            @NotNull KtType expressionType,
+            @NotNull KtExpression expression,
             @NotNull ResolutionContext c
     ) {
         DataFlowValue dataFlowValue = DataFlowValueFactory.createDataFlowValue(expression, expressionType, c);
@@ -238,15 +238,15 @@ public class DataFlowAnalyzer {
         return result != null ? result.getResultType() : null;
     }
 
-    public void recordExpectedType(@NotNull BindingTrace trace, @NotNull JetExpression expression, @NotNull JetType expectedType) {
+    public void recordExpectedType(@NotNull BindingTrace trace, @NotNull KtExpression expression, @NotNull KtType expectedType) {
         if (expectedType != NO_EXPECTED_TYPE) {
-            JetType normalizeExpectedType = expectedType == UNIT_EXPECTED_TYPE ? builtIns.getUnitType() : expectedType;
+            KtType normalizeExpectedType = expectedType == UNIT_EXPECTED_TYPE ? builtIns.getUnitType() : expectedType;
             trace.record(BindingContext.EXPECTED_EXPRESSION_TYPE, expression, normalizeExpectedType);
         }
     }
 
     @Nullable
-    public JetType checkStatementType(@NotNull JetExpression expression, @NotNull ResolutionContext context) {
+    public KtType checkStatementType(@NotNull KtExpression expression, @NotNull ResolutionContext context) {
         if (!noExpectedType(context.expectedType) && !KotlinBuiltIns.isUnit(context.expectedType) && !context.expectedType.isError()) {
             context.trace.report(EXPECTED_TYPE_MISMATCH.on(expression, context.expectedType));
             return null;
@@ -255,16 +255,16 @@ public class DataFlowAnalyzer {
     }
 
     @Nullable
-    public JetType checkImplicitCast(@Nullable JetType expressionType, @NotNull JetExpression expression, @NotNull ResolutionContext context, boolean isStatement) {
-        boolean isIfExpression = expression instanceof JetIfExpression;
+    public KtType checkImplicitCast(@Nullable KtType expressionType, @NotNull KtExpression expression, @NotNull ResolutionContext context, boolean isStatement) {
+        boolean isIfExpression = expression instanceof KtIfExpression;
         if (expressionType != null && (context.expectedType == NO_EXPECTED_TYPE || isIfExpression)
                 && context.contextDependency == INDEPENDENT && !isStatement
                 && (KotlinBuiltIns.isUnit(expressionType) || KotlinBuiltIns.isAnyOrNullableAny(expressionType))
                 && !DynamicTypesKt.isDynamic(expressionType)) {
             if (isIfExpression && KotlinBuiltIns.isUnit(expressionType)) {
-                JetIfExpression ifExpression = (JetIfExpression) expression;
+                KtIfExpression ifExpression = (KtIfExpression) expression;
                 if (ifExpression.getThen() == null || ifExpression.getElse() == null) {
-                    context.trace.report(INVALID_IF_AS_EXPRESSION.on((JetIfExpression) expression));
+                    context.trace.report(INVALID_IF_AS_EXPRESSION.on((KtIfExpression) expression));
                     return expressionType;
                 }
             }
@@ -276,12 +276,12 @@ public class DataFlowAnalyzer {
     }
 
     @NotNull
-    public JetTypeInfo checkImplicitCast(@NotNull JetTypeInfo typeInfo, @NotNull JetExpression expression, @NotNull ResolutionContext context, boolean isStatement) {
+    public JetTypeInfo checkImplicitCast(@NotNull JetTypeInfo typeInfo, @NotNull KtExpression expression, @NotNull ResolutionContext context, boolean isStatement) {
         return typeInfo.replaceType(checkImplicitCast(typeInfo.getType(), expression, context, isStatement));
     }
 
     @NotNull
-    public JetTypeInfo illegalStatementType(@NotNull JetExpression expression, @NotNull ExpressionTypingContext context, @NotNull ExpressionTypingInternals facade) {
+    public JetTypeInfo illegalStatementType(@NotNull KtExpression expression, @NotNull ExpressionTypingContext context, @NotNull ExpressionTypingInternals facade) {
         facade.checkStatementType(
                 expression, context.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT));
         context.trace.report(EXPRESSION_EXPECTED.on(expression, expression));
@@ -289,14 +289,14 @@ public class DataFlowAnalyzer {
     }
 
     @NotNull
-    public Collection<JetType> getAllPossibleTypes(
-            @NotNull JetExpression expression,
+    public Collection<KtType> getAllPossibleTypes(
+            @NotNull KtExpression expression,
             @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull JetType type,
+            @NotNull KtType type,
             @NotNull ResolutionContext c
     ) {
         DataFlowValue dataFlowValue = DataFlowValueFactory.createDataFlowValue(expression, type, c);
-        Collection<JetType> possibleTypes = Sets.newHashSet(type);
+        Collection<KtType> possibleTypes = Sets.newHashSet(type);
         if (dataFlowValue.isPredictable()) {
             possibleTypes.addAll(dataFlowInfo.getPossibleTypes(dataFlowValue));
         }
@@ -305,9 +305,9 @@ public class DataFlowAnalyzer {
 
     @NotNull
     public JetTypeInfo createCheckedTypeInfo(
-            @Nullable JetType type,
+            @Nullable KtType type,
             @NotNull ResolutionContext<?> context,
-            @NotNull JetExpression expression
+            @NotNull KtExpression expression
     ) {
         return checkType(TypeInfoFactoryKt.createTypeInfo(type, context), expression, context);
     }
@@ -315,10 +315,10 @@ public class DataFlowAnalyzer {
     @NotNull
     public JetTypeInfo createCompileTimeConstantTypeInfo(
             @NotNull CompileTimeConstant<?> value,
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             @NotNull ExpressionTypingContext context
     ) {
-        JetType expressionType;
+        KtType expressionType;
         if (value instanceof IntegerValueTypeConstant) {
             IntegerValueTypeConstant integerValueTypeConstant = (IntegerValueTypeConstant) value;
             if (context.contextDependency == INDEPENDENT) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java
index 9d35efe057e..cbef23e4c25 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java
@@ -25,9 +25,8 @@ import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext;
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionResultsCache;
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionResultsCacheImpl;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstantChecker;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingContext> {
 
@@ -36,7 +35,7 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull JetType expectedType
+            @NotNull KtType expectedType
     ) {
         return newContext(trace, scope, dataFlowInfo, expectedType, CallChecker.DoNothing.INSTANCE$);
     }
@@ -46,7 +45,7 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull CallChecker callChecker
     ) {
         return newContext(trace, scope, dataFlowInfo, expectedType,
@@ -71,7 +70,7 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
             @NotNull CallChecker callChecker,
@@ -87,7 +86,7 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
             @NotNull CallChecker callChecker,
@@ -106,7 +105,7 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
             @NotNull BindingTrace trace,
             @NotNull LexicalScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull JetType expectedType,
+            @NotNull KtType expectedType,
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
             @NotNull StatementFilter statementFilter,
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingFacade.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingFacade.java
index f9456603b17..f96d54c7b51 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingFacade.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingFacade.java
@@ -17,15 +17,15 @@
 package org.jetbrains.kotlin.types.expressions;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 
 public interface ExpressionTypingFacade {
     @NotNull
-    JetTypeInfo safeGetTypeInfo(@NotNull JetExpression expression, ExpressionTypingContext context);
+    JetTypeInfo safeGetTypeInfo(@NotNull KtExpression expression, ExpressionTypingContext context);
 
     @NotNull
-    JetTypeInfo getTypeInfo(@NotNull JetExpression expression, ExpressionTypingContext context);
+    JetTypeInfo getTypeInfo(@NotNull KtExpression expression, ExpressionTypingContext context);
     
     @NotNull
-    JetTypeInfo getTypeInfo(@NotNull JetExpression expression, ExpressionTypingContext context, boolean isStatement);
+    JetTypeInfo getTypeInfo(@NotNull KtExpression expression, ExpressionTypingContext context, boolean isStatement);
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingInternals.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingInternals.java
index 351581d427e..51a404df100 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingInternals.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingInternals.java
@@ -23,14 +23,14 @@ import org.jetbrains.kotlin.psi.*;
 /*package*/ interface ExpressionTypingInternals extends ExpressionTypingFacade {
     @NotNull
     JetTypeInfo checkInExpression(
-            @NotNull JetElement callElement,
-            @NotNull JetSimpleNameExpression operationSign,
+            @NotNull KtElement callElement,
+            @NotNull KtSimpleNameExpression operationSign,
             @NotNull ValueArgument leftArgument,
-            @Nullable JetExpression right,
+            @Nullable KtExpression right,
             @NotNull ExpressionTypingContext context
     );
 
-    void checkStatementType(@NotNull JetExpression expression, ExpressionTypingContext context);
+    void checkStatementType(@NotNull KtExpression expression, ExpressionTypingContext context);
 
     @NotNull
     ExpressionTypingComponents getComponents();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java
index 7a6387488f1..509320877c7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.calls.context.ContextDependency;
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope;
 import org.jetbrains.kotlin.resolve.scopes.WritableScope;
 import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt;
 
 import java.util.Iterator;
@@ -69,14 +69,14 @@ public class ExpressionTypingServices {
     }
 
     @NotNull
-    public JetType safeGetType(
+    public KtType safeGetType(
             @NotNull LexicalScope scope,
-            @NotNull JetExpression expression,
-            @NotNull JetType expectedType,
+            @NotNull KtExpression expression,
+            @NotNull KtType expectedType,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull BindingTrace trace
     ) {
-        JetType type = getType(scope, expression, expectedType, dataFlowInfo, trace);
+        KtType type = getType(scope, expression, expectedType, dataFlowInfo, trace);
 
         return type != null ? type : ErrorUtils.createErrorType("Type for " + expression.getText());
     }
@@ -84,8 +84,8 @@ public class ExpressionTypingServices {
     @NotNull
     public JetTypeInfo getTypeInfo(
             @NotNull LexicalScope scope,
-            @NotNull JetExpression expression,
-            @NotNull JetType expectedType,
+            @NotNull KtExpression expression,
+            @NotNull KtType expectedType,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull BindingTrace trace,
             boolean isStatement
@@ -97,15 +97,15 @@ public class ExpressionTypingServices {
     }
 
     @NotNull
-    public JetTypeInfo getTypeInfo(@NotNull JetExpression expression, @NotNull ResolutionContext resolutionContext) {
+    public JetTypeInfo getTypeInfo(@NotNull KtExpression expression, @NotNull ResolutionContext resolutionContext) {
         return expressionTypingFacade.getTypeInfo(expression, ExpressionTypingContext.newContext(resolutionContext));
     }
 
     @Nullable
-    public JetType getType(
+    public KtType getType(
             @NotNull LexicalScope scope,
-            @NotNull JetExpression expression,
-            @NotNull JetType expectedType,
+            @NotNull KtExpression expression,
+            @NotNull KtType expectedType,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull BindingTrace trace
     ) {
@@ -116,10 +116,10 @@ public class ExpressionTypingServices {
 
     public void checkFunctionReturnType(
             @NotNull LexicalScope functionInnerScope,
-            @NotNull JetDeclarationWithBody function,
+            @NotNull KtDeclarationWithBody function,
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull DataFlowInfo dataFlowInfo,
-            @Nullable JetType expectedReturnType,
+            @Nullable KtType expectedReturnType,
             BindingTrace trace
     ) {
         if (expectedReturnType == null) {
@@ -134,8 +134,8 @@ public class ExpressionTypingServices {
         ));
     }
 
-    /*package*/ void checkFunctionReturnType(JetDeclarationWithBody function, ExpressionTypingContext context) {
-        JetExpression bodyExpression = function.getBodyExpression();
+    /*package*/ void checkFunctionReturnType(KtDeclarationWithBody function, ExpressionTypingContext context) {
+        KtExpression bodyExpression = function.getBodyExpression();
         if (bodyExpression == null) return;
 
         boolean blockBody = function.hasBlockBody();
@@ -148,22 +148,22 @@ public class ExpressionTypingServices {
     }
 
     @NotNull
-    public JetTypeInfo getBlockReturnedType(JetBlockExpression expression, ExpressionTypingContext context, boolean isStatement) {
+    public JetTypeInfo getBlockReturnedType(KtBlockExpression expression, ExpressionTypingContext context, boolean isStatement) {
         return getBlockReturnedType(expression, isStatement ? CoercionStrategy.COERCION_TO_UNIT : CoercionStrategy.NO_COERCION, context);
     }
 
     @NotNull
     public JetTypeInfo getBlockReturnedType(
-            @NotNull JetBlockExpression expression,
+            @NotNull KtBlockExpression expression,
             @NotNull CoercionStrategy coercionStrategyForLastExpression,
             @NotNull ExpressionTypingContext context
     ) {
-        List<JetExpression> block = StatementFilterKt.filterStatements(statementFilter, expression);
+        List<KtExpression> block = StatementFilterKt.filterStatements(statementFilter, expression);
 
         // SCRIPT: get code descriptor for script declaration
         DeclarationDescriptor containingDescriptor = context.scope.getOwnerDescriptor();
         if (containingDescriptor instanceof ScriptDescriptor) {
-            if (!(expression.getParent() instanceof JetScript)) {
+            if (!(expression.getParent() instanceof KtScript)) {
                 // top level script declarations should have ScriptDescriptor parent
                 // and lower level script declarations should be ScriptCodeDescriptor parent
                 containingDescriptor = ((ScriptDescriptor) containingDescriptor).getScriptCodeDescriptor();
@@ -192,14 +192,14 @@ public class ExpressionTypingServices {
     }
 
     @NotNull
-    public JetType getBodyExpressionType(
+    public KtType getBodyExpressionType(
             @NotNull BindingTrace trace,
             @NotNull LexicalScope outerScope,
             @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull JetDeclarationWithBody function,
+            @NotNull KtDeclarationWithBody function,
             @NotNull FunctionDescriptor functionDescriptor
     ) {
-        JetExpression bodyExpression = function.getBodyExpression();
+        KtExpression bodyExpression = function.getBodyExpression();
         assert bodyExpression != null;
         LexicalScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(outerScope, functionDescriptor, trace);
 
@@ -208,7 +208,7 @@ public class ExpressionTypingServices {
         );
         JetTypeInfo typeInfo = expressionTypingFacade.getTypeInfo(bodyExpression, context, function.hasBlockBody());
 
-        JetType type = typeInfo.getType();
+        KtType type = typeInfo.getType();
         if (type != null) {
             return type;
         }
@@ -224,7 +224,7 @@ public class ExpressionTypingServices {
      */
     /*package*/ JetTypeInfo getBlockReturnedTypeWithWritableScope(
             @NotNull LexicalWritableScope scope,
-            @NotNull List<? extends JetElement> block,
+            @NotNull List<? extends KtElement> block,
             @NotNull CoercionStrategy coercionStrategyForLastExpression,
             @NotNull ExpressionTypingContext context
     ) {
@@ -240,12 +240,12 @@ public class ExpressionTypingServices {
         // Jump point data flow info
         DataFlowInfo beforeJumpInfo = newContext.dataFlowInfo;
         boolean jumpOutPossible = false;
-        for (Iterator<? extends JetElement> iterator = block.iterator(); iterator.hasNext(); ) {
-            JetElement statement = iterator.next();
-            if (!(statement instanceof JetExpression)) {
+        for (Iterator<? extends KtElement> iterator = block.iterator(); iterator.hasNext(); ) {
+            KtElement statement = iterator.next();
+            if (!(statement instanceof KtExpression)) {
                 continue;
             }
-            JetExpression statementExpression = (JetExpression) statement;
+            KtExpression statementExpression = (KtExpression) statement;
             if (!iterator.hasNext()) {
                 result = getTypeOfLastExpressionInBlock(
                         statementExpression, newContext.replaceExpectedType(context.expectedType), coercionStrategyForLastExpression,
@@ -272,13 +272,13 @@ public class ExpressionTypingServices {
     }
 
     private JetTypeInfo getTypeOfLastExpressionInBlock(
-            @NotNull JetExpression statementExpression,
+            @NotNull KtExpression statementExpression,
             @NotNull ExpressionTypingContext context,
             @NotNull CoercionStrategy coercionStrategyForLastExpression,
             @NotNull ExpressionTypingInternals blockLevelVisitor
     ) {
         if (context.expectedType != NO_EXPECTED_TYPE) {
-            JetType expectedType;
+            KtType expectedType;
             if (context.expectedType == UNIT_EXPECTED_TYPE ||//the first check is necessary to avoid invocation 'isUnit(UNIT_EXPECTED_TYPE)'
                 (coercionStrategyForLastExpression == COERCION_TO_UNIT && KotlinBuiltIns.isUnit(context.expectedType))) {
                 expectedType = UNIT_EXPECTED_TYPE;
@@ -292,14 +292,14 @@ public class ExpressionTypingServices {
         JetTypeInfo result = blockLevelVisitor.getTypeInfo(statementExpression, context, true);
         if (coercionStrategyForLastExpression == COERCION_TO_UNIT) {
             boolean mightBeUnit = false;
-            if (statementExpression instanceof JetDeclaration) {
+            if (statementExpression instanceof KtDeclaration) {
                 mightBeUnit = true;
             }
-            if (statementExpression instanceof JetBinaryExpression) {
-                JetBinaryExpression binaryExpression = (JetBinaryExpression) statementExpression;
+            if (statementExpression instanceof KtBinaryExpression) {
+                KtBinaryExpression binaryExpression = (KtBinaryExpression) statementExpression;
                 IElementType operationType = binaryExpression.getOperationToken();
                 //noinspection SuspiciousMethodCalls
-                if (operationType == JetTokens.EQ || OperatorConventions.ASSIGNMENT_OPERATIONS.containsKey(operationType)) {
+                if (operationType == KtTokens.EQ || OperatorConventions.ASSIGNMENT_OPERATIONS.containsKey(operationType)) {
                     mightBeUnit = true;
                 }
             }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java
index f38f0cf35a9..c177ca03491 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory;
 import org.jetbrains.kotlin.diagnostics.Errors;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope;
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.resolve.scopes.WritableScope;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ClassReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt;
 
 import java.util.ArrayList;
@@ -48,13 +48,13 @@ public class ExpressionTypingUtils {
     @NotNull
     public static ReceiverValue normalizeReceiverValueForVisibility(@NotNull ReceiverValue receiverValue, @NotNull BindingContext trace) {
         if (receiverValue instanceof ExpressionReceiver) {
-            JetExpression expression = ((ExpressionReceiver) receiverValue).getExpression();
-            JetReferenceExpression referenceExpression = null;
-            if (expression instanceof JetThisExpression) {
-                referenceExpression = ((JetThisExpression) expression).getInstanceReference();
+            KtExpression expression = ((ExpressionReceiver) receiverValue).getExpression();
+            KtReferenceExpression referenceExpression = null;
+            if (expression instanceof KtThisExpression) {
+                referenceExpression = ((KtThisExpression) expression).getInstanceReference();
             }
-            else if (expression instanceof JetConstructorDelegationReferenceExpression) {
-                referenceExpression = (JetReferenceExpression) expression;
+            else if (expression instanceof KtConstructorDelegationReferenceExpression) {
+                referenceExpression = (KtReferenceExpression) expression;
             }
 
             if (referenceExpression != null) {
@@ -68,7 +68,7 @@ public class ExpressionTypingUtils {
     }
 
     @Nullable
-    public static ExpressionReceiver getExpressionReceiver(@NotNull JetExpression expression, @Nullable JetType type) {
+    public static ExpressionReceiver getExpressionReceiver(@NotNull KtExpression expression, @Nullable KtType type) {
         if (type == null) return null;
         return new ExpressionReceiver(expression, type);
     }
@@ -76,7 +76,7 @@ public class ExpressionTypingUtils {
     @Nullable
     public static ExpressionReceiver getExpressionReceiver(
             @NotNull ExpressionTypingFacade facade,
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             ExpressionTypingContext context
     ) {
         return getExpressionReceiver(expression, facade.getTypeInfo(expression, context).getType());
@@ -85,16 +85,16 @@ public class ExpressionTypingUtils {
     @NotNull
     public static ExpressionReceiver safeGetExpressionReceiver(
             @NotNull ExpressionTypingFacade facade,
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             ExpressionTypingContext context
     ) {
-        JetType type = safeGetType(facade.safeGetTypeInfo(expression, context));
+        KtType type = safeGetType(facade.safeGetTypeInfo(expression, context));
         return new ExpressionReceiver(expression, type);
     }
 
     @NotNull
-    public static JetType safeGetType(@NotNull JetTypeInfo typeInfo) {
-        JetType type = typeInfo.getType();
+    public static KtType safeGetType(@NotNull JetTypeInfo typeInfo) {
+        KtType type = typeInfo.getType();
         assert type != null : "safeGetType should be invoked on safe JetTypeInfo; safeGetTypeInfo should return @NotNull type";
         return type;
     }
@@ -107,13 +107,13 @@ public class ExpressionTypingUtils {
         return scope;
     }
 
-    public static JetExpression createFakeExpressionOfType(
+    public static KtExpression createFakeExpressionOfType(
             @NotNull Project project,
             @NotNull BindingTrace trace,
             @NotNull String argumentName,
-            @NotNull JetType argumentType
+            @NotNull KtType argumentType
     ) {
-        JetExpression fakeExpression = JetPsiFactoryKt.JetPsiFactory(project).createExpression(argumentName);
+        KtExpression fakeExpression = KtPsiFactoryKt.KtPsiFactory(project).createExpression(argumentName);
         trace.recordType(fakeExpression, argumentType);
         trace.record(PROCESSED, fakeExpression);
         return fakeExpression;
@@ -134,7 +134,7 @@ public class ExpressionTypingUtils {
 
     public static ObservableBindingTrace makeTraceInterceptingTypeMismatch(
             @NotNull BindingTrace trace,
-            @NotNull final JetElement expressionToWatch,
+            @NotNull final KtElement expressionToWatch,
             @NotNull final boolean[] mismatchFound
     ) {
         return new ObservableBindingTrace(trace) {
@@ -157,7 +157,7 @@ public class ExpressionTypingUtils {
 
     @NotNull
     public static JetTypeInfo getTypeInfoOrNullType(
-            @Nullable JetExpression expression,
+            @Nullable KtExpression expression,
             @NotNull ExpressionTypingContext context,
             @NotNull ExpressionTypingInternals facade
     ) {
@@ -167,24 +167,24 @@ public class ExpressionTypingUtils {
     }
 
     @SuppressWarnings("SuspiciousMethodCalls")
-    public static boolean isBinaryExpressionDependentOnExpectedType(@NotNull JetBinaryExpression expression) {
+    public static boolean isBinaryExpressionDependentOnExpectedType(@NotNull KtBinaryExpression expression) {
         IElementType operationType = expression.getOperationReference().getReferencedNameElementType();
-        return (operationType == JetTokens.IDENTIFIER || OperatorConventions.BINARY_OPERATION_NAMES.containsKey(operationType)
-                || operationType == JetTokens.ELVIS);
+        return (operationType == KtTokens.IDENTIFIER || OperatorConventions.BINARY_OPERATION_NAMES.containsKey(operationType)
+                || operationType == KtTokens.ELVIS);
     }
 
-    public static boolean isUnaryExpressionDependentOnExpectedType(@NotNull JetUnaryExpression expression) {
-        return expression.getOperationReference().getReferencedNameElementType() == JetTokens.EXCLEXCL;
+    public static boolean isUnaryExpressionDependentOnExpectedType(@NotNull KtUnaryExpression expression) {
+        return expression.getOperationReference().getReferencedNameElementType() == KtTokens.EXCLEXCL;
     }
 
-    public static boolean isExclExclExpression(@Nullable JetExpression expression) {
-        return expression instanceof JetUnaryExpression
-               && ((JetUnaryExpression) expression).getOperationReference().getReferencedNameElementType() == JetTokens.EXCLEXCL;
+    public static boolean isExclExclExpression(@Nullable KtExpression expression) {
+        return expression instanceof KtUnaryExpression
+               && ((KtUnaryExpression) expression).getOperationReference().getReferencedNameElementType() == KtTokens.EXCLEXCL;
     }
 
     @NotNull
-    public static List<JetType> getValueParametersTypes(@NotNull List<ValueParameterDescriptor> valueParameters) {
-        List<JetType> parameterTypes = new ArrayList<JetType>(valueParameters.size());
+    public static List<KtType> getValueParametersTypes(@NotNull List<ValueParameterDescriptor> valueParameters) {
+        List<KtType> parameterTypes = new ArrayList<KtType>(valueParameters.size());
         for (ValueParameterDescriptor parameter : valueParameters) {
             parameterTypes.add(parameter.getType());
         }
@@ -222,18 +222,18 @@ public class ExpressionTypingUtils {
         return false;
     }
 
-    public static boolean dependsOnExpectedType(@Nullable JetExpression expression) {
-        JetExpression expr = JetPsiUtil.deparenthesize(expression);
+    public static boolean dependsOnExpectedType(@Nullable KtExpression expression) {
+        KtExpression expr = KtPsiUtil.deparenthesize(expression);
         if (expr == null) return false;
 
-        if (expr instanceof JetBinaryExpressionWithTypeRHS) {
+        if (expr instanceof KtBinaryExpressionWithTypeRHS) {
             return false;
         }
-        if (expr instanceof JetBinaryExpression) {
-            return isBinaryExpressionDependentOnExpectedType((JetBinaryExpression) expr);
+        if (expr instanceof KtBinaryExpression) {
+            return isBinaryExpressionDependentOnExpectedType((KtBinaryExpression) expr);
         }
-        if (expr instanceof JetUnaryExpression) {
-            return isUnaryExpressionDependentOnExpectedType((JetUnaryExpression) expr);
+        if (expr instanceof KtUnaryExpression) {
+            return isUnaryExpressionDependentOnExpectedType((KtUnaryExpression) expr);
         }
         return true;
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitor.java
index a3677c466e3..6b19cce5135 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitor.java
@@ -17,9 +17,9 @@
 package org.jetbrains.kotlin.types.expressions;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetVisitor;
+import org.jetbrains.kotlin.psi.KtVisitor;
 
-/*package*/ abstract class ExpressionTypingVisitor extends JetVisitor<JetTypeInfo, ExpressionTypingContext> {
+/*package*/ abstract class ExpressionTypingVisitor extends KtVisitor<JetTypeInfo, ExpressionTypingContext> {
 
     protected final ExpressionTypingInternals facade;
     protected final ExpressionTypingComponents components;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java
index f2a9145be0a..abefb39806f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilsKt;
 import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope;
 import org.jetbrains.kotlin.types.DeferredType;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt;
 import org.jetbrains.kotlin.util.PerformanceCounter;
 import org.jetbrains.kotlin.util.ReenteringLazyValueComputationException;
@@ -39,7 +39,8 @@ import org.jetbrains.kotlin.utils.KotlinFrontEndException;
 
 import static org.jetbrains.kotlin.diagnostics.Errors.TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM;
 
-public abstract class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTypeInfo, ExpressionTypingContext> implements ExpressionTypingInternals {
+public abstract class ExpressionTypingVisitorDispatcher extends KtVisitor<JetTypeInfo, ExpressionTypingContext>
+        implements ExpressionTypingInternals {
 
     public static final PerformanceCounter typeInfoPerfCounter = PerformanceCounter.Companion.create("Type info", true);
 
@@ -107,10 +108,10 @@ public abstract class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTy
     @NotNull
     @Override
     public JetTypeInfo checkInExpression(
-            @NotNull JetElement callElement,
-            @NotNull JetSimpleNameExpression operationSign,
+            @NotNull KtElement callElement,
+            @NotNull KtSimpleNameExpression operationSign,
             @NotNull ValueArgument leftArgument,
-            @Nullable JetExpression right,
+            @Nullable KtExpression right,
             @NotNull ExpressionTypingContext context
     ) {
         return basic.checkInExpression(callElement, operationSign, leftArgument, right, context);
@@ -118,7 +119,7 @@ public abstract class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTy
 
     @Override
     @NotNull
-    public final JetTypeInfo safeGetTypeInfo(@NotNull JetExpression expression, ExpressionTypingContext context) {
+    public final JetTypeInfo safeGetTypeInfo(@NotNull KtExpression expression, ExpressionTypingContext context) {
         JetTypeInfo typeInfo = getTypeInfo(expression, context);
         if (typeInfo.getType() != null) {
             return typeInfo;
@@ -130,7 +131,7 @@ public abstract class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTy
 
     @Override
     @NotNull
-    public final JetTypeInfo getTypeInfo(@NotNull JetExpression expression, ExpressionTypingContext context) {
+    public final JetTypeInfo getTypeInfo(@NotNull KtExpression expression, ExpressionTypingContext context) {
         JetTypeInfo result = getTypeInfo(expression, context, this);
         annotationChecker.checkExpression(expression, context.trace);
         return result;
@@ -138,7 +139,7 @@ public abstract class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTy
 
     @Override
     @NotNull
-    public final JetTypeInfo getTypeInfo(@NotNull JetExpression expression, ExpressionTypingContext context, boolean isStatement) {
+    public final JetTypeInfo getTypeInfo(@NotNull KtExpression expression, ExpressionTypingContext context, boolean isStatement) {
         if (!isStatement) return getTypeInfo(expression, context);
         return getTypeInfo(expression, context, getStatementVisitor(context));
     }
@@ -150,12 +151,12 @@ public abstract class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTy
     }
 
     @Override
-    public void checkStatementType(@NotNull JetExpression expression, ExpressionTypingContext context) {
+    public void checkStatementType(@NotNull KtExpression expression, ExpressionTypingContext context) {
         expression.accept(createStatementVisitor(context), context);
     }
 
     @NotNull
-    private static JetTypeInfo getTypeInfo(@NotNull final JetExpression expression, final ExpressionTypingContext context, final JetVisitor<JetTypeInfo, ExpressionTypingContext> visitor) {
+    private static JetTypeInfo getTypeInfo(@NotNull final KtExpression expression, final ExpressionTypingContext context, final KtVisitor<JetTypeInfo, ExpressionTypingContext> visitor) {
         return typeInfoPerfCounter.time(new Function0<JetTypeInfo>() {
             @Override
             public JetTypeInfo invoke() {
@@ -170,7 +171,7 @@ public abstract class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTy
                         // Some recursive definitions (object expressions) must put their types in the cache manually:
                         //noinspection ConstantConditions
                         if (context.trace.get(BindingContext.PROCESSED, expression)) {
-                            JetType type = context.trace.getBindingContext().getType(expression);
+                            KtType type = context.trace.getBindingContext().getType(expression);
                             return result.replaceType(type);
                         }
 
@@ -209,7 +210,7 @@ public abstract class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTy
         });
     }
 
-    private static void logOrThrowException(@NotNull JetExpression expression, Throwable e) {
+    private static void logOrThrowException(@NotNull KtExpression expression, Throwable e) {
         try {
             // This trows AssertionError in CLI and reports the error in the IDE
             LOG.error(
@@ -227,178 +228,178 @@ public abstract class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTy
     //////////////////////////////////////////////////////////////////////////////////////////////
 
     @Override
-    public JetTypeInfo visitFunctionLiteralExpression(@NotNull JetFunctionLiteralExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitFunctionLiteralExpression(@NotNull KtFunctionLiteralExpression expression, ExpressionTypingContext data) {
         return functions.visitFunctionLiteralExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitNamedFunction(@NotNull JetNamedFunction function, ExpressionTypingContext data) {
+    public JetTypeInfo visitNamedFunction(@NotNull KtNamedFunction function, ExpressionTypingContext data) {
         return functions.visitNamedFunction(function, data);
     }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
 
     @Override
-    public JetTypeInfo visitThrowExpression(@NotNull JetThrowExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitThrowExpression(@NotNull KtThrowExpression expression, ExpressionTypingContext data) {
         return controlStructures.visitThrowExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitReturnExpression(@NotNull JetReturnExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitReturnExpression(@NotNull KtReturnExpression expression, ExpressionTypingContext data) {
         return controlStructures.visitReturnExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitContinueExpression(@NotNull JetContinueExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitContinueExpression(@NotNull KtContinueExpression expression, ExpressionTypingContext data) {
         return controlStructures.visitContinueExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitIfExpression(@NotNull JetIfExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitIfExpression(@NotNull KtIfExpression expression, ExpressionTypingContext data) {
         return controlStructures.visitIfExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitTryExpression(@NotNull JetTryExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitTryExpression(@NotNull KtTryExpression expression, ExpressionTypingContext data) {
         return controlStructures.visitTryExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitForExpression(@NotNull JetForExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitForExpression(@NotNull KtForExpression expression, ExpressionTypingContext data) {
         return controlStructures.visitForExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitWhileExpression(@NotNull JetWhileExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitWhileExpression(@NotNull KtWhileExpression expression, ExpressionTypingContext data) {
         return controlStructures.visitWhileExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitDoWhileExpression(@NotNull JetDoWhileExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitDoWhileExpression(@NotNull KtDoWhileExpression expression, ExpressionTypingContext data) {
         return controlStructures.visitDoWhileExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitBreakExpression(@NotNull JetBreakExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitBreakExpression(@NotNull KtBreakExpression expression, ExpressionTypingContext data) {
         return controlStructures.visitBreakExpression(expression, data);
     }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
 
     @Override
-    public JetTypeInfo visitIsExpression(@NotNull JetIsExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitIsExpression(@NotNull KtIsExpression expression, ExpressionTypingContext data) {
         return patterns.visitIsExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitWhenExpression(@NotNull JetWhenExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitWhenExpression(@NotNull KtWhenExpression expression, ExpressionTypingContext data) {
         return patterns.visitWhenExpression(expression, data);
     }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
 
     @Override
-    public JetTypeInfo visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression, ExpressionTypingContext data) {
         return basic.visitSimpleNameExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitParenthesizedExpression(@NotNull KtParenthesizedExpression expression, ExpressionTypingContext data) {
         return basic.visitParenthesizedExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitConstantExpression(@NotNull JetConstantExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitConstantExpression(@NotNull KtConstantExpression expression, ExpressionTypingContext data) {
         return basic.visitConstantExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitBinaryWithTypeRHSExpression(@NotNull KtBinaryExpressionWithTypeRHS expression, ExpressionTypingContext data) {
         return basic.visitBinaryWithTypeRHSExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitThisExpression(@NotNull JetThisExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitThisExpression(@NotNull KtThisExpression expression, ExpressionTypingContext data) {
         return basic.visitThisExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitSuperExpression(@NotNull JetSuperExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitSuperExpression(@NotNull KtSuperExpression expression, ExpressionTypingContext data) {
         return basic.visitSuperExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitBlockExpression(@NotNull JetBlockExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitBlockExpression(@NotNull KtBlockExpression expression, ExpressionTypingContext data) {
         return basic.visitBlockExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitClassLiteralExpression(@NotNull JetClassLiteralExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitClassLiteralExpression(@NotNull KtClassLiteralExpression expression, ExpressionTypingContext data) {
         return basic.visitClassLiteralExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitCallableReferenceExpression(@NotNull JetCallableReferenceExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitCallableReferenceExpression(@NotNull KtCallableReferenceExpression expression, ExpressionTypingContext data) {
         return basic.visitCallableReferenceExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitObjectLiteralExpression(@NotNull JetObjectLiteralExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitObjectLiteralExpression(@NotNull KtObjectLiteralExpression expression, ExpressionTypingContext data) {
         return basic.visitObjectLiteralExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitQualifiedExpression(@NotNull JetQualifiedExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitQualifiedExpression(@NotNull KtQualifiedExpression expression, ExpressionTypingContext data) {
         return basic.visitQualifiedExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitCallExpression(@NotNull JetCallExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitCallExpression(@NotNull KtCallExpression expression, ExpressionTypingContext data) {
         return basic.visitCallExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitUnaryExpression(@NotNull JetUnaryExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitUnaryExpression(@NotNull KtUnaryExpression expression, ExpressionTypingContext data) {
         return basic.visitUnaryExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitLabeledExpression(@NotNull JetLabeledExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitLabeledExpression(@NotNull KtLabeledExpression expression, ExpressionTypingContext data) {
         return basic.visitLabeledExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitBinaryExpression(@NotNull JetBinaryExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitBinaryExpression(@NotNull KtBinaryExpression expression, ExpressionTypingContext data) {
         return basic.visitBinaryExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitArrayAccessExpression(@NotNull JetArrayAccessExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitArrayAccessExpression(@NotNull KtArrayAccessExpression expression, ExpressionTypingContext data) {
         return basic.visitArrayAccessExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitDeclaration(@NotNull JetDeclaration dcl, ExpressionTypingContext data) {
+    public JetTypeInfo visitDeclaration(@NotNull KtDeclaration dcl, ExpressionTypingContext data) {
         return basic.visitDeclaration(dcl, data);
     }
 
     @Override
-    public JetTypeInfo visitRootPackageExpression(@NotNull JetRootPackageExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitRootPackageExpression(@NotNull KtRootPackageExpression expression, ExpressionTypingContext data) {
         return basic.visitRootPackageExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitStringTemplateExpression(@NotNull JetStringTemplateExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitStringTemplateExpression(@NotNull KtStringTemplateExpression expression, ExpressionTypingContext data) {
         return basic.visitStringTemplateExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitAnnotatedExpression(@NotNull JetAnnotatedExpression expression, ExpressionTypingContext data) {
+    public JetTypeInfo visitAnnotatedExpression(@NotNull KtAnnotatedExpression expression, ExpressionTypingContext data) {
         return basic.visitAnnotatedExpression(expression, data);
     }
 
     @Override
-    public JetTypeInfo visitJetElement(@NotNull JetElement element, ExpressionTypingContext data) {
+    public JetTypeInfo visitJetElement(@NotNull KtElement element, ExpressionTypingContext data) {
         return element.accept(basic, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java
index fd246e16b10..768692d8c79 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java
@@ -25,10 +25,9 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.VariableDescriptor;
 import org.jetbrains.kotlin.diagnostics.Errors;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.TemporaryBindingTrace;
 import org.jetbrains.kotlin.resolve.calls.context.TemporaryTraceAndCache;
@@ -42,15 +41,15 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory;
 import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt;
 
 import java.util.Collection;
 
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
-import static org.jetbrains.kotlin.psi.JetPsiUtil.deparenthesize;
+import static org.jetbrains.kotlin.psi.KtPsiUtil.deparenthesize;
 import static org.jetbrains.kotlin.resolve.BindingContext.AMBIGUOUS_REFERENCE_TARGET;
 import static org.jetbrains.kotlin.resolve.BindingContext.VARIABLE_REASSIGNMENT;
 import static org.jetbrains.kotlin.resolve.calls.context.ContextDependency.INDEPENDENT;
@@ -82,9 +81,9 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @Nullable
-    private JetType checkAssignmentType(
-            @Nullable JetType assignmentType,
-            @NotNull JetBinaryExpression expression,
+    private KtType checkAssignmentType(
+            @Nullable KtType assignmentType,
+            @NotNull KtBinaryExpression expression,
             @NotNull ExpressionTypingContext context
     ) {
         if (assignmentType != null && !KotlinBuiltIns.isUnit(assignmentType) && !noExpectedType(context.expectedType) &&
@@ -96,7 +95,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @Override
-    public JetTypeInfo visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, ExpressionTypingContext context) {
+    public JetTypeInfo visitObjectDeclaration(@NotNull KtObjectDeclaration declaration, ExpressionTypingContext context) {
         components.localClassifierAnalyzer.processClassOrObject(
                 scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT),
                 scope.getOwnerDescriptor(),
@@ -105,24 +104,24 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @Override
-    public JetTypeInfo visitProperty(@NotNull JetProperty property, ExpressionTypingContext typingContext) {
+    public JetTypeInfo visitProperty(@NotNull KtProperty property, ExpressionTypingContext typingContext) {
         ExpressionTypingContext context = typingContext.replaceContextDependency(INDEPENDENT).replaceScope(scope);
-        JetTypeReference receiverTypeRef = property.getReceiverTypeReference();
+        KtTypeReference receiverTypeRef = property.getReceiverTypeReference();
         if (receiverTypeRef != null) {
             context.trace.report(LOCAL_EXTENSION_PROPERTY.on(receiverTypeRef));
         }
 
-        JetPropertyAccessor getter = property.getGetter();
+        KtPropertyAccessor getter = property.getGetter();
         if (getter != null) {
             context.trace.report(LOCAL_VARIABLE_WITH_GETTER.on(getter));
         }
 
-        JetPropertyAccessor setter = property.getSetter();
+        KtPropertyAccessor setter = property.getSetter();
         if (setter != null) {
             context.trace.report(LOCAL_VARIABLE_WITH_SETTER.on(setter));
         }
 
-        JetExpression delegateExpression = property.getDelegateExpression();
+        KtExpression delegateExpression = property.getDelegateExpression();
         if (delegateExpression != null) {
             components.expressionTypingServices.getTypeInfo(delegateExpression, context);
             context.trace.report(LOCAL_VARIABLE_WITH_DELEGATE.on(property.getDelegate()));
@@ -130,13 +129,13 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
 
         VariableDescriptor propertyDescriptor = components.descriptorResolver.
                 resolveLocalVariableDescriptor(scope, property, context.dataFlowInfo, context.trace);
-        JetExpression initializer = property.getInitializer();
+        KtExpression initializer = property.getInitializer();
         JetTypeInfo typeInfo;
         if (initializer != null) {
-            JetType outType = propertyDescriptor.getType();
+            KtType outType = propertyDescriptor.getType();
             typeInfo = facade.getTypeInfo(initializer, context.replaceExpectedType(outType));
             DataFlowInfo dataFlowInfo = typeInfo.getDataFlowInfo();
-            JetType type = typeInfo.getType();
+            KtType type = typeInfo.getType();
             // At this moment we do not take initializer value into account if type is given for a property
             // We can comment first part of this condition to take them into account, like here: var s: String? = "xyz"
             // In this case s will be not-nullable until it is changed
@@ -166,10 +165,10 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @Override
-    public JetTypeInfo visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration, ExpressionTypingContext context) {
+    public JetTypeInfo visitMultiDeclaration(@NotNull KtMultiDeclaration multiDeclaration, ExpressionTypingContext context) {
         components.annotationResolver.resolveAnnotationsWithArguments(scope, multiDeclaration.getModifierList(), context.trace);
 
-        JetExpression initializer = multiDeclaration.getInitializer();
+        KtExpression initializer = multiDeclaration.getInitializer();
         if (initializer == null) {
             context.trace.report(INITIALIZER_REQUIRED_FOR_MULTIDECLARATION.on(multiDeclaration));
             return TypeInfoFactoryKt.noTypeInfo(context);
@@ -187,12 +186,12 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @Override
-    public JetTypeInfo visitNamedFunction(@NotNull JetNamedFunction function, ExpressionTypingContext context) {
+    public JetTypeInfo visitNamedFunction(@NotNull KtNamedFunction function, ExpressionTypingContext context) {
         return functions.visitNamedFunction(function, context, true, scope);
     }
 
     @Override
-    public JetTypeInfo visitClass(@NotNull JetClass klass, ExpressionTypingContext context) {
+    public JetTypeInfo visitClass(@NotNull KtClass klass, ExpressionTypingContext context) {
         components.localClassifierAnalyzer.processClassOrObject(
                 scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT),
                 scope.getOwnerDescriptor(),
@@ -201,22 +200,22 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @Override
-    public JetTypeInfo visitTypedef(@NotNull JetTypedef typedef, ExpressionTypingContext context) {
+    public JetTypeInfo visitTypedef(@NotNull KtTypedef typedef, ExpressionTypingContext context) {
         context.trace.report(UNSUPPORTED.on(typedef, "Typedefs are not supported"));
         return super.visitTypedef(typedef, context);
     }
 
     @Override
-    public JetTypeInfo visitDeclaration(@NotNull JetDeclaration dcl, ExpressionTypingContext context) {
+    public JetTypeInfo visitDeclaration(@NotNull KtDeclaration dcl, ExpressionTypingContext context) {
         return TypeInfoFactoryKt.createTypeInfo(components.dataFlowAnalyzer.checkStatementType(dcl, context), context);
     }
 
     @Override
-    public JetTypeInfo visitBinaryExpression(@NotNull JetBinaryExpression expression, ExpressionTypingContext context) {
-        JetSimpleNameExpression operationSign = expression.getOperationReference();
+    public JetTypeInfo visitBinaryExpression(@NotNull KtBinaryExpression expression, ExpressionTypingContext context) {
+        KtSimpleNameExpression operationSign = expression.getOperationReference();
         IElementType operationType = operationSign.getReferencedNameElementType();
         JetTypeInfo result;
-        if (operationType == JetTokens.EQ) {
+        if (operationType == KtTokens.EQ) {
             result = visitAssignment(expression, context);
         }
         else if (OperatorConventions.ASSIGNMENT_OPERATIONS.containsKey(operationType)) {
@@ -229,21 +228,21 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @NotNull
-    protected JetTypeInfo visitAssignmentOperation(JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
+    protected JetTypeInfo visitAssignmentOperation(KtBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
         //There is a temporary binding trace for an opportunity to resolve set method for array if needed (the initial trace should be used there)
         TemporaryTraceAndCache temporary = TemporaryTraceAndCache.create(
                 contextWithExpectedType, "trace to resolve array set method for binary expression", expression);
         ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE)
                 .replaceTraceAndCache(temporary).replaceContextDependency(INDEPENDENT);
 
-        JetSimpleNameExpression operationSign = expression.getOperationReference();
+        KtSimpleNameExpression operationSign = expression.getOperationReference();
         IElementType operationType = operationSign.getReferencedNameElementType();
-        JetExpression leftOperand = expression.getLeft();
+        KtExpression leftOperand = expression.getLeft();
         JetTypeInfo leftInfo = ExpressionTypingUtils.getTypeInfoOrNullType(leftOperand, context, facade);
-        JetType leftType = leftInfo.getType();
+        KtType leftType = leftInfo.getType();
 
-        JetExpression right = expression.getRight();
-        JetExpression left = leftOperand == null ? null : deparenthesize(leftOperand);
+        KtExpression right = expression.getRight();
+        KtExpression left = leftOperand == null ? null : deparenthesize(leftOperand);
         if (right == null || left == null) {
             temporary.commit();
             return leftInfo.clearType();
@@ -267,11 +266,11 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
                         context.replaceTraceAndCache(temporaryForAssignmentOperation).replaceScope(scope),
                         receiver, expression, name
                 );
-        JetType assignmentOperationType = OverloadResolutionResultsUtil.getResultingType(assignmentOperationDescriptors,
-                                                                                         context.contextDependency);
+        KtType assignmentOperationType = OverloadResolutionResultsUtil.getResultingType(assignmentOperationDescriptors,
+                                                                                        context.contextDependency);
 
         OverloadResolutionResults<FunctionDescriptor> binaryOperationDescriptors;
-        JetType binaryOperationType;
+        KtType binaryOperationType;
         TemporaryTraceAndCache temporaryForBinaryOperation = TemporaryTraceAndCache.create(
                 context, "trace to check binary operation like '+' for", expression);
         TemporaryBindingTrace ignoreReportsTrace = TemporaryBindingTrace.create(context.trace, "Trace for checking assignability");
@@ -290,7 +289,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
             binaryOperationType = null;
         }
 
-        JetType type = assignmentOperationType != null ? assignmentOperationType : binaryOperationType;
+        KtType type = assignmentOperationType != null ? assignmentOperationType : binaryOperationType;
         JetTypeInfo rightInfo = leftInfo;
         if (assignmentOperationDescriptors.isSuccess() && binaryOperationDescriptors.isSuccess()) {
             // Both 'plus()' and 'plusAssign()' available => ambiguity
@@ -306,7 +305,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
         else if (assignmentOperationType != null && (assignmentOperationDescriptors.isSuccess() || !binaryOperationDescriptors.isSuccess())) {
             // There's 'plusAssign()', so we do a.plusAssign(b)
             temporaryForAssignmentOperation.commit();
-            if (!JetTypeChecker.DEFAULT.equalTypes(components.builtIns.getUnitType(), assignmentOperationType)) {
+            if (!KotlinTypeChecker.DEFAULT.equalTypes(components.builtIns.getUnitType(), assignmentOperationType)) {
                 context.trace.report(ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT.on(operationSign, assignmentOperationDescriptors.getResultingDescriptor(), operationSign));
             }
         }
@@ -314,10 +313,10 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
             // There's only 'plus()', so we try 'a = a + b'
             temporaryForBinaryOperation.commit();
             context.trace.record(VARIABLE_REASSIGNMENT, expression);
-            if (left instanceof JetArrayAccessExpression) {
+            if (left instanceof KtArrayAccessExpression) {
                 ExpressionTypingContext contextForResolve = context.replaceScope(scope).replaceBindingTrace(TemporaryBindingTrace.create(
                         context.trace, "trace to resolve array set method for assignment", expression));
-                basic.resolveArrayAccessSetMethod((JetArrayAccessExpression) left, right, contextForResolve, context.trace);
+                basic.resolveArrayAccessSetMethod((KtArrayAccessExpression) left, right, contextForResolve, context.trace);
             }
             rightInfo = facade.getTypeInfo(right, context.replaceDataFlowInfo(leftInfo.getDataFlowInfo()));
             components.dataFlowAnalyzer.checkType(binaryOperationType, expression, context.replaceExpectedType(leftType).replaceDataFlowInfo(rightInfo.getDataFlowInfo()));
@@ -328,33 +327,33 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @NotNull
-    protected JetTypeInfo visitAssignment(JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
+    protected JetTypeInfo visitAssignment(KtBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
         final ExpressionTypingContext context =
                 contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceScope(scope).replaceContextDependency(INDEPENDENT);
-        JetExpression leftOperand = expression.getLeft();
-        if (leftOperand instanceof JetAnnotatedExpression) {
+        KtExpression leftOperand = expression.getLeft();
+        if (leftOperand instanceof KtAnnotatedExpression) {
             // We will lose all annotations during deparenthesizing, so we have to resolve them right now
             components.annotationResolver.resolveAnnotationsWithArguments(
-                    scope, ((JetAnnotatedExpression) leftOperand).getAnnotationEntries(), context.trace
+                    scope, ((KtAnnotatedExpression) leftOperand).getAnnotationEntries(), context.trace
             );
         }
-        JetExpression left = deparenthesize(leftOperand);
-        JetExpression right = expression.getRight();
-        if (left instanceof JetArrayAccessExpression) {
-            JetArrayAccessExpression arrayAccessExpression = (JetArrayAccessExpression) left;
+        KtExpression left = deparenthesize(leftOperand);
+        KtExpression right = expression.getRight();
+        if (left instanceof KtArrayAccessExpression) {
+            KtArrayAccessExpression arrayAccessExpression = (KtArrayAccessExpression) left;
             if (right == null) return TypeInfoFactoryKt.noTypeInfo(context);
             JetTypeInfo typeInfo = basic.resolveArrayAccessSetMethod(arrayAccessExpression, right, context, context.trace);
             basic.checkLValue(context.trace, context, arrayAccessExpression, right);
             return typeInfo.replaceType(checkAssignmentType(typeInfo.getType(), expression, contextWithExpectedType));
         }
         JetTypeInfo leftInfo = ExpressionTypingUtils.getTypeInfoOrNullType(left, context, facade);
-        JetType leftType = leftInfo.getType();
+        KtType leftType = leftInfo.getType();
         DataFlowInfo dataFlowInfo = leftInfo.getDataFlowInfo();
         JetTypeInfo resultInfo;
         if (right != null) {
             resultInfo = facade.getTypeInfo(right, context.replaceDataFlowInfo(dataFlowInfo).replaceExpectedType(leftType));
             dataFlowInfo = resultInfo.getDataFlowInfo();
-            JetType rightType = resultInfo.getType();
+            KtType rightType = resultInfo.getType();
             if (left != null && leftType != null && rightType != null) {
                 DataFlowValue leftValue = DataFlowValueFactory.createDataFlowValue(left, leftType, context);
                 DataFlowValue rightValue = DataFlowValueFactory.createDataFlowValue(right, rightType, context);
@@ -373,55 +372,55 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
 
 
     @Override
-    public JetTypeInfo visitExpression(@NotNull JetExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitExpression(@NotNull KtExpression expression, ExpressionTypingContext context) {
         return facade.getTypeInfo(expression, context);
     }
 
     @Override
-    public JetTypeInfo visitJetElement(@NotNull JetElement element, ExpressionTypingContext context) {
+    public JetTypeInfo visitJetElement(@NotNull KtElement element, ExpressionTypingContext context) {
         context.trace.report(UNSUPPORTED.on(element, "in a block"));
         return TypeInfoFactoryKt.noTypeInfo(context);
     }
 
     @Override
-    public JetTypeInfo visitWhileExpression(@NotNull JetWhileExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitWhileExpression(@NotNull KtWhileExpression expression, ExpressionTypingContext context) {
         return controlStructures.visitWhileExpression(expression, context, true);
     }
 
     @Override
-    public JetTypeInfo visitDoWhileExpression(@NotNull JetDoWhileExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitDoWhileExpression(@NotNull KtDoWhileExpression expression, ExpressionTypingContext context) {
         return controlStructures.visitDoWhileExpression(expression, context, true);
     }
 
     @Override
-    public JetTypeInfo visitForExpression(@NotNull JetForExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitForExpression(@NotNull KtForExpression expression, ExpressionTypingContext context) {
         return controlStructures.visitForExpression(expression, context, true);
     }
 
     @Override
     public JetTypeInfo visitAnnotatedExpression(
-            @NotNull JetAnnotatedExpression expression, ExpressionTypingContext data
+            @NotNull KtAnnotatedExpression expression, ExpressionTypingContext data
     ) {
         return basic.visitAnnotatedExpression(expression, data, true);
     }
 
     @Override
-    public JetTypeInfo visitIfExpression(@NotNull JetIfExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitIfExpression(@NotNull KtIfExpression expression, ExpressionTypingContext context) {
         return controlStructures.visitIfExpression(expression, context, true);
     }
 
     @Override
-    public JetTypeInfo visitWhenExpression(@NotNull JetWhenExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitWhenExpression(@NotNull KtWhenExpression expression, ExpressionTypingContext context) {
         return patterns.visitWhenExpression(expression, context, true);
     }
 
     @Override
-    public JetTypeInfo visitBlockExpression(@NotNull JetBlockExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitBlockExpression(@NotNull KtBlockExpression expression, ExpressionTypingContext context) {
         return components.expressionTypingServices.getBlockReturnedType(expression, context, true);
     }
 
     @Override
-    public JetTypeInfo visitLabeledExpression(@NotNull JetLabeledExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitLabeledExpression(@NotNull KtLabeledExpression expression, ExpressionTypingContext context) {
         return basic.visitLabeledExpression(expression, context, true);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FakeCallResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FakeCallResolver.kt
index dc6edd58b99..df1c9270cbd 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FakeCallResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FakeCallResolver.kt
@@ -20,15 +20,15 @@ import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.Call
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.resolve.TemporaryBindingTrace
 import org.jetbrains.kotlin.resolve.calls.CallResolver
 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults
 import org.jetbrains.kotlin.resolve.calls.util.CallMaker
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.doNothing
 import java.util.*
 
@@ -40,11 +40,11 @@ public class FakeCallResolver(
             context: ExpressionTypingContext,
             receiver: ReceiverValue,
             name: Name,
-            callElement: JetExpression?,
-            vararg argumentTypes: JetType
+            callElement: KtExpression?,
+            vararg argumentTypes: KtType
     ): OverloadResolutionResults<FunctionDescriptor> {
         val traceWithFakeArgumentInfo = TemporaryBindingTrace.create(context.trace, "trace to store fake argument for", name)
-        val fakeArguments = ArrayList<JetExpression>()
+        val fakeArguments = ArrayList<KtExpression>()
         for (type in argumentTypes) {
             fakeArguments.add(ExpressionTypingUtils.createFakeExpressionOfType(project, traceWithFakeArgumentInfo, "fakeArgument" + fakeArguments.size(), type))
         }
@@ -55,7 +55,7 @@ public class FakeCallResolver(
             context: ExpressionTypingContext,
             receiver: ReceiverValue,
             name: Name,
-            callElement: JetExpression
+            callElement: KtExpression
     ): OverloadResolutionResults<FunctionDescriptor> {
         return resolveFakeCall(receiver, context, emptyList(), name, callElement)
     }
@@ -63,9 +63,9 @@ public class FakeCallResolver(
     public fun resolveFakeCall(
             receiver: ReceiverValue,
             context: ExpressionTypingContext,
-            valueArguments: List<JetExpression>,
+            valueArguments: List<KtExpression>,
             name: Name,
-            callElement: JetExpression
+            callElement: KtExpression
     ): OverloadResolutionResults<FunctionDescriptor> {
         return makeAndResolveFakeCall(receiver, context, valueArguments, name, callElement).second
     }
@@ -73,9 +73,9 @@ public class FakeCallResolver(
     public fun makeAndResolveFakeCall(
             receiver: ReceiverValue,
             context: ExpressionTypingContext,
-            valueArguments: List<JetExpression>,
+            valueArguments: List<KtExpression>,
             name: Name,
-            callElement: JetExpression?
+            callElement: KtExpression?
     ): Pair<Call, OverloadResolutionResults<FunctionDescriptor>> {
         val fakeTrace = TemporaryBindingTrace.create(context.trace, "trace to resolve fake call for", name)
         val fakeBindingTrace = context.replaceBindingTrace(fakeTrace)
@@ -92,12 +92,12 @@ public class FakeCallResolver(
     public fun makeAndResolveFakeCallInContext(
             receiver: ReceiverValue,
             context: ExpressionTypingContext,
-            valueArguments: List<JetExpression>,
+            valueArguments: List<KtExpression>,
             name: Name,
-            callElement: JetExpression?,
-            onSuccess: (JetSimpleNameExpression) -> Unit = doNothing()
+            callElement: KtExpression?,
+            onSuccess: (KtSimpleNameExpression) -> Unit = doNothing()
     ): Pair<Call, OverloadResolutionResults<FunctionDescriptor>> {
-        val fake = JetPsiFactory(project).createSimpleName(name.asString())
+        val fake = KtPsiFactory(project).createSimpleName(name.asString())
         val call = CallMaker.makeCallWithExpressions(callElement ?: fake, receiver, null, fake, valueArguments)
         val results = callResolver.resolveCallWithGivenName(context, call, fake, name)
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java
index 65192c9d392..4f87b6b4326 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java
@@ -26,18 +26,16 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1;
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.Call;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults;
-import org.jetbrains.kotlin.resolve.calls.tasks.DynamicCallsKt;
-import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver;
 import org.jetbrains.kotlin.resolve.validation.OperatorValidator;
 import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
 import org.jetbrains.kotlin.types.DynamicTypesKt;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
 
 import java.util.Collections;
@@ -62,14 +60,14 @@ public class ForLoopConventionsChecker {
     }
 
     @Nullable
-    public JetType checkIterableConvention(@NotNull ExpressionReceiver loopRange, ExpressionTypingContext context) {
-        JetExpression loopRangeExpression = loopRange.getExpression();
+    public KtType checkIterableConvention(@NotNull ExpressionReceiver loopRange, ExpressionTypingContext context) {
+        KtExpression loopRangeExpression = loopRange.getExpression();
 
         // Make a fake call loopRange.iterator(), and try to resolve it
         Name iterator = Name.identifier("iterator");
         Pair<Call, OverloadResolutionResults<FunctionDescriptor>> calls =
-                fakeCallResolver.makeAndResolveFakeCall(loopRange, context, Collections.<JetExpression>emptyList(), iterator,
-                                                             loopRange.getExpression());
+                fakeCallResolver.makeAndResolveFakeCall(loopRange, context, Collections.<KtExpression>emptyList(), iterator,
+                                                        loopRange.getExpression());
         OverloadResolutionResults<FunctionDescriptor> iteratorResolutionResults = calls.getSecond();
 
         if (iteratorResolutionResults.isSuccess()) {
@@ -81,10 +79,10 @@ public class ForLoopConventionsChecker {
 
             symbolUsageValidator.validateCall(iteratorResolvedCall, iteratorFunction, context.trace, loopRangeExpression);
 
-            JetType iteratorType = iteratorFunction.getReturnType();
-            JetType hasNextType = checkConventionForIterator(context, loopRangeExpression, iteratorType, "hasNext",
-                                                             HAS_NEXT_FUNCTION_AMBIGUITY, HAS_NEXT_MISSING, HAS_NEXT_FUNCTION_NONE_APPLICABLE,
-                                                             LOOP_RANGE_HAS_NEXT_RESOLVED_CALL);
+            KtType iteratorType = iteratorFunction.getReturnType();
+            KtType hasNextType = checkConventionForIterator(context, loopRangeExpression, iteratorType, "hasNext",
+                                                            HAS_NEXT_FUNCTION_AMBIGUITY, HAS_NEXT_MISSING, HAS_NEXT_FUNCTION_NONE_APPLICABLE,
+                                                            LOOP_RANGE_HAS_NEXT_RESOLVED_CALL);
             if (hasNextType != null && !builtIns.isBooleanOrSubtype(hasNextType)) {
                 context.trace.report(HAS_NEXT_FUNCTION_TYPE_MISMATCH.on(loopRangeExpression, hasNextType));
             }
@@ -103,7 +101,7 @@ public class ForLoopConventionsChecker {
         return null;
     }
 
-    private static void checkIfOperatorModifierPresent(JetExpression expression, FunctionDescriptor descriptor, DiagnosticSink sink) {
+    private static void checkIfOperatorModifierPresent(KtExpression expression, FunctionDescriptor descriptor, DiagnosticSink sink) {
         if (ErrorUtils.isError(descriptor)) return;
         ReceiverParameterDescriptor extensionReceiverParameter = descriptor.getExtensionReceiverParameter();
         if ((extensionReceiverParameter != null) && (DynamicTypesKt.isDynamic(extensionReceiverParameter.getType()))) return;
@@ -114,15 +112,15 @@ public class ForLoopConventionsChecker {
     }
 
     @Nullable
-    private JetType checkConventionForIterator(
+    private KtType checkConventionForIterator(
             @NotNull ExpressionTypingContext context,
-            @NotNull JetExpression loopRangeExpression,
-            @NotNull JetType iteratorType,
+            @NotNull KtExpression loopRangeExpression,
+            @NotNull KtType iteratorType,
             @NotNull String name,
-            @NotNull DiagnosticFactory1<JetExpression, JetType> ambiguity,
-            @NotNull DiagnosticFactory1<JetExpression, JetType> missing,
-            @NotNull DiagnosticFactory1<JetExpression, JetType> noneApplicable,
-            @NotNull WritableSlice<JetExpression, ResolvedCall<FunctionDescriptor>> resolvedCallKey
+            @NotNull DiagnosticFactory1<KtExpression, KtType> ambiguity,
+            @NotNull DiagnosticFactory1<KtExpression, KtType> missing,
+            @NotNull DiagnosticFactory1<KtExpression, KtType> noneApplicable,
+            @NotNull WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> resolvedCallKey
     ) {
         OverloadResolutionResults<FunctionDescriptor> nextResolutionResults = fakeCallResolver.resolveFakeCall(
                 context, new TransientReceiver(iteratorType), Name.identifier(name), loopRangeExpression);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt
index 114eca714e2..ba84ae96daf 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.diagnostics.Errors.*
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getAnnotationEntries
 import org.jetbrains.kotlin.resolve.*
@@ -34,23 +34,21 @@ import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
 import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope
 import org.jetbrains.kotlin.resolve.source.toSourceElement
 import org.jetbrains.kotlin.types.CommonSupertypes
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.TypeUtils.CANT_INFER_FUNCTION_PARAM_TYPE
-import org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE
-import org.jetbrains.kotlin.types.TypeUtils.noExpectedType
+import org.jetbrains.kotlin.types.TypeUtils.*
 import org.jetbrains.kotlin.types.expressions.CoercionStrategy.COERCION_TO_UNIT
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.createTypeInfo
 import org.jetbrains.kotlin.utils.addIfNotNull
 
 public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : ExpressionTypingVisitor(facade) {
 
-    override fun visitNamedFunction(function: JetNamedFunction, data: ExpressionTypingContext): JetTypeInfo {
+    override fun visitNamedFunction(function: KtNamedFunction, data: ExpressionTypingContext): JetTypeInfo {
         return visitNamedFunction(function, data, false, null)
     }
 
     public fun visitNamedFunction(
-            function: JetNamedFunction,
+            function: KtNamedFunction,
             context: ExpressionTypingContext,
             isStatement: Boolean,
             statementScope: LexicalWritableScope? // must be not null if isStatement
@@ -104,7 +102,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
 
         components.modifiersChecker.withTrace(context.trace).checkModifiersForLocalDeclaration(function, functionDescriptor)
         components.identifierChecker.checkDeclaration(function, context.trace)
-        if (!function.hasBody() && !function.hasModifier(JetTokens.EXTERNAL_KEYWORD)) {
+        if (!function.hasBody() && !function.hasModifier(KtTokens.EXTERNAL_KEYWORD)) {
             context.trace.report(NON_MEMBER_FUNCTION_NO_BODY.on(function, functionDescriptor))
         }
 
@@ -116,7 +114,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
         }
     }
 
-    private fun createFunctionType(functionDescriptor: SimpleFunctionDescriptor): JetType? {
+    private fun createFunctionType(functionDescriptor: SimpleFunctionDescriptor): KtType? {
         val receiverType = functionDescriptor.getExtensionReceiverParameter()?.getType()
 
         val returnType = functionDescriptor.getReturnType()
@@ -131,7 +129,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
         return components.builtIns.getFunctionType(Annotations.EMPTY, receiverType, parameters, returnType)
     }
 
-    override fun visitFunctionLiteralExpression(expression: JetFunctionLiteralExpression, context: ExpressionTypingContext): JetTypeInfo? {
+    override fun visitFunctionLiteralExpression(expression: KtFunctionLiteralExpression, context: ExpressionTypingContext): JetTypeInfo? {
         if (!expression.getFunctionLiteral().hasBody()) return null
 
         val expectedType = context.expectedType
@@ -155,7 +153,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
     }
 
     private fun createFunctionLiteralDescriptor(
-            expression: JetFunctionLiteralExpression,
+            expression: KtFunctionLiteralExpression,
             context: ExpressionTypingContext
     ): AnonymousFunctionDescriptor {
         val functionLiteral = expression.getFunctionLiteral()
@@ -175,11 +173,11 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
     }
 
     private fun computeReturnType(
-            expression: JetFunctionLiteralExpression,
+            expression: KtFunctionLiteralExpression,
             context: ExpressionTypingContext,
             functionDescriptor: SimpleFunctionDescriptorImpl,
             functionTypeExpected: Boolean
-    ): JetType {
+    ): KtType {
         val expectedReturnType = if (functionTypeExpected) KotlinBuiltIns.getReturnTypeFromFunctionType(context.expectedType) else null
         val returnType = computeUnsafeReturnType(expression, context, functionDescriptor, expectedReturnType);
 
@@ -192,11 +190,11 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
     }
 
     private fun computeUnsafeReturnType(
-            expression: JetFunctionLiteralExpression,
+            expression: KtFunctionLiteralExpression,
             context: ExpressionTypingContext,
             functionDescriptor: SimpleFunctionDescriptorImpl,
-            expectedReturnType: JetType?
-    ): JetType? {
+            expectedReturnType: KtType?
+    ): KtType? {
         val functionLiteral = expression.getFunctionLiteral()
 
         val expectedType = expectedReturnType ?: NO_EXPECTED_TYPE
@@ -212,11 +210,11 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
     }
 
     private fun computeReturnTypeBasedOnReturnExpressions(
-            functionLiteral: JetFunctionLiteral,
+            functionLiteral: KtFunctionLiteral,
             context: ExpressionTypingContext,
-            typeOfBodyExpression: JetType?
-    ): JetType? {
-        val returnedExpressionTypes = Lists.newArrayList<JetType>()
+            typeOfBodyExpression: KtType?
+    ): KtType? {
+        val returnedExpressionTypes = Lists.newArrayList<KtType>()
 
         var hasEmptyReturn = false
         val returnExpressions = collectReturns(functionLiteral, context.trace)
@@ -249,11 +247,11 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
         return CommonSupertypes.commonSupertype(returnedExpressionTypes)
     }
 
-    private fun collectReturns(functionLiteral: JetFunctionLiteral, trace: BindingTrace): Collection<JetReturnExpression> {
-        val result = Lists.newArrayList<JetReturnExpression>()
+    private fun collectReturns(functionLiteral: KtFunctionLiteral, trace: BindingTrace): Collection<KtReturnExpression> {
+        val result = Lists.newArrayList<KtReturnExpression>()
         val bodyExpression = functionLiteral.getBodyExpression()
-        bodyExpression?.accept(object : JetTreeVisitor<MutableList<JetReturnExpression>>() {
-            override fun visitReturnExpression(expression: JetReturnExpression, data: MutableList<JetReturnExpression>): Void? {
+        bodyExpression?.accept(object : KtTreeVisitor<MutableList<KtReturnExpression>>() {
+            override fun visitReturnExpression(expression: KtReturnExpression, data: MutableList<KtReturnExpression>): Void? {
                 data.add(expression)
                 return null
             }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/JetTypeInfo.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/JetTypeInfo.kt
index b13a7371986..db89f14fd11 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/JetTypeInfo.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/JetTypeInfo.kt
@@ -16,11 +16,8 @@
 
 package org.jetbrains.kotlin.types.expressions
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 /**
  * Stores simultaneously type of current expression together with data flow info
@@ -34,7 +31,7 @@ import org.jetbrains.kotlin.types.JetType
  * Both break and continue are counted as possible jump outside of a loop, but return is not.
  */
 /*package*/ open class JetTypeInfo(
-        val type: JetType?,
+        val type: KtType?,
         val dataFlowInfo: DataFlowInfo,
         val jumpOutPossible: Boolean = false,
         val jumpFlowInfo: DataFlowInfo = dataFlowInfo
@@ -43,7 +40,7 @@ import org.jetbrains.kotlin.types.JetType
     fun clearType() = replaceType(null)
 
     // NB: do not compare type with this.type because this comparison is complex and unstabld
-    fun replaceType(type: JetType?) = JetTypeInfo(type, dataFlowInfo, jumpOutPossible, jumpFlowInfo)
+    fun replaceType(type: KtType?) = JetTypeInfo(type, dataFlowInfo, jumpOutPossible, jumpFlowInfo)
 
     fun replaceJumpOutPossible(jumpOutPossible: Boolean) =
             if (jumpOutPossible == this.jumpOutPossible) this else JetTypeInfo(type, dataFlowInfo, jumpOutPossible, jumpFlowInfo)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LabelResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LabelResolver.java
index 0ba0ed29434..01b7552a1ce 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LabelResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LabelResolver.java
@@ -42,13 +42,13 @@ public class LabelResolver {
     private LabelResolver() {}
 
     @NotNull
-    private Set<JetElement> getElementsByLabelName(@NotNull Name labelName, @NotNull JetSimpleNameExpression labelExpression) {
-        Set<JetElement> elements = Sets.newLinkedHashSet();
+    private Set<KtElement> getElementsByLabelName(@NotNull Name labelName, @NotNull KtSimpleNameExpression labelExpression) {
+        Set<KtElement> elements = Sets.newLinkedHashSet();
         PsiElement parent = labelExpression.getParent();
         while (parent != null) {
             Name name = getLabelNameIfAny(parent);
             if (name != null && name.equals(labelName)) {
-                elements.add(getExpressionUnderLabel((JetExpression) parent));
+                elements.add(getExpressionUnderLabel((KtExpression) parent));
             }
             parent = parent.getParent();
         }
@@ -57,51 +57,51 @@ public class LabelResolver {
 
     @Nullable
     public Name getLabelNameIfAny(@NotNull PsiElement element) {
-        if (element instanceof JetLabeledExpression) {
-            return ((JetLabeledExpression) element).getLabelNameAsName();
+        if (element instanceof KtLabeledExpression) {
+            return ((KtLabeledExpression) element).getLabelNameAsName();
         }
 
-        if (element instanceof JetFunctionLiteral) {
+        if (element instanceof KtFunctionLiteral) {
             return getLabelNameIfAny(element.getParent());
         }
 
-        if (element instanceof JetFunctionLiteralExpression) {
-            return getLabelForFunctionalExpression((JetExpression) element);
+        if (element instanceof KtFunctionLiteralExpression) {
+            return getLabelForFunctionalExpression((KtExpression) element);
         }
 
-        if (element instanceof JetNamedFunction) {
-            Name name = ((JetNamedFunction) element).getNameAsName();
+        if (element instanceof KtNamedFunction) {
+            Name name = ((KtNamedFunction) element).getNameAsName();
             if (name != null) return name;
-            return getLabelForFunctionalExpression((JetExpression) element);
+            return getLabelForFunctionalExpression((KtExpression) element);
         }
 
         return null;
     }
 
-    private Name getLabelForFunctionalExpression(@NotNull JetExpression element) {
-        if (element.getParent() instanceof JetLabeledExpression) {
+    private Name getLabelForFunctionalExpression(@NotNull KtExpression element) {
+        if (element.getParent() instanceof KtLabeledExpression) {
             return getLabelNameIfAny(element.getParent());
         }
         return getCallerName(element);
     }
 
     @NotNull
-    private JetExpression getExpressionUnderLabel(@NotNull JetExpression labeledExpression) {
-        JetExpression expression = JetPsiUtil.safeDeparenthesize(labeledExpression);
-        if (expression instanceof JetFunctionLiteralExpression) {
-            return ((JetFunctionLiteralExpression) expression).getFunctionLiteral();
+    private KtExpression getExpressionUnderLabel(@NotNull KtExpression labeledExpression) {
+        KtExpression expression = KtPsiUtil.safeDeparenthesize(labeledExpression);
+        if (expression instanceof KtFunctionLiteralExpression) {
+            return ((KtFunctionLiteralExpression) expression).getFunctionLiteral();
         }
         return expression;
     }
 
     @Nullable
-    private Name getCallerName(@NotNull JetExpression expression) {
-        JetCallExpression callExpression = getContainingCallExpression(expression);
+    private Name getCallerName(@NotNull KtExpression expression) {
+        KtCallExpression callExpression = getContainingCallExpression(expression);
         if (callExpression == null) return null;
 
-        JetExpression calleeExpression = callExpression.getCalleeExpression();
-        if (calleeExpression instanceof JetSimpleNameExpression) {
-            JetSimpleNameExpression nameExpression = (JetSimpleNameExpression) calleeExpression;
+        KtExpression calleeExpression = callExpression.getCalleeExpression();
+        if (calleeExpression instanceof KtSimpleNameExpression) {
+            KtSimpleNameExpression nameExpression = (KtSimpleNameExpression) calleeExpression;
             return nameExpression.getReferencedNameAsName();
         }
 
@@ -109,35 +109,35 @@ public class LabelResolver {
     }
 
     @Nullable
-    private JetCallExpression getContainingCallExpression(@NotNull JetExpression expression) {
+    private KtCallExpression getContainingCallExpression(@NotNull KtExpression expression) {
         PsiElement parent = expression.getParent();
-        if (parent instanceof JetFunctionLiteralArgument) {
+        if (parent instanceof KtFunctionLiteralArgument) {
             // f {}
             PsiElement call = parent.getParent();
-            if (call instanceof JetCallExpression) {
-                return (JetCallExpression) call;
+            if (call instanceof KtCallExpression) {
+                return (KtCallExpression) call;
             }
         }
 
-        if (parent instanceof JetValueArgument) {
+        if (parent instanceof KtValueArgument) {
             // f ({}) or f(p = {}) or f (fun () {})
-            JetValueArgument argument = (JetValueArgument) parent;
+            KtValueArgument argument = (KtValueArgument) parent;
             PsiElement argList = argument.getParent();
             if (argList == null) return null;
             PsiElement call = argList.getParent();
-            if (call instanceof JetCallExpression) {
-                return (JetCallExpression) call;
+            if (call instanceof KtCallExpression) {
+                return (KtCallExpression) call;
             }
         }
         return null;
     }
 
     @Nullable
-    public JetElement resolveControlLabel(
-            @NotNull JetExpressionWithLabel expression,
+    public KtElement resolveControlLabel(
+            @NotNull KtExpressionWithLabel expression,
             @NotNull ResolutionContext context
     ) {
-        JetSimpleNameExpression labelElement = expression.getTargetLabel();
+        KtSimpleNameExpression labelElement = expression.getTargetLabel();
         Name labelName = expression.getLabelNameAsName();
         if (labelElement == null || labelName == null) return null;
 
@@ -149,16 +149,16 @@ public class LabelResolver {
             return null;
         }
         if (size == 0) {
-            JetElement element = resolveNamedLabel(labelName, labelElement, context.trace);
+            KtElement element = resolveNamedLabel(labelName, labelElement, context.trace);
             if (element == null) {
                 context.trace.report(UNRESOLVED_REFERENCE.on(labelElement, labelElement));
             }
             return element;
         }
         DeclarationDescriptor declarationDescriptor = declarationsByLabel.iterator().next();
-        JetElement element;
+        KtElement element;
         if (declarationDescriptor instanceof FunctionDescriptor || declarationDescriptor instanceof ClassDescriptor) {
-            element = (JetElement) DescriptorToSourceUtils.descriptorToDeclaration(declarationDescriptor);
+            element = (KtElement) DescriptorToSourceUtils.descriptorToDeclaration(declarationDescriptor);
         }
         else {
             throw new UnsupportedOperationException(declarationDescriptor.getClass().toString()); // TODO
@@ -167,31 +167,31 @@ public class LabelResolver {
         return element;
     }
 
-    private JetElement resolveNamedLabel(
+    private KtElement resolveNamedLabel(
             @NotNull Name labelName, 
-            @NotNull JetSimpleNameExpression labelExpression, 
+            @NotNull KtSimpleNameExpression labelExpression,
             @NotNull BindingTrace trace
     ) {
-        Set<JetElement> list = getElementsByLabelName(labelName, labelExpression);
+        Set<KtElement> list = getElementsByLabelName(labelName, labelExpression);
         if (list.isEmpty()) return null;
 
         if (list.size() > 1) {
             trace.report(LABEL_NAME_CLASH.on(labelExpression));
         }
 
-        JetElement result = list.iterator().next();
+        KtElement result = list.iterator().next();
         trace.record(LABEL_TARGET, labelExpression, result);
         return result;
     }
     
     @NotNull
     public LabeledReceiverResolutionResult resolveThisOrSuperLabel(
-            @NotNull JetInstanceExpressionWithLabel expression,
+            @NotNull KtInstanceExpressionWithLabel expression,
             @NotNull ResolutionContext context,
             @NotNull Name labelName
     ) {
-        JetReferenceExpression referenceExpression = expression.getInstanceReference();
-        JetSimpleNameExpression targetLabel = expression.getTargetLabel();
+        KtReferenceExpression referenceExpression = expression.getInstanceReference();
+        KtSimpleNameExpression targetLabel = expression.getTargetLabel();
         assert targetLabel != null : expression;
 
         Collection<DeclarationDescriptor> declarationsByLabel = ScopeUtilsKt.getDeclarationsByLabel(context.scope, labelName);
@@ -229,8 +229,8 @@ public class LabelResolver {
             return LabeledReceiverResolutionResult.labelResolutionSuccess(thisReceiver);
         }
         else if (size == 0) {
-            JetElement element = resolveNamedLabel(labelName, targetLabel, context.trace);
-            if (element instanceof JetFunctionLiteral) {
+            KtElement element = resolveNamedLabel(labelName, targetLabel, context.trace);
+            if (element instanceof KtFunctionLiteral) {
                 DeclarationDescriptor declarationDescriptor =
                         context.trace.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, element);
                 if (declarationDescriptor instanceof FunctionDescriptor) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt
index 6e2946038ef..795c51444c1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.frontend.di.createContainerForLazyLocalClassifierAna
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.debugText.getDebugText
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
@@ -60,7 +60,7 @@ public class LocalClassifierAnalyzer(
             scope: LexicalWritableScope?,
             context: ExpressionTypingContext,
             containingDeclaration: DeclarationDescriptor,
-            classOrObject: JetClassOrObject
+            classOrObject: KtClassOrObject
     ) {
         val module = DescriptorUtils.getContainingModule(containingDeclaration)
         val moduleContext = globalContext.withProject(classOrObject.getProject()).withModule(module)
@@ -92,7 +92,7 @@ public class LocalClassifierAnalyzer(
 
 class LocalClassDescriptorHolder(
         val writableScope: LexicalWritableScope?,
-        val myClass: JetClassOrObject,
+        val myClass: KtClassOrObject,
         val containingDeclaration: DeclarationDescriptor,
         val storageManager: StorageManager,
         val expressionTypingContext: ExpressionTypingContext,
@@ -108,7 +108,7 @@ class LocalClassDescriptorHolder(
     fun isMyClass(element: PsiElement): Boolean = element == myClass
     fun insideMyClass(element: PsiElement): Boolean = PsiTreeUtil.isAncestor(myClass, element, false)
 
-    fun getClassDescriptor(classOrObject: JetClassOrObject, declarationScopeProvider: DeclarationScopeProvider): ClassDescriptor {
+    fun getClassDescriptor(classOrObject: KtClassOrObject, declarationScopeProvider: DeclarationScopeProvider): ClassDescriptor {
         assert(isMyClass(classOrObject)) { "Called on a wrong class: ${classOrObject.getDebugText()}" }
         if (classDescriptor == null) {
             classDescriptor = LazyClassDescriptor(
@@ -144,7 +144,7 @@ class LocalClassDescriptorHolder(
         return classDescriptor!!
     }
 
-    fun getResolutionScopeForClass(classOrObject: JetClassOrObject): LexicalScope {
+    fun getResolutionScopeForClass(classOrObject: KtClassOrObject): LexicalScope {
         assert (isMyClass(classOrObject)) { "Called on a wrong class: ${classOrObject.getDebugText()}" }
         return expressionTypingContext.scope
     }
@@ -157,7 +157,7 @@ class LocalLazyDeclarationResolver(
         topLevelDescriptorProvider : TopLevelDescriptorProvider
 ) : LazyDeclarationResolver(globalContext, trace, topLevelDescriptorProvider) {
 
-    override fun getClassDescriptor(classOrObject: JetClassOrObject, location: LookupLocation): ClassDescriptor {
+    override fun getClassDescriptor(classOrObject: KtClassOrObject, location: LookupLocation): ClassDescriptor {
         if (localClassDescriptorManager.isMyClass(classOrObject)) {
             return localClassDescriptorManager.getClassDescriptor(classOrObject, scopeProvider)
         }
@@ -173,7 +173,7 @@ class DeclarationScopeProviderForLocalClassifierAnalyzer(
 ) : DeclarationScopeProviderImpl(lazyDeclarationResolver, fileScopeProvider) {
     override fun getResolutionScopeForDeclaration(elementOfDeclaration: PsiElement): LexicalScope {
         if (localClassDescriptorManager.isMyClass(elementOfDeclaration)) {
-            return localClassDescriptorManager.getResolutionScopeForClass(elementOfDeclaration as JetClassOrObject)
+            return localClassDescriptorManager.getResolutionScopeForClass(elementOfDeclaration as KtClassOrObject)
         }
         return super.getResolutionScopeForDeclaration(elementOfDeclaration)
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/MultiDeclarationResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/MultiDeclarationResolver.kt
index 5fdf43562b0..f7b4878f389 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/MultiDeclarationResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/MultiDeclarationResolver.kt
@@ -17,9 +17,9 @@
 package org.jetbrains.kotlin.types.expressions
 
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetMultiDeclaration
-import org.jetbrains.kotlin.psi.JetMultiDeclarationEntry
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtMultiDeclaration
+import org.jetbrains.kotlin.psi.KtMultiDeclarationEntry
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorResolver
 import org.jetbrains.kotlin.resolve.TypeResolver
@@ -29,9 +29,9 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.resolve.scopes.utils.getLocalVariable
 import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 
 public class MultiDeclarationResolver(
         private val fakeCallResolver: FakeCallResolver,
@@ -41,9 +41,9 @@ public class MultiDeclarationResolver(
 ) {
     public fun defineLocalVariablesFromMultiDeclaration(
             writableScope: LexicalWritableScope,
-            multiDeclaration: JetMultiDeclaration,
+            multiDeclaration: KtMultiDeclaration,
             receiver: ReceiverValue,
-            reportErrorsOn: JetExpression,
+            reportErrorsOn: KtExpression,
             context: ExpressionTypingContext
     ) {
         for ((componentIndex, entry) in multiDeclaration.getEntries().withIndex()) {
@@ -52,7 +52,7 @@ public class MultiDeclarationResolver(
             val expectedType = getExpectedTypeForComponent(context, entry)
             val results = fakeCallResolver.resolveFakeCall(context.replaceExpectedType(expectedType), receiver, componentName, entry)
 
-            var componentType: JetType? = null
+            var componentType: KtType? = null
             if (results.isSuccess()) {
                 context.trace.record(BindingContext.COMPONENT_RESOLVED_CALL, entry, results.getResultingCall())
 
@@ -60,7 +60,7 @@ public class MultiDeclarationResolver(
                 symbolUsageValidator.validateCall(null, functionDescriptor, context.trace, entry)
 
                 componentType = functionDescriptor.getReturnType()
-                if (componentType != null && !TypeUtils.noExpectedType(expectedType) && !JetTypeChecker.DEFAULT.isSubtypeOf(componentType, expectedType)) {
+                if (componentType != null && !TypeUtils.noExpectedType(expectedType) && !KotlinTypeChecker.DEFAULT.isSubtypeOf(componentType, expectedType)) {
                     context.trace.report(Errors.COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH.on(reportErrorsOn, componentName, componentType, expectedType))
                 }
             }
@@ -82,7 +82,7 @@ public class MultiDeclarationResolver(
         }
     }
 
-    private fun getExpectedTypeForComponent(context: ExpressionTypingContext, entry: JetMultiDeclarationEntry): JetType {
+    private fun getExpectedTypeForComponent(context: ExpressionTypingContext, entry: KtMultiDeclarationEntry): KtType {
         val entryTypeRef = entry.getTypeReference() ?: return TypeUtils.NO_EXPECTED_TYPE
         return typeResolver.resolveType(context.scope, entryTypeRef, context.trace, true)
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/OperatorConventions.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/OperatorConventions.java
index 448bcea3ae6..6f6ec9612c3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/OperatorConventions.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/OperatorConventions.java
@@ -21,13 +21,11 @@ import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetSingleValueToken;
-import org.jetbrains.kotlin.lexer.JetToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtSingleValueToken;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.Name;
 
-import java.util.Map;
-
 import static org.jetbrains.kotlin.util.OperatorNameConventions.*;
 
 public class OperatorConventions {
@@ -50,70 +48,70 @@ public class OperatorConventions {
 
     // If you add new unary, binary or assignment operators, add it to OperatorConventionNames as well
 
-    public static final ImmutableBiMap<JetSingleValueToken, Name> UNARY_OPERATION_NAMES = ImmutableBiMap.<JetSingleValueToken, Name>builder()
-            .put(JetTokens.PLUSPLUS, INC)
-            .put(JetTokens.MINUSMINUS, DEC)
-            .put(JetTokens.PLUS, UNARY_PLUS)
-            .put(JetTokens.MINUS, UNARY_MINUS)
-            .put(JetTokens.EXCL, NOT)
+    public static final ImmutableBiMap<KtSingleValueToken, Name> UNARY_OPERATION_NAMES = ImmutableBiMap.<KtSingleValueToken, Name>builder()
+            .put(KtTokens.PLUSPLUS, INC)
+            .put(KtTokens.MINUSMINUS, DEC)
+            .put(KtTokens.PLUS, UNARY_PLUS)
+            .put(KtTokens.MINUS, UNARY_MINUS)
+            .put(KtTokens.EXCL, NOT)
             .build();
 
-    public static final ImmutableMap<Name, JetSingleValueToken> UNARY_OPERATION_NAMES_WITH_DEPRECATED_INVERTED = ImmutableMap.<Name, JetSingleValueToken>builder()
-            .put(INC, JetTokens.PLUSPLUS)
-            .put(DEC, JetTokens.MINUSMINUS)
-            .put(UNARY_PLUS, JetTokens.PLUS)
-            .put(PLUS, JetTokens.PLUS)
-            .put(UNARY_MINUS, JetTokens.MINUS)
-            .put(MINUS, JetTokens.MINUS)
-            .put(NOT, JetTokens.EXCL)
+    public static final ImmutableMap<Name, KtSingleValueToken> UNARY_OPERATION_NAMES_WITH_DEPRECATED_INVERTED = ImmutableMap.<Name, KtSingleValueToken>builder()
+            .put(INC, KtTokens.PLUSPLUS)
+            .put(DEC, KtTokens.MINUSMINUS)
+            .put(UNARY_PLUS, KtTokens.PLUS)
+            .put(PLUS, KtTokens.PLUS)
+            .put(UNARY_MINUS, KtTokens.MINUS)
+            .put(MINUS, KtTokens.MINUS)
+            .put(NOT, KtTokens.EXCL)
             .build();
 
-    public static final ImmutableBiMap<JetSingleValueToken, Name> BINARY_OPERATION_NAMES = ImmutableBiMap.<JetSingleValueToken, Name>builder()
-            .put(JetTokens.MUL, TIMES)
-            .put(JetTokens.PLUS, PLUS)
-            .put(JetTokens.MINUS, MINUS)
-            .put(JetTokens.DIV, DIV)
-            .put(JetTokens.PERC, MOD)
-            .put(JetTokens.RANGE, RANGE_TO)
+    public static final ImmutableBiMap<KtSingleValueToken, Name> BINARY_OPERATION_NAMES = ImmutableBiMap.<KtSingleValueToken, Name>builder()
+            .put(KtTokens.MUL, TIMES)
+            .put(KtTokens.PLUS, PLUS)
+            .put(KtTokens.MINUS, MINUS)
+            .put(KtTokens.DIV, DIV)
+            .put(KtTokens.PERC, MOD)
+            .put(KtTokens.RANGE, RANGE_TO)
             .build();
 
-    public static final ImmutableSet<JetSingleValueToken> NOT_OVERLOADABLE =
-            ImmutableSet.of(JetTokens.ANDAND, JetTokens.OROR, JetTokens.ELVIS, JetTokens.EQEQEQ, JetTokens.EXCLEQEQEQ);
+    public static final ImmutableSet<KtSingleValueToken> NOT_OVERLOADABLE =
+            ImmutableSet.of(KtTokens.ANDAND, KtTokens.OROR, KtTokens.ELVIS, KtTokens.EQEQEQ, KtTokens.EXCLEQEQEQ);
     
-    public static final ImmutableSet<JetSingleValueToken> INCREMENT_OPERATIONS =
-            ImmutableSet.of(JetTokens.PLUSPLUS, JetTokens.MINUSMINUS);
+    public static final ImmutableSet<KtSingleValueToken> INCREMENT_OPERATIONS =
+            ImmutableSet.of(KtTokens.PLUSPLUS, KtTokens.MINUSMINUS);
 
-    public static final ImmutableSet<JetSingleValueToken> COMPARISON_OPERATIONS =
-            ImmutableSet.of(JetTokens.LT, JetTokens.GT, JetTokens.LTEQ, JetTokens.GTEQ);
+    public static final ImmutableSet<KtSingleValueToken> COMPARISON_OPERATIONS =
+            ImmutableSet.of(KtTokens.LT, KtTokens.GT, KtTokens.LTEQ, KtTokens.GTEQ);
 
-    public static final ImmutableSet<JetSingleValueToken> EQUALS_OPERATIONS =
-            ImmutableSet.of(JetTokens.EQEQ, JetTokens.EXCLEQ);
+    public static final ImmutableSet<KtSingleValueToken> EQUALS_OPERATIONS =
+            ImmutableSet.of(KtTokens.EQEQ, KtTokens.EXCLEQ);
 
-    public static final ImmutableSet<JetSingleValueToken> IDENTITY_EQUALS_OPERATIONS =
-            ImmutableSet.of(JetTokens.EQEQEQ, JetTokens.EXCLEQEQEQ);
+    public static final ImmutableSet<KtSingleValueToken> IDENTITY_EQUALS_OPERATIONS =
+            ImmutableSet.of(KtTokens.EQEQEQ, KtTokens.EXCLEQEQEQ);
 
-    public static final ImmutableSet<JetSingleValueToken> IN_OPERATIONS =
-            ImmutableSet.<JetSingleValueToken>of(JetTokens.IN_KEYWORD, JetTokens.NOT_IN);
+    public static final ImmutableSet<KtSingleValueToken> IN_OPERATIONS =
+            ImmutableSet.<KtSingleValueToken>of(KtTokens.IN_KEYWORD, KtTokens.NOT_IN);
 
-    public static final ImmutableBiMap<JetSingleValueToken, Name> ASSIGNMENT_OPERATIONS = ImmutableBiMap.<JetSingleValueToken, Name>builder()
-            .put(JetTokens.MULTEQ, TIMES_ASSIGN)
-            .put(JetTokens.DIVEQ, DIV_ASSIGN)
-            .put(JetTokens.PERCEQ, MOD_ASSIGN)
-            .put(JetTokens.PLUSEQ, PLUS_ASSIGN)
-            .put(JetTokens.MINUSEQ, MINUS_ASSIGN)
+    public static final ImmutableBiMap<KtSingleValueToken, Name> ASSIGNMENT_OPERATIONS = ImmutableBiMap.<KtSingleValueToken, Name>builder()
+            .put(KtTokens.MULTEQ, TIMES_ASSIGN)
+            .put(KtTokens.DIVEQ, DIV_ASSIGN)
+            .put(KtTokens.PERCEQ, MOD_ASSIGN)
+            .put(KtTokens.PLUSEQ, PLUS_ASSIGN)
+            .put(KtTokens.MINUSEQ, MINUS_ASSIGN)
             .build();
 
-    public static final ImmutableBiMap<JetSingleValueToken, JetSingleValueToken> ASSIGNMENT_OPERATION_COUNTERPARTS = ImmutableBiMap.<JetSingleValueToken, JetSingleValueToken>builder()
-            .put(JetTokens.MULTEQ, JetTokens.MUL)
-            .put(JetTokens.DIVEQ, JetTokens.DIV)
-            .put(JetTokens.PERCEQ, JetTokens.PERC)
-            .put(JetTokens.PLUSEQ, JetTokens.PLUS)
-            .put(JetTokens.MINUSEQ, JetTokens.MINUS)
+    public static final ImmutableBiMap<KtSingleValueToken, KtSingleValueToken> ASSIGNMENT_OPERATION_COUNTERPARTS = ImmutableBiMap.<KtSingleValueToken, KtSingleValueToken>builder()
+            .put(KtTokens.MULTEQ, KtTokens.MUL)
+            .put(KtTokens.DIVEQ, KtTokens.DIV)
+            .put(KtTokens.PERCEQ, KtTokens.PERC)
+            .put(KtTokens.PLUSEQ, KtTokens.PLUS)
+            .put(KtTokens.MINUSEQ, KtTokens.MINUS)
             .build();
 
-    public static final ImmutableBiMap<JetSingleValueToken, Name> BOOLEAN_OPERATIONS = ImmutableBiMap.<JetSingleValueToken, Name>builder()
-             .put(JetTokens.ANDAND, AND)
-             .put(JetTokens.OROR, OR)
+    public static final ImmutableBiMap<KtSingleValueToken, Name> BOOLEAN_OPERATIONS = ImmutableBiMap.<KtSingleValueToken, Name>builder()
+             .put(KtTokens.ANDAND, AND)
+             .put(KtTokens.OROR, OR)
              .build();
 
     public static final ImmutableSet<Name> CONVENTION_NAMES = ImmutableSet.<Name>builder()
@@ -124,12 +122,12 @@ public class OperatorConventions {
             .build();
 
     @Nullable
-    public static Name getNameForOperationSymbol(@NotNull JetToken token) {
+    public static Name getNameForOperationSymbol(@NotNull KtToken token) {
         return getNameForOperationSymbol(token, true, true);
     }
 
     @Nullable
-    public static Name getNameForOperationSymbol(@NotNull JetToken token, boolean unaryOperations, boolean binaryOperations) {
+    public static Name getNameForOperationSymbol(@NotNull KtToken token, boolean unaryOperations, boolean binaryOperations) {
         Name name;
 
         if (binaryOperations) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.java
index a841bfc0044..846078647e3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.java
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory;
 import org.jetbrains.kotlin.resolve.calls.util.CallMaker;
 import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope;
 import org.jetbrains.kotlin.types.*;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt;
 
 import java.util.Collections;
@@ -53,13 +53,13 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitIsExpression(@NotNull JetIsExpression expression, ExpressionTypingContext contextWithExpectedType) {
+    public JetTypeInfo visitIsExpression(@NotNull KtIsExpression expression, ExpressionTypingContext contextWithExpectedType) {
         ExpressionTypingContext context = contextWithExpectedType
                                             .replaceExpectedType(NO_EXPECTED_TYPE)
                                             .replaceContextDependency(INDEPENDENT);
-        JetExpression leftHandSide = expression.getLeftHandSide();
+        KtExpression leftHandSide = expression.getLeftHandSide();
         JetTypeInfo typeInfo = facade.safeGetTypeInfo(leftHandSide, context.replaceScope(context.scope));
-        JetType knownType = typeInfo.getType();
+        KtType knownType = typeInfo.getType();
         if (expression.getTypeReference() != null) {
             DataFlowValue dataFlowValue = DataFlowValueFactory.createDataFlowValue(leftHandSide, knownType, context);
             DataFlowInfo conditionInfo = checkTypeForIs(context, knownType, expression.getTypeReference(), dataFlowValue).thenInfo;
@@ -70,18 +70,18 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitWhenExpression(@NotNull JetWhenExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitWhenExpression(@NotNull KtWhenExpression expression, ExpressionTypingContext context) {
         return visitWhenExpression(expression, context, false);
     }
 
-    public JetTypeInfo visitWhenExpression(JetWhenExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
+    public JetTypeInfo visitWhenExpression(KtWhenExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
         components.dataFlowAnalyzer.recordExpectedType(contextWithExpectedType.trace, expression, contextWithExpectedType.expectedType);
 
         ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT);
         // TODO :change scope according to the bound value in the when header
-        JetExpression subjectExpression = expression.getSubjectExpression();
+        KtExpression subjectExpression = expression.getSubjectExpression();
 
-        JetType subjectType;
+        KtType subjectType;
         boolean loopBreakContinuePossible = false;
         if (subjectExpression == null) {
             subjectType = ErrorUtils.createErrorType("Unknown type");
@@ -93,7 +93,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
             assert subjectType != null;
             if (TypeUtils.isNullableType(subjectType) && !WhenChecker.containsNullCase(expression, context.trace)) {
                 ExpressionTypingContext subjectContext = context.replaceExpectedType(TypeUtils.makeNotNullable(subjectType));
-                components.dataFlowAnalyzer.checkPossibleCast(subjectType, JetPsiUtil.safeDeparenthesize(subjectExpression), subjectContext);
+                components.dataFlowAnalyzer.checkPossibleCast(subjectType, KtPsiUtil.safeDeparenthesize(subjectExpression), subjectContext);
             }
             context = context.replaceDataFlowInfo(typeInfo.getDataFlowInfo());
         }
@@ -103,15 +103,15 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
 
         // TODO : exhaustive patterns
 
-        Set<JetType> expressionTypes = Sets.newHashSet();
+        Set<KtType> expressionTypes = Sets.newHashSet();
         DataFlowInfo commonDataFlowInfo = null;
         DataFlowInfo elseDataFlowInfo = context.dataFlowInfo;
-        for (JetWhenEntry whenEntry : expression.getEntries()) {
+        for (KtWhenEntry whenEntry : expression.getEntries()) {
             DataFlowInfos infosForCondition = getDataFlowInfosForEntryCondition(
                     whenEntry, context.replaceDataFlowInfo(elseDataFlowInfo), subjectExpression, subjectType, subjectDataFlowValue);
             elseDataFlowInfo = elseDataFlowInfo.and(infosForCondition.elseInfo);
 
-            JetExpression bodyExpression = whenEntry.getExpression();
+            KtExpression bodyExpression = whenEntry.getExpression();
             if (bodyExpression != null) {
                 LexicalWritableScope scopeToExtend = newWritableScopeImpl(context, "Scope extended in when entry");
                 ExpressionTypingContext newContext = contextWithExpectedType
@@ -120,7 +120,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
                 JetTypeInfo typeInfo = components.expressionTypingServices.getBlockReturnedTypeWithWritableScope(
                         scopeToExtend, Collections.singletonList(bodyExpression), coercionStrategy, newContext);
                 loopBreakContinuePossible |= typeInfo.getJumpOutPossible();
-                JetType type = typeInfo.getType();
+                KtType type = typeInfo.getType();
                 if (type != null) {
                     expressionTypes.add(type);
                 }
@@ -154,10 +154,10 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
 
     @NotNull
     private DataFlowInfos getDataFlowInfosForEntryCondition(
-            @NotNull JetWhenEntry whenEntry,
+            @NotNull KtWhenEntry whenEntry,
             @NotNull ExpressionTypingContext context,
-            @Nullable JetExpression subjectExpression,
-            @NotNull JetType subjectType,
+            @Nullable KtExpression subjectExpression,
+            @NotNull KtType subjectType,
             @NotNull DataFlowValue subjectDataFlowValue
     ) {
         if (whenEntry.isElse()) {
@@ -166,7 +166,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
 
         DataFlowInfos infos = null;
         ExpressionTypingContext contextForCondition = context;
-        for (JetWhenCondition condition : whenEntry.getConditions()) {
+        for (KtWhenCondition condition : whenEntry.getConditions()) {
             DataFlowInfos conditionInfos = checkWhenCondition(subjectExpression, subjectType, condition,
                                                               contextForCondition, subjectDataFlowValue);
             if (infos != null) {
@@ -181,17 +181,17 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
     }
 
     private DataFlowInfos checkWhenCondition(
-            @Nullable final JetExpression subjectExpression,
-            final JetType subjectType,
-            JetWhenCondition condition,
+            @Nullable final KtExpression subjectExpression,
+            final KtType subjectType,
+            KtWhenCondition condition,
             final ExpressionTypingContext context,
             final DataFlowValue subjectDataFlowValue
     ) {
         final Ref<DataFlowInfos> newDataFlowInfo = new Ref<DataFlowInfos>(noChange(context));
-        condition.accept(new JetVisitorVoid() {
+        condition.accept(new KtVisitorVoid() {
             @Override
-            public void visitWhenConditionInRange(@NotNull JetWhenConditionInRange condition) {
-                JetExpression rangeExpression = condition.getRangeExpression();
+            public void visitWhenConditionInRange(@NotNull KtWhenConditionInRange condition) {
+                KtExpression rangeExpression = condition.getRangeExpression();
                 if (rangeExpression == null) return;
                 if (subjectExpression == null) {
                     context.trace.report(EXPECTED_CONDITION.on(condition));
@@ -204,14 +204,14 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
                                                                 argumentForSubject, rangeExpression, context);
                 DataFlowInfo dataFlowInfo = typeInfo.getDataFlowInfo();
                 newDataFlowInfo.set(new DataFlowInfos(dataFlowInfo, dataFlowInfo));
-                JetType type = typeInfo.getType();
+                KtType type = typeInfo.getType();
                 if (type == null || !isBoolean(type)) {
                     context.trace.report(TYPE_MISMATCH_IN_RANGE.on(condition));
                 }
             }
 
             @Override
-            public void visitWhenConditionIsPattern(@NotNull JetWhenConditionIsPattern condition) {
+            public void visitWhenConditionIsPattern(@NotNull KtWhenConditionIsPattern condition) {
                 if (subjectExpression == null) {
                     context.trace.report(EXPECTED_CONDITION.on(condition));
                 }
@@ -227,8 +227,8 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
             }
 
             @Override
-            public void visitWhenConditionWithExpression(@NotNull JetWhenConditionWithExpression condition) {
-                JetExpression expression = condition.getExpression();
+            public void visitWhenConditionWithExpression(@NotNull KtWhenConditionWithExpression condition) {
+                KtExpression expression = condition.getExpression();
                 if (expression != null) {
                     newDataFlowInfo.set(checkTypeForExpressionCondition(context, expression, subjectType, subjectExpression == null,
                                                                         subjectDataFlowValue));
@@ -236,7 +236,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
             }
 
             @Override
-            public void visitJetElement(@NotNull JetElement element) {
+            public void visitJetElement(@NotNull KtElement element) {
                 context.trace.report(UNSUPPORTED.on(element, getClass().getCanonicalName()));
             }
         });
@@ -259,8 +259,8 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
 
     private DataFlowInfos checkTypeForExpressionCondition(
             ExpressionTypingContext context,
-            JetExpression expression,
-            JetType subjectType,
+            KtExpression expression,
+            KtType subjectType,
             boolean conditionExpected,
             DataFlowValue subjectDataFlowValue
     ) {
@@ -268,14 +268,14 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
             return noChange(context);
         }
         JetTypeInfo typeInfo = facade.getTypeInfo(expression, context);
-        JetType type = typeInfo.getType();
+        KtType type = typeInfo.getType();
         if (type == null) {
             return noChange(context);
         }
         context = context.replaceDataFlowInfo(typeInfo.getDataFlowInfo());
         if (conditionExpected) {
-            JetType booleanType = components.builtIns.getBooleanType();
-            if (!JetTypeChecker.DEFAULT.equalTypes(booleanType, type)) {
+            KtType booleanType = components.builtIns.getBooleanType();
+            if (!KotlinTypeChecker.DEFAULT.equalTypes(booleanType, type)) {
                 context.trace.report(TYPE_MISMATCH_IN_CONDITION.on(expression, type));
             }
             else {
@@ -298,8 +298,8 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
 
     private DataFlowInfos checkTypeForIs(
             ExpressionTypingContext context,
-            JetType subjectType,
-            JetTypeReference typeReferenceAfterIs,
+            KtType subjectType,
+            KtTypeReference typeReferenceAfterIs,
             DataFlowValue subjectDataFlowValue
     ) {
         if (typeReferenceAfterIs == null) {
@@ -307,7 +307,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
         }
         TypeResolutionContext typeResolutionContext = new TypeResolutionContext(context.scope, context.trace, true, /*allowBareTypes=*/ true);
         PossiblyBareType possiblyBareTarget = components.typeResolver.resolvePossiblyBareType(typeResolutionContext, typeReferenceAfterIs);
-        JetType targetType = TypeReconstructionUtil.reconstructBareType(typeReferenceAfterIs, possiblyBareTarget, subjectType, context.trace, components.builtIns);
+        KtType targetType = TypeReconstructionUtil.reconstructBareType(typeReferenceAfterIs, possiblyBareTarget, subjectType, context.trace, components.builtIns);
 
         if (DynamicTypesKt.isDynamic(targetType)) {
             context.trace.report(DYNAMIC_NOT_ALLOWED.on(typeReferenceAfterIs));
@@ -318,13 +318,13 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
         }
 
         if (!subjectType.isMarkedNullable() && targetType.isMarkedNullable()) {
-            JetTypeElement element = typeReferenceAfterIs.getTypeElement();
-            assert element instanceof JetNullableType : "element must be instance of " + JetNullableType.class.getName();
-            JetNullableType nullableType = (JetNullableType) element;
+            KtTypeElement element = typeReferenceAfterIs.getTypeElement();
+            assert element instanceof KtNullableType : "element must be instance of " + KtNullableType.class.getName();
+            KtNullableType nullableType = (KtNullableType) element;
             context.trace.report(Errors.USELESS_NULLABLE_CHECK.on(nullableType));
         }
         checkTypeCompatibility(context, targetType, subjectType, typeReferenceAfterIs);
-        if (CastDiagnosticsUtil.isCastErased(subjectType, targetType, JetTypeChecker.DEFAULT)) {
+        if (CastDiagnosticsUtil.isCastErased(subjectType, targetType, KotlinTypeChecker.DEFAULT)) {
             context.trace.report(Errors.CANNOT_CHECK_FOR_ERASED.on(typeReferenceAfterIs, targetType));
         }
         return new DataFlowInfos(context.dataFlowInfo.establishSubtyping(subjectDataFlowValue, targetType), context.dataFlowInfo);
@@ -339,9 +339,9 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
      */
     private void checkTypeCompatibility(
             @NotNull ExpressionTypingContext context,
-            @Nullable JetType type,
-            @NotNull JetType subjectType,
-            @NotNull JetElement reportErrorOn
+            @Nullable KtType type,
+            @NotNull KtType subjectType,
+            @NotNull KtElement reportErrorOn
     ) {
         // TODO : Take smart casts into account?
         if (type == null) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PreliminaryDeclarationVisitor.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PreliminaryDeclarationVisitor.kt
index 28e9be5d25a..ef187f928fb 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PreliminaryDeclarationVisitor.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PreliminaryDeclarationVisitor.kt
@@ -17,16 +17,16 @@
 package org.jetbrains.kotlin.types.expressions
 
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 
-class PreliminaryDeclarationVisitor(val declaration: JetDeclaration): AssignedVariablesSearcher() {
+class PreliminaryDeclarationVisitor(val declaration: KtDeclaration): AssignedVariablesSearcher() {
 
-    override fun writers(variableDescriptor: VariableDescriptor): MutableSet<JetDeclaration?> {
+    override fun writers(variableDescriptor: VariableDescriptor): MutableSet<KtDeclaration?> {
         lazyTrigger
         return super.writers(variableDescriptor)
     }
@@ -37,11 +37,11 @@ class PreliminaryDeclarationVisitor(val declaration: JetDeclaration): AssignedVa
 
     companion object {
 
-        fun createForExpression(expression: JetExpression, trace: BindingTrace) {
-            expression.getStrictParentOfType<JetDeclaration>()?.let { createForDeclaration(it, trace) }
+        fun createForExpression(expression: KtExpression, trace: BindingTrace) {
+            expression.getStrictParentOfType<KtDeclaration>()?.let { createForDeclaration(it, trace) }
         }
 
-        fun createForDeclaration(declaration: JetDeclaration, trace: BindingTrace) {
+        fun createForDeclaration(declaration: KtDeclaration, trace: BindingTrace) {
             // TODO: find top-most declaration (but not class!!!)
             // TODO: check if already exists
             val visitor = PreliminaryDeclarationVisitor(declaration)
@@ -52,8 +52,8 @@ class PreliminaryDeclarationVisitor(val declaration: JetDeclaration): AssignedVa
         fun getVisitorByVariable(variableDescriptor: VariableDescriptor, bindingContext: BindingContext): PreliminaryDeclarationVisitor? {
             // Search for preliminary visitor of parent descriptor
             val containingDescriptor = variableDescriptor.containingDeclaration
-            var currentDeclaration: JetDeclaration? =
-                    DescriptorToSourceUtils.descriptorToDeclaration(containingDescriptor) as? JetDeclaration ?: return null
+            var currentDeclaration: KtDeclaration? =
+                    DescriptorToSourceUtils.descriptorToDeclaration(containingDescriptor) as? KtDeclaration ?: return null
             var preliminaryVisitor = bindingContext.get(BindingContext.PRELIMINARY_VISITOR, currentDeclaration)
             while (preliminaryVisitor == null && currentDeclaration != null) {
                 currentDeclaration = currentDeclaration.getStrictParentOfType()
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PreliminaryLoopVisitor.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PreliminaryLoopVisitor.kt
index 885a0aa7004..99388925068 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PreliminaryLoopVisitor.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PreliminaryLoopVisitor.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.types.expressions
 
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor
-import org.jetbrains.kotlin.psi.JetLoopExpression
+import org.jetbrains.kotlin.psi.KtLoopExpression
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValue
 import java.util.*
@@ -50,7 +50,7 @@ class PreliminaryLoopVisitor private constructor() : AssignedVariablesSearcher()
     companion object {
 
         @JvmStatic
-        fun visitLoop(loopExpression: JetLoopExpression): PreliminaryLoopVisitor {
+        fun visitLoop(loopExpression: KtLoopExpression): PreliminaryLoopVisitor {
             val visitor = PreliminaryLoopVisitor()
             loopExpression.accept(visitor, null)
             return visitor
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/SenselessComparisonChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/SenselessComparisonChecker.kt
index 1c79eab3de8..11392a3df75 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/SenselessComparisonChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/SenselessComparisonChecker.kt
@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.types.expressions
 
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.types.KtType
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValue
@@ -28,16 +28,16 @@ import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
 
 object SenselessComparisonChecker {
     @JvmStatic fun checkSenselessComparisonWithNull(
-            expression: JetBinaryExpression,
-            left: JetExpression,
-            right: JetExpression,
+            expression: KtBinaryExpression,
+            left: KtExpression,
+            right: KtExpression,
             context: ResolutionContext<*>,
-            getType: (JetExpression) -> JetType?,
+            getType: (KtExpression) -> KtType?,
             getNullability: (DataFlowValue) -> Nullability
     ) {
         val expr =
-                if (JetPsiUtil.isNullConstant(left)) right
-                else if (JetPsiUtil.isNullConstant(right)) left
+                if (KtPsiUtil.isNullConstant(left)) right
+                else if (KtPsiUtil.isNullConstant(right)) left
                 else return
 
         val type = getType(expr)
@@ -46,7 +46,7 @@ object SenselessComparisonChecker {
         val operationSign = expression.getOperationReference()
         val value = DataFlowValueFactory.createDataFlowValue(expr, type, context)
 
-        val equality = operationSign.getReferencedNameElementType() == JetTokens.EQEQ || operationSign.getReferencedNameElementType() == JetTokens.EQEQEQ
+        val equality = operationSign.getReferencedNameElementType() == KtTokens.EQEQ || operationSign.getReferencedNameElementType() == KtTokens.EQEQEQ
         val nullability = getNullability(value)
 
         val expressionIsAlways =
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/TypeInfoFactory.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/TypeInfoFactory.kt
index b25fb6d7d6d..ecec1bb1ed5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/TypeInfoFactory.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/TypeInfoFactory.kt
@@ -16,10 +16,10 @@
 
 package org.jetbrains.kotlin.types.expressions.typeInfoFactory
 
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.expressions.DataFlowAnalyzer
 import org.jetbrains.kotlin.types.expressions.JetTypeInfo
 
@@ -27,14 +27,14 @@ import org.jetbrains.kotlin.types.expressions.JetTypeInfo
  * Functions in this file are intended to create type info instances in different circumstances
  */
 
-public fun createTypeInfo(type: JetType?, dataFlowInfo: DataFlowInfo): JetTypeInfo = JetTypeInfo(type, dataFlowInfo)
+public fun createTypeInfo(type: KtType?, dataFlowInfo: DataFlowInfo): JetTypeInfo = JetTypeInfo(type, dataFlowInfo)
 
-public fun createTypeInfo(type: JetType?, dataFlowInfo: DataFlowInfo, jumpPossible: Boolean, jumpFlowInfo: DataFlowInfo): JetTypeInfo =
+public fun createTypeInfo(type: KtType?, dataFlowInfo: DataFlowInfo, jumpPossible: Boolean, jumpFlowInfo: DataFlowInfo): JetTypeInfo =
         JetTypeInfo(type, dataFlowInfo, jumpPossible, jumpFlowInfo)
 
-public fun createTypeInfo(type: JetType?): JetTypeInfo = createTypeInfo(type, DataFlowInfo.EMPTY)
+public fun createTypeInfo(type: KtType?): JetTypeInfo = createTypeInfo(type, DataFlowInfo.EMPTY)
 
-public fun createTypeInfo(type: JetType?, context: ResolutionContext<*>): JetTypeInfo = createTypeInfo(type, context.dataFlowInfo)
+public fun createTypeInfo(type: KtType?, context: ResolutionContext<*>): JetTypeInfo = createTypeInfo(type, context.dataFlowInfo)
 
 public fun noTypeInfo(dataFlowInfo: DataFlowInfo): JetTypeInfo = createTypeInfo(null, dataFlowInfo)
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/TypeReconstructionUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/TypeReconstructionUtil.java
index 7aa8a81068a..d3727596eeb 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/TypeReconstructionUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/TypeReconstructionUtil.java
@@ -20,12 +20,12 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
-import org.jetbrains.kotlin.psi.JetTypeReference;
+import org.jetbrains.kotlin.psi.KtTypeReference;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.PossiblyBareType;
 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 org.jetbrains.kotlin.types.TypeReconstructionResult;
 
@@ -33,10 +33,10 @@ import static org.jetbrains.kotlin.diagnostics.Errors.NO_TYPE_ARGUMENTS_ON_RHS;
 
 public class TypeReconstructionUtil {
     @NotNull
-    public static JetType reconstructBareType(
-            @NotNull JetTypeReference right,
+    public static KtType reconstructBareType(
+            @NotNull KtTypeReference right,
             @NotNull PossiblyBareType possiblyBareTarget,
-            @Nullable JetType subjectType,
+            @Nullable KtType subjectType,
             @NotNull BindingTrace trace,
             @NotNull KotlinBuiltIns builtIns
     ) {
@@ -52,7 +52,7 @@ public class TypeReconstructionUtil {
                                                      allStarProjectionsString(typeConstructor)));
         }
 
-        JetType targetType = reconstructionResult.getResultingType();
+        KtType targetType = reconstructionResult.getResultingType();
         if (targetType != null) {
             if (possiblyBareTarget.isBare()) {
                 trace.record(BindingContext.TYPE, right, targetType);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt
index a7d6730c644..7305782bc0a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.types.expressions
 
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.psi.JetParameter
+import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.DescriptorResolver
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -33,7 +33,7 @@ public class ValueParameterResolver(
         private val constantExpressionEvaluator: ConstantExpressionEvaluator
 ) {
     public fun resolveValueParameters(
-            valueParameters: List<JetParameter>,
+            valueParameters: List<KtParameter>,
             valueParameterDescriptors: List<ValueParameterDescriptor>,
             declaringScope: LexicalScope,
             dataFlowInfo: DataFlowInfo,
@@ -45,7 +45,7 @@ public class ValueParameterResolver(
     }
 
     public fun resolveValueParameters(
-            valueParameters: List<JetParameter>,
+            valueParameters: List<KtParameter>,
             valueParameterDescriptors: List<ValueParameterDescriptor>,
             context: ExpressionTypingContext
     ) {
@@ -57,7 +57,7 @@ public class ValueParameterResolver(
 
     private fun resolveDefaultValue(
             valueParameterDescriptor: ValueParameterDescriptor,
-            jetParameter: JetParameter,
+            jetParameter: KtParameter,
             context: ExpressionTypingContext
     ) {
         if (!valueParameterDescriptor.declaresDefaultValue()) return
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/unqualifiedSuper/unqualifiedSuper.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/unqualifiedSuper/unqualifiedSuper.kt
index ac2f19804ae..9fdc9f4b3c7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/unqualifiedSuper/unqualifiedSuper.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/unqualifiedSuper/unqualifiedSuper.kt
@@ -25,29 +25,29 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetCallExpression
-import org.jetbrains.kotlin.psi.JetDotQualifiedExpression
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
-import org.jetbrains.kotlin.psi.JetSuperExpression
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.psi.KtCallExpression
+import org.jetbrains.kotlin.psi.KtDotQualifiedExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtSuperExpression
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.utils.addToStdlib.singletonList
 
 
 public fun resolveUnqualifiedSuperFromExpressionContext(
-        superExpression: JetSuperExpression,
-        supertypes: Collection<JetType>,
-        anyType: JetType
-): Collection<JetType> {
+        superExpression: KtSuperExpression,
+        supertypes: Collection<KtType>,
+        anyType: KtType
+): Collection<KtType> {
     val parentElement = superExpression.parent
 
-    if (parentElement is JetDotQualifiedExpression) {
+    if (parentElement is KtDotQualifiedExpression) {
         val selectorExpression = parentElement.selectorExpression
         when (selectorExpression) {
-            is JetCallExpression -> {
+            is KtCallExpression -> {
                 // super.foo(...): foo can be a function or a property of a callable type
                 val calleeExpression = selectorExpression.calleeExpression
-                if (calleeExpression is JetSimpleNameExpression) {
+                if (calleeExpression is KtSimpleNameExpression) {
                     val calleeName = calleeExpression.getReferencedNameAsName()
                     val location = NoLookupLocation.WHEN_TYPING
                     if (isCallingMethodOfAny(selectorExpression, calleeName)) {
@@ -58,7 +58,7 @@ public fun resolveUnqualifiedSuperFromExpressionContext(
                     }
                 }
             }
-            is JetSimpleNameExpression -> {
+            is KtSimpleNameExpression -> {
                 // super.x: x can be a property only
                 // NB there are no properties in kotlin.Any
                 return resolveSupertypesByPropertyName(supertypes, selectorExpression.getReferencedNameAsName(), NoLookupLocation.WHEN_TYPING)
@@ -71,20 +71,20 @@ public fun resolveUnqualifiedSuperFromExpressionContext(
 
 private val ARITY_OF_METHODS_OF_ANY = hashMapOf("hashCode" to 0, "equals" to 1, "toString" to 0)
 
-private fun isCallingMethodOfAny(callExpression: JetCallExpression, calleeName: Name): Boolean =
+private fun isCallingMethodOfAny(callExpression: KtCallExpression, calleeName: Name): Boolean =
         ARITY_OF_METHODS_OF_ANY.getOrElse(calleeName.asString(), { -1 }) == callExpression.valueArguments.size()
 
-public fun isPossiblyAmbiguousUnqualifiedSuper(superExpression: JetSuperExpression, supertypes: Collection<JetType>): Boolean =
+public fun isPossiblyAmbiguousUnqualifiedSuper(superExpression: KtSuperExpression, supertypes: Collection<KtType>): Boolean =
         supertypes.size() > 1 ||
         (supertypes.size() == 1 && supertypes.single().isInterface() && isCallingMethodOfAnyWithSuper(superExpression))
 
-private fun isCallingMethodOfAnyWithSuper(superExpression: JetSuperExpression): Boolean {
+private fun isCallingMethodOfAnyWithSuper(superExpression: KtSuperExpression): Boolean {
     val parent = superExpression.parent
-    if (parent is JetDotQualifiedExpression) {
+    if (parent is KtDotQualifiedExpression) {
         val selectorExpression = parent.selectorExpression
-        if (selectorExpression is JetCallExpression) {
+        if (selectorExpression is KtCallExpression) {
             val calleeExpression = selectorExpression.calleeExpression
-            if (calleeExpression is JetSimpleNameExpression) {
+            if (calleeExpression is KtSimpleNameExpression) {
                 val calleeName = calleeExpression.getReferencedNameAsName()
                 return isCallingMethodOfAny(selectorExpression, calleeName)
             }
@@ -94,10 +94,10 @@ private fun isCallingMethodOfAnyWithSuper(superExpression: JetSuperExpression):
     return false
 }
 
-private fun JetType.isInterface(): Boolean =
+private fun KtType.isInterface(): Boolean =
         TypeUtils.getClassDescriptor(this)?.kind == ClassKind.INTERFACE
 
-private fun resolveSupertypesForMethodOfAny(supertypes: Collection<JetType>, calleeName: Name, location: LookupLocation, anyType: JetType): Collection<JetType> {
+private fun resolveSupertypesForMethodOfAny(supertypes: Collection<KtType>, calleeName: Name, location: LookupLocation, anyType: KtType): Collection<KtType> {
     val typesWithConcreteOverride = resolveSupertypesByMembers(supertypes, false) { getFunctionMembers(it, calleeName, location) }
     return if (typesWithConcreteOverride.isNotEmpty())
         typesWithConcreteOverride
@@ -105,19 +105,19 @@ private fun resolveSupertypesForMethodOfAny(supertypes: Collection<JetType>, cal
         anyType.singletonList()
 }
 
-private fun resolveSupertypesByCalleeName(supertypes: Collection<JetType>, calleeName: Name, location: LookupLocation): Collection<JetType> =
+private fun resolveSupertypesByCalleeName(supertypes: Collection<KtType>, calleeName: Name, location: LookupLocation): Collection<KtType> =
         resolveSupertypesByMembers(supertypes, true) { getFunctionMembers(it, calleeName, location) + getPropertyMembers(it, calleeName, location) }
 
-private fun resolveSupertypesByPropertyName(supertypes: Collection<JetType>, propertyName: Name, location: LookupLocation): Collection<JetType> =
+private fun resolveSupertypesByPropertyName(supertypes: Collection<KtType>, propertyName: Name, location: LookupLocation): Collection<KtType> =
         resolveSupertypesByMembers(supertypes, true) { getPropertyMembers(it, propertyName, location) }
 
 private inline fun resolveSupertypesByMembers(
-        supertypes: Collection<JetType>,
+        supertypes: Collection<KtType>,
         allowArbitraryMembers: Boolean,
-        getMembers: (JetType) -> Collection<MemberDescriptor>
-): Collection<JetType> {
-    val typesWithConcreteMembers = SmartList<JetType>()
-    val typesWithArbitraryMembers = SmartList<JetType>()
+        getMembers: (KtType) -> Collection<MemberDescriptor>
+): Collection<KtType> {
+    val typesWithConcreteMembers = SmartList<KtType>()
+    val typesWithArbitraryMembers = SmartList<KtType>()
 
     for (supertype in supertypes) {
         val members = getMembers(supertype)
@@ -131,16 +131,16 @@ private inline fun resolveSupertypesByMembers(
 
     return if (typesWithConcreteMembers.isNotEmpty()) typesWithConcreteMembers
         else if (allowArbitraryMembers) typesWithArbitraryMembers
-        else emptyList<JetType>()
+        else emptyList<KtType>()
 }
 
-private fun getFunctionMembers(type: JetType, name: Name, location: LookupLocation): Collection<MemberDescriptor> =
+private fun getFunctionMembers(type: KtType, name: Name, location: LookupLocation): Collection<MemberDescriptor> =
         type.memberScope.getFunctions(name, location)
 
-private fun getPropertyMembers(type: JetType, name: Name, location: LookupLocation): Collection<MemberDescriptor> =
+private fun getPropertyMembers(type: KtType, name: Name, location: LookupLocation): Collection<MemberDescriptor> =
         type.memberScope.getProperties(name, location).filterIsInstanceTo(SmartList<MemberDescriptor>())
 
-private fun isConcreteMember(supertype: JetType, memberDescriptor: MemberDescriptor): Boolean {
+private fun isConcreteMember(supertype: KtType, memberDescriptor: MemberDescriptor): Boolean {
     // "Concrete member" is a function or a property that is not abstract,
     // and is not an implicit fake override for a method of Any on an interface.
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/Slices.java b/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/Slices.java
index 4a4c3c9d8d7..18a74dc38d8 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/Slices.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/Slices.java
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.util.slicedMap;
 
 import com.intellij.openapi.diagnostic.Logger;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetElement;
+import org.jetbrains.kotlin.psi.KtElement;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt;
 
 import java.util.Arrays;
@@ -41,7 +41,7 @@ public class Slices {
                         " key: " + key +
                         " old value: " + oldValue + '@' + System.identityHashCode(oldValue) +
                         " new value: " + newValue + '@' + System.identityHashCode(newValue) +
-                          (key instanceof JetElement ? "\n" + PsiUtilsKt.getElementTextWithContext((JetElement) key) : ""));
+                          (key instanceof KtElement ? "\n" + PsiUtilsKt.getElementTextWithContext((KtElement) key) : ""));
             }
             return true;
         }
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/ClsWrapperStubPsiFactory.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/ClsWrapperStubPsiFactory.java
index 533847960ae..78166d24883 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/ClsWrapperStubPsiFactory.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/ClsWrapperStubPsiFactory.java
@@ -27,19 +27,19 @@ import com.intellij.psi.impl.java.stubs.*;
 import com.intellij.psi.stubs.StubBase;
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetDeclaration;
+import org.jetbrains.kotlin.psi.KtDeclaration;
 
 class ClsWrapperStubPsiFactory extends StubPsiFactory {
     public static final Key<PsiElement> ORIGIN_ELEMENT = Key.create("ORIGIN_ELEMENT");
     private final StubPsiFactory delegate = new ClsStubPsiFactory();
 
-    public static JetDeclaration getOriginalDeclaration(PsiMember member) {
+    public static KtDeclaration getOriginalDeclaration(PsiMember member) {
         if (member instanceof ClsRepositoryPsiElement<?>) {
             StubElement stubElement = ((ClsRepositoryPsiElement<?>) member).getStub();
             if (stubElement instanceof UserDataHolder) {
                 PsiElement original = ((UserDataHolder) stubElement).getUserData(ORIGIN_ELEMENT);
-                if (original instanceof JetDeclaration) {
-                    return (JetDeclaration) original;
+                if (original instanceof KtDeclaration) {
+                    return (KtDeclaration) original;
                 }
             }
         }
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/FakeLightClassForFileOfPackage.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/FakeLightClassForFileOfPackage.java
index 0c8a1a26feb..6c6bbda683b 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/FakeLightClassForFileOfPackage.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/FakeLightClassForFileOfPackage.java
@@ -26,8 +26,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtFile;
 
 /**
  * This class serves as a workaround for usages of {@link JavaElementFinder#findClasses} which eventually only need names of files
@@ -39,10 +39,10 @@ import org.jetbrains.kotlin.psi.JetFile;
  */
 public class FakeLightClassForFileOfPackage extends AbstractLightClass implements KotlinLightClass, JetJavaMirrorMarker {
     private final KotlinLightClassForFacade delegate;
-    private final JetFile file;
+    private final KtFile file;
 
     public FakeLightClassForFileOfPackage(
-            @NotNull PsiManager manager, @NotNull KotlinLightClassForFacade delegate, @NotNull JetFile file
+            @NotNull PsiManager manager, @NotNull KotlinLightClassForFacade delegate, @NotNull KtFile file
     ) {
         super(manager);
         this.delegate = delegate;
@@ -51,7 +51,7 @@ public class FakeLightClassForFileOfPackage extends AbstractLightClass implement
 
     @Nullable
     @Override
-    public JetClassOrObject getOrigin() {
+    public KtClassOrObject getOrigin() {
         return null;
     }
 
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/JavaElementFinder.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/JavaElementFinder.java
index c763ffab972..6899d1b1a03 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/JavaElementFinder.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/JavaElementFinder.java
@@ -32,12 +32,11 @@ import com.intellij.util.containers.SLRUCache;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.load.java.JvmAbi;
-import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.FqNamesUtilKt;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetEnumEntry;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtEnumEntry;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.jvm.KotlinFinderMarker;
 
 import java.util.Collection;
@@ -128,11 +127,11 @@ public class JavaElementFinder extends PsiElementFinder implements KotlinFinderM
     private void findClassesAndObjects(FqName qualifiedName, GlobalSearchScope scope, List<PsiClass> answer) {
         findInterfaceDefaultImpls(qualifiedName, scope, answer);
 
-        Collection<JetClassOrObject> classOrObjectDeclarations =
+        Collection<KtClassOrObject> classOrObjectDeclarations =
                 lightClassGenerationSupport.findClassOrObjectDeclarations(qualifiedName, scope);
 
-        for (JetClassOrObject declaration : classOrObjectDeclarations) {
-            if (!(declaration instanceof JetEnumEntry)) {
+        for (KtClassOrObject declaration : classOrObjectDeclarations) {
+            if (!(declaration instanceof KtEnumEntry)) {
                 PsiClass lightClass = LightClassUtil.INSTANCE$.getPsiClass(declaration);
                 if (lightClass != null) {
                     answer.add(lightClass);
@@ -146,7 +145,7 @@ public class JavaElementFinder extends PsiElementFinder implements KotlinFinderM
 
         if (!qualifiedName.shortName().asString().equals(JvmAbi.DEFAULT_IMPLS_CLASS_NAME)) return;
 
-        for (JetClassOrObject classOrObject : lightClassGenerationSupport.findClassOrObjectDeclarations(qualifiedName.parent(), scope)) {
+        for (KtClassOrObject classOrObject : lightClassGenerationSupport.findClassOrObjectDeclarations(qualifiedName.parent(), scope)) {
             if (LightClassUtilsKt.getHasInterfaceDefaultImpls(classOrObject)) {
                 PsiClass interfaceClass = LightClassUtil.INSTANCE$.getPsiClass(classOrObject);
                 if (interfaceClass != null) {
@@ -164,12 +163,12 @@ public class JavaElementFinder extends PsiElementFinder implements KotlinFinderM
     public Set<String> getClassNames(@NotNull PsiPackage psiPackage, @NotNull GlobalSearchScope scope) {
         FqName packageFQN = new FqName(psiPackage.getQualifiedName());
 
-        Collection<JetClassOrObject> declarations = lightClassGenerationSupport.findClassOrObjectDeclarationsInPackage(packageFQN, scope);
+        Collection<KtClassOrObject> declarations = lightClassGenerationSupport.findClassOrObjectDeclarationsInPackage(packageFQN, scope);
 
         Set<String> answer = Sets.newHashSet();
         answer.addAll(lightClassGenerationSupport.getFacadeNames(packageFQN, scope));
 
-        for (JetClassOrObject declaration : declarations) {
+        for (KtClassOrObject declaration : declarations) {
             String name = declaration.getName();
             if (name != null) {
                 answer.add(name);
@@ -190,7 +189,7 @@ public class JavaElementFinder extends PsiElementFinder implements KotlinFinderM
         // allScope() because the contract says that the whole project
         GlobalSearchScope allScope = GlobalSearchScope.allScope(project);
         if (lightClassGenerationSupport.packageExists(fqName, allScope)) {
-            return new JetLightPackage(psiManager, fqName, allScope);
+            return new KotlinLightPackage(psiManager, fqName, allScope);
         }
 
         return null;
@@ -206,7 +205,7 @@ public class JavaElementFinder extends PsiElementFinder implements KotlinFinderM
         Collection<PsiPackage> answer = Collections2.transform(subpackages, new Function<FqName, PsiPackage>() {
             @Override
             public PsiPackage apply(@Nullable FqName input) {
-                return new JetLightPackage(psiManager, input, scope);
+                return new KotlinLightPackage(psiManager, input, scope);
             }
         });
 
@@ -221,8 +220,8 @@ public class JavaElementFinder extends PsiElementFinder implements KotlinFinderM
 
         answer.addAll(lightClassGenerationSupport.getFacadeClassesInPackage(packageFQN, scope));
 
-        Collection<JetClassOrObject> declarations = lightClassGenerationSupport.findClassOrObjectDeclarationsInPackage(packageFQN, scope);
-        for (JetClassOrObject declaration : declarations) {
+        Collection<KtClassOrObject> declarations = lightClassGenerationSupport.findClassOrObjectDeclarationsInPackage(packageFQN, scope);
+        for (KtClassOrObject declaration : declarations) {
             PsiClass aClass = LightClassUtil.INSTANCE$.getPsiClass(declaration);
             if (aClass != null) {
                 answer.add(aClass);
@@ -236,7 +235,7 @@ public class JavaElementFinder extends PsiElementFinder implements KotlinFinderM
     @NotNull
     public PsiFile[] getPackageFiles(@NotNull PsiPackage psiPackage, @NotNull GlobalSearchScope scope) {
         FqName packageFQN = new FqName(psiPackage.getQualifiedName());
-        Collection<JetFile> result = lightClassGenerationSupport.findFilesForPackage(packageFQN, scope);
+        Collection<KtFile> result = lightClassGenerationSupport.findFilesForPackage(packageFQN, scope);
         return result.toArray(new PsiFile[result.size()]);
     }
 
@@ -246,10 +245,10 @@ public class JavaElementFinder extends PsiElementFinder implements KotlinFinderM
         return new Condition<PsiFile>() {
             @Override
             public boolean value(PsiFile input) {
-                if (!(input instanceof JetFile)) {
+                if (!(input instanceof KtFile)) {
                     return true;
                 }
-                return psiPackage.getQualifiedName().equals(((JetFile) input).getPackageFqName().asString());
+                return psiPackage.getQualifiedName().equals(((KtFile) input).getPackageFqName().asString());
             }
         };
     }
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinCodeBlockModificationListener.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinCodeBlockModificationListener.kt
index 26eaa24e608..370ca15f678 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinCodeBlockModificationListener.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinCodeBlockModificationListener.kt
@@ -36,7 +36,7 @@ public class KotlinCodeBlockModificationListener(modificationTracker: PsiModific
     private val myModificationTracker = modificationTracker as PsiModificationTrackerImpl
 
     override fun treeChanged(event: PsiTreeChangeEventImpl) {
-        if (event.file !is JetFile) return
+        if (event.file !is KtFile) return
 
         when (event.code) {
             BEFORE_CHILDREN_CHANGE,
@@ -72,7 +72,7 @@ public class KotlinCodeBlockModificationListener(modificationTracker: PsiModific
     private fun processChange(parent: PsiElement?, child1: PsiElement?, child2: PsiElement?) {
         try {
             if (!isInsideCodeBlock(parent)) {
-                if (parent != null && parent.containingFile is JetFile) {
+                if (parent != null && parent.containingFile is KtFile) {
                     myModificationTracker.incCounter()
                 }
                 else {
@@ -111,10 +111,10 @@ public class KotlinCodeBlockModificationListener(modificationTracker: PsiModific
             if (element == null || element.parent == null) return true
 
             //TODO: other types
-            val blockDeclaration = JetPsiUtil.getTopmostParentOfTypes(element, *BLOCK_DECLARATION_TYPES) ?: return false
+            val blockDeclaration = KtPsiUtil.getTopmostParentOfTypes(element, *BLOCK_DECLARATION_TYPES) ?: return false
 
             when (blockDeclaration) {
-                is JetNamedFunction -> {
+                is KtNamedFunction -> {
                     if (blockDeclaration.hasBlockBody()) {
                         return blockDeclaration.bodyExpression.isAncestor(element)
                     }
@@ -123,7 +123,7 @@ public class KotlinCodeBlockModificationListener(modificationTracker: PsiModific
                     }
                 }
 
-                is JetProperty -> {
+                is KtProperty -> {
                     for (accessor in blockDeclaration.accessors) {
                         if (accessor.initializer.isAncestor(element) || accessor.bodyExpression.isAncestor(element)) {
                             return true
@@ -137,13 +137,13 @@ public class KotlinCodeBlockModificationListener(modificationTracker: PsiModific
             return false
         }
 
-        public fun isBlockDeclaration(declaration: JetDeclaration): Boolean {
+        public fun isBlockDeclaration(declaration: KtDeclaration): Boolean {
             return BLOCK_DECLARATION_TYPES.any { it.isInstance(declaration) }
         }
 
-        private val BLOCK_DECLARATION_TYPES = arrayOf<Class<out JetDeclaration>>(
-                javaClass<JetProperty>(),
-                javaClass<JetNamedFunction>()
+        private val BLOCK_DECLARATION_TYPES = arrayOf<Class<out KtDeclaration>>(
+                javaClass<KtProperty>(),
+                javaClass<KtNamedFunction>()
         )
     }
 }
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinJavaFileStubProvider.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinJavaFileStubProvider.java
index af5ef23396c..aff5936366b 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinJavaFileStubProvider.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinJavaFileStubProvider.java
@@ -52,10 +52,10 @@ import org.jetbrains.kotlin.fileClasses.FileClasses;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassInfo;
 import org.jetbrains.kotlin.fileClasses.NoResolveFileClassesProvider;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetPsiUtil;
-import org.jetbrains.kotlin.psi.JetScript;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtPsiUtil;
+import org.jetbrains.kotlin.psi.KtScript;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTraceContext;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
@@ -82,13 +82,13 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
                 new StubGenerationStrategy<KotlinFacadeLightClassData>() {
                     @NotNull
                     @Override
-                    public LightClassConstructionContext getContext(@NotNull Collection<JetFile> files) {
+                    public LightClassConstructionContext getContext(@NotNull Collection<KtFile> files) {
                         return LightClassGenerationSupport.getInstance(project).getContextForPackage(files);
                     }
 
                     @NotNull
                     @Override
-                    public Collection<JetFile> getFiles() {
+                    public Collection<KtFile> getFiles() {
                         // Don't memoize this, it can be called again after an out-of-code-block modification occurs,
                         // and the set of files changes
                         return LightClassGenerationSupport.getInstance(project).findFilesForPackage(packageFqName, searchScope);
@@ -115,24 +115,24 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
                         return new GenerationState.GenerateClassFilter() {
 
                             @Override
-                            public boolean shouldGeneratePackagePart(JetFile jetFile) {
+                            public boolean shouldGeneratePackagePart(KtFile jetFile) {
                                 return true;
                             }
 
                             @Override
-                            public boolean shouldAnnotateClass(JetClassOrObject classOrObject) {
+                            public boolean shouldAnnotateClass(KtClassOrObject classOrObject) {
                                 return shouldGenerateClass(classOrObject);
                             }
 
                             @Override
-                            public boolean shouldGenerateClass(JetClassOrObject classOrObject) {
+                            public boolean shouldGenerateClass(KtClassOrObject classOrObject) {
                                 // Top-level classes and such should not be generated for performance reasons.
                                 // Local classes in top-level functions must still be generated
-                                return JetPsiUtil.isLocal(classOrObject);
+                                return KtPsiUtil.isLocal(classOrObject);
                             }
 
                             @Override
-                            public boolean shouldGenerateScript(JetScript script) {
+                            public boolean shouldGenerateScript(KtScript script) {
                                 // Scripts yield top-level classes, and should not be generated
                                 return false;
                             }
@@ -140,7 +140,7 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
                     }
 
                     @Override
-                    public void generate(@NotNull GenerationState state, @NotNull Collection<JetFile> files) {
+                    public void generate(@NotNull GenerationState state, @NotNull Collection<KtFile> files) {
                         KotlinCodegenFacade.doGenerateFiles(files, state, CompilationErrorHandler.THROW_EXCEPTION);
                     }
 
@@ -164,7 +164,7 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
                 new StubGenerationStrategy<KotlinFacadeLightClassData>() {
                     @NotNull
                     @Override
-                    public Collection<JetFile> getFiles() {
+                    public Collection<KtFile> getFiles() {
                         return LightClassGenerationSupport.getInstance(project).findFilesForFacade(facadeFqName, searchScope);
                     }
 
@@ -176,7 +176,7 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
 
                     @NotNull
                     @Override
-                    public LightClassConstructionContext getContext(@NotNull Collection<JetFile> files) {
+                    public LightClassConstructionContext getContext(@NotNull Collection<KtFile> files) {
                         return LightClassGenerationSupport.getInstance(project).getContextForFacade(files);
                     }
 
@@ -194,31 +194,31 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
                     public GenerationState.GenerateClassFilter getGenerateClassFilter() {
                         return new GenerationState.GenerateClassFilter() {
                             @Override
-                            public boolean shouldAnnotateClass(JetClassOrObject classOrObject) {
+                            public boolean shouldAnnotateClass(KtClassOrObject classOrObject) {
                                 return shouldGenerateClass(classOrObject);
                             }
 
                             @Override
-                            public boolean shouldGenerateClass(JetClassOrObject classOrObject) {
-                                return JetPsiUtil.isLocal(classOrObject);
+                            public boolean shouldGenerateClass(KtClassOrObject classOrObject) {
+                                return KtPsiUtil.isLocal(classOrObject);
                             }
 
                             @Override
-                            public boolean shouldGeneratePackagePart(JetFile jetFile) {
+                            public boolean shouldGeneratePackagePart(KtFile jetFile) {
                                 return true;
                             }
 
                             @Override
-                            public boolean shouldGenerateScript(JetScript script) {
+                            public boolean shouldGenerateScript(KtScript script) {
                                 return false;
                             }
                         };
                     }
 
                     @Override
-                    public void generate(@NotNull GenerationState state, @NotNull Collection<JetFile> files) {
+                    public void generate(@NotNull GenerationState state, @NotNull Collection<KtFile> files) {
                         if (!files.isEmpty()) {
-                            JetFile representativeFile = files.iterator().next();
+                            KtFile representativeFile = files.iterator().next();
                             JvmFileClassInfo fileClassInfo = NoResolveFileClassesProvider.INSTANCE$.getFileClassInfo(representativeFile);
                             if (!fileClassInfo.getWithJvmMultifileClass()) {
                                 PackageCodegen codegen = state.getFactory().forPackage(representativeFile.getPackageFqName(), files);
@@ -241,18 +241,18 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
     }
 
     @NotNull
-    public static KotlinJavaFileStubProvider<OutermostKotlinClassLightClassData> createForDeclaredClass(@NotNull final JetClassOrObject classOrObject) {
+    public static KotlinJavaFileStubProvider<OutermostKotlinClassLightClassData> createForDeclaredClass(@NotNull final KtClassOrObject classOrObject) {
         return new KotlinJavaFileStubProvider<OutermostKotlinClassLightClassData>(
                 classOrObject.getProject(),
                 classOrObject.isLocal(),
                 new StubGenerationStrategy<OutermostKotlinClassLightClassData>() {
-                    private JetFile getFile() {
+                    private KtFile getFile() {
                         return classOrObject.getContainingJetFile();
                     }
 
                     @NotNull
                     @Override
-                    public LightClassConstructionContext getContext(@NotNull Collection<JetFile> files) {
+                    public LightClassConstructionContext getContext(@NotNull Collection<KtFile> files) {
                         return LightClassGenerationSupport.getInstance(classOrObject.getProject()).getContextForClassOrObject(classOrObject);
                     }
 
@@ -267,18 +267,18 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
                         if (classDescriptor == null) {
                             return new OutermostKotlinClassLightClassData(
                                     javaFileStub, extraDiagnostics, FqName.ROOT, classOrObject,
-                                    Collections.<JetClassOrObject, InnerKotlinClassLightClassData>emptyMap()
+                                    Collections.<KtClassOrObject, InnerKotlinClassLightClassData>emptyMap()
                             );
                         }
 
                         FqName fqName = predictClassFqName(bindingContext, classDescriptor);
                         Collection<ClassDescriptor> allInnerClasses = CodegenBinding.getAllInnerClasses(bindingContext, classDescriptor);
 
-                        Map<JetClassOrObject, InnerKotlinClassLightClassData> innerClassesMap = ContainerUtil.newHashMap();
+                        Map<KtClassOrObject, InnerKotlinClassLightClassData> innerClassesMap = ContainerUtil.newHashMap();
                         for (ClassDescriptor innerClassDescriptor : allInnerClasses) {
                             PsiElement declaration = descriptorToDeclaration(innerClassDescriptor);
-                            if (!(declaration instanceof JetClassOrObject)) continue;
-                            JetClassOrObject innerClass = (JetClassOrObject) declaration;
+                            if (!(declaration instanceof KtClassOrObject)) continue;
+                            KtClassOrObject innerClass = (KtClassOrObject) declaration;
 
                             InnerKotlinClassLightClassData innerLightClassData = new InnerKotlinClassLightClassData(
                                     predictClassFqName(bindingContext, innerClassDescriptor),
@@ -306,7 +306,7 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
 
                     @NotNull
                     @Override
-                    public Collection<JetFile> getFiles() {
+                    public Collection<KtFile> getFiles() {
                         return Collections.singletonList(getFile());
                     }
 
@@ -321,17 +321,17 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
                         return new GenerationState.GenerateClassFilter() {
 
                             @Override
-                            public boolean shouldGeneratePackagePart(JetFile jetFile) {
+                            public boolean shouldGeneratePackagePart(KtFile jetFile) {
                                 return true;
                             }
 
                             @Override
-                            public boolean shouldAnnotateClass(JetClassOrObject classOrObject) {
+                            public boolean shouldAnnotateClass(KtClassOrObject classOrObject) {
                                 return shouldGenerateClass(classOrObject);
                             }
 
                             @Override
-                            public boolean shouldGenerateClass(JetClassOrObject generatedClassOrObject) {
+                            public boolean shouldGenerateClass(KtClassOrObject generatedClassOrObject) {
                                 // Trivial: generate and analyze class we are interested in.
                                 if (generatedClassOrObject == classOrObject) return true;
 
@@ -364,7 +364,7 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
                             }
 
                             @Override
-                            public boolean shouldGenerateScript(JetScript script) {
+                            public boolean shouldGenerateScript(KtScript script) {
                                 // We generate all enclosing classes
                                 return PsiTreeUtil.isAncestor(script, classOrObject, false);
                             }
@@ -372,9 +372,9 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
                     }
 
                     @Override
-                    public void generate(@NotNull GenerationState state, @NotNull Collection<JetFile> files) {
+                    public void generate(@NotNull GenerationState state, @NotNull Collection<KtFile> files) {
                         PackageCodegen packageCodegen = state.getFactory().forPackage(getPackageFqName(), files);
-                        JetFile file = classOrObject.getContainingJetFile();
+                        KtFile file = classOrObject.getContainingJetFile();
                         Type packagePartType = FileClasses.getFileClassType(state.getFileClassesProvider(), file);
                         PackageContext context = state.getRootContext().intoPackagePart(packageCodegen.getPackageFragment(), packagePartType, file);
                         packageCodegen.generateClassOrObject(classOrObject, context);
@@ -409,7 +409,7 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
     @Override
     public Result<T> compute() {
         FqName packageFqName = stubGenerationStrategy.getPackageFqName();
-        Collection<JetFile> files = stubGenerationStrategy.getFiles();
+        Collection<KtFile> files = stubGenerationStrategy.getFiles();
 
         checkForBuiltIns(packageFqName, files);
 
@@ -465,7 +465,7 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
     private static ClsFileImpl createFakeClsFile(
             @NotNull Project project,
             @NotNull final FqName packageFqName,
-            @NotNull Collection<JetFile> files,
+            @NotNull Collection<KtFile> files,
             @NotNull final Function0<? extends PsiClassHolderFileStub> fileStubProvider
     ) {
         PsiManager manager = PsiManager.getInstance(project);
@@ -490,7 +490,7 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
     }
 
     @NotNull
-    private PsiJavaFileStub createJavaFileStub(@NotNull FqName packageFqName, @NotNull Collection<JetFile> files) {
+    private PsiJavaFileStub createJavaFileStub(@NotNull FqName packageFqName, @NotNull Collection<KtFile> files) {
         final PsiJavaFileStubImpl javaFileStub = new PsiJavaFileStubImpl(packageFqName.asString(), true);
         javaFileStub.setPsiFactory(new ClsWrapperStubPsiFactory());
 
@@ -506,15 +506,15 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
     }
 
     @NotNull
-    private static VirtualFile getRepresentativeVirtualFile(@NotNull Collection<JetFile> files) {
-        JetFile firstFile = files.iterator().next();
+    private static VirtualFile getRepresentativeVirtualFile(@NotNull Collection<KtFile> files) {
+        KtFile firstFile = files.iterator().next();
         VirtualFile virtualFile = firstFile.getVirtualFile();
         assert virtualFile != null : "No virtual file for " + firstFile;
         return virtualFile;
     }
 
-    private static void checkForBuiltIns(@NotNull FqName fqName, @NotNull Collection<JetFile> files) {
-        for (JetFile file : files) {
+    private static void checkForBuiltIns(@NotNull FqName fqName, @NotNull Collection<KtFile> files) {
+        for (KtFile file : files) {
             if (LightClassUtil.INSTANCE$.belongsToKotlinBuiltIns(file)) {
                 // We may not fail later due to some luck, but generating JetLightClasses for built-ins is a bad idea anyways
                 // If it fails later, there will be an exception logged
@@ -533,13 +533,13 @@ public class KotlinJavaFileStubProvider<T extends WithFileStubAndExtraDiagnostic
     }
 
     private interface StubGenerationStrategy<T extends WithFileStubAndExtraDiagnostics> {
-        @NotNull Collection<JetFile> getFiles();
+        @NotNull Collection<KtFile> getFiles();
         @NotNull FqName getPackageFqName();
 
-        @NotNull LightClassConstructionContext getContext(@NotNull Collection<JetFile> files);
+        @NotNull LightClassConstructionContext getContext(@NotNull Collection<KtFile> files);
         @NotNull T createLightClassData(PsiJavaFileStub javaFileStub, BindingContext bindingContext, Diagnostics extraDiagnostics);
 
         GenerationState.GenerateClassFilter getGenerateClassFilter();
-        void generate(@NotNull GenerationState state, @NotNull Collection<JetFile> files);
+        void generate(@NotNull GenerationState state, @NotNull Collection<KtFile> files);
     }
 }
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClass.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClass.kt
index ffbe21456cd..ea64f628587 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClass.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClass.kt
@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.asJava;
 
 import com.intellij.psi.PsiClass;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 
-public interface KotlinLightClass : PsiClass, KotlinLightElement<JetClassOrObject, PsiClass> {
+public interface KotlinLightClass : PsiClass, KotlinLightElement<KtClassOrObject, PsiClass> {
     public fun getFqName(): FqName
 }
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForAnonymousDeclaration.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForAnonymousDeclaration.java
index 73c9f1d6dc4..5561df751a4 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForAnonymousDeclaration.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForAnonymousDeclaration.java
@@ -26,9 +26,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collection;
 
@@ -37,7 +37,7 @@ class KotlinLightClassForAnonymousDeclaration extends KotlinLightClassForExplici
 
     private SoftReference<PsiClassType> cachedBaseType = null;
 
-    KotlinLightClassForAnonymousDeclaration(@NotNull PsiManager manager, @NotNull FqName name, @NotNull JetClassOrObject classOrObject) {
+    KotlinLightClassForAnonymousDeclaration(@NotNull PsiManager manager, @NotNull FqName name, @NotNull KtClassOrObject classOrObject) {
         super(manager, name, classOrObject);
     }
 
@@ -52,11 +52,11 @@ class KotlinLightClassForAnonymousDeclaration extends KotlinLightClassForExplici
         ClassDescriptor descriptor = getDescriptor();
         if (descriptor == null) return CommonClassNames.JAVA_LANG_OBJECT;
 
-        Collection<JetType> superTypes = descriptor.getTypeConstructor().getSupertypes();
+        Collection<KtType> superTypes = descriptor.getTypeConstructor().getSupertypes();
 
         if (superTypes.isEmpty()) return CommonClassNames.JAVA_LANG_OBJECT;
 
-        JetType superType = superTypes.iterator().next();
+        KtType superType = superTypes.iterator().next();
         DeclarationDescriptor superClassDescriptor = superType.getConstructor().getDeclarationDescriptor();
 
         if (superClassDescriptor == null) {
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForEnumEntry.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForEnumEntry.kt
index d22cdc5c105..f4fcf0ce637 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForEnumEntry.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForEnumEntry.kt
@@ -18,14 +18,14 @@ package org.jetbrains.kotlin.asJava
 
 import com.intellij.psi.PsiManager
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetEnumEntry
+import org.jetbrains.kotlin.psi.KtEnumEntry
 import com.intellij.psi.PsiEnumConstantInitializer
 import com.intellij.psi.PsiEnumConstant
 
 public class KotlinLightClassForEnumEntry(
         psiManager: PsiManager,
         fqName: FqName,
-        enumEntry: JetEnumEntry,
+        enumEntry: KtEnumEntry,
         private val enumConstant: PsiEnumConstant
 ): KotlinLightClassForAnonymousDeclaration(psiManager, fqName, enumEntry), PsiEnumConstantInitializer {
     override fun getEnumConstant(): PsiEnumConstant = enumConstant
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForExplicitDeclaration.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForExplicitDeclaration.kt
index 36a90333b81..cf16c003b61 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForExplicitDeclaration.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForExplicitDeclaration.kt
@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.codegen.binding.PsiCodegenPredictor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.fileClasses.NoResolveFileClassesProvider
 import org.jetbrains.kotlin.idea.KotlinLanguage
-import org.jetbrains.kotlin.lexer.JetTokens.*
+import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
@@ -50,8 +50,8 @@ import javax.swing.Icon
 public open class KotlinLightClassForExplicitDeclaration(
         manager: PsiManager,
         protected val classFqName: FqName, // FqName of (possibly inner) class
-        protected val classOrObject: JetClassOrObject)
-: KotlinWrappingLightClass(manager), JetJavaMirrorMarker, StubBasedPsiElement<KotlinClassOrObjectStub<out JetClassOrObject>> {
+        protected val classOrObject: KtClassOrObject)
+: KotlinWrappingLightClass(manager), JetJavaMirrorMarker, StubBasedPsiElement<KotlinClassOrObjectStub<out KtClassOrObject>> {
     private var delegate: PsiClass? = null
 
     private fun getLocalClassParent(): PsiElement? {
@@ -88,37 +88,37 @@ public open class KotlinLightClassForExplicitDeclaration(
             return method
         }
 
-        var declaration: PsiElement? = JetPsiUtil.getTopmostParentOfTypes(
+        var declaration: PsiElement? = KtPsiUtil.getTopmostParentOfTypes(
                 classOrObject,
-                JetNamedFunction::class.java,
-                JetConstructor::class.java,
-                JetProperty::class.java,
-                JetClassInitializer::class.java,
-                JetParameter::class.java)
+                KtNamedFunction::class.java,
+                KtConstructor::class.java,
+                KtProperty::class.java,
+                KtClassInitializer::class.java,
+                KtParameter::class.java)
 
-        if (declaration is JetParameter) {
-            declaration = declaration.getStrictParentOfType<JetNamedDeclaration>()
+        if (declaration is KtParameter) {
+            declaration = declaration.getStrictParentOfType<KtNamedDeclaration>()
         }
 
-        if (declaration is JetFunction) {
+        if (declaration is KtFunction) {
             return getParentByPsiMethod(LightClassUtil.getLightClassMethod(declaration), declaration.name, false)
         }
 
         // Represent the property as a fake method with the same name
-        if (declaration is JetProperty) {
+        if (declaration is KtProperty) {
             return getParentByPsiMethod(LightClassUtil.getLightClassPropertyMethods(declaration).getter, declaration.name, true)
         }
 
-        if (declaration is JetClassInitializer) {
+        if (declaration is KtClassInitializer) {
             val parent = declaration.parent
             val grandparent = parent.parent
 
-            if (parent is JetClassBody && grandparent is JetClassOrObject) {
+            if (parent is KtClassBody && grandparent is KtClassOrObject) {
                 return LightClassUtil.getPsiClass(grandparent)
             }
         }
 
-        if (declaration is JetClass) {
+        if (declaration is KtClass) {
             return LightClassUtil.getPsiClass(declaration)
         }
         return null
@@ -133,12 +133,12 @@ public open class KotlinLightClassForExplicitDeclaration(
             containingClass
     }
 
-    override fun getOrigin(): JetClassOrObject = classOrObject
+    override fun getOrigin(): KtClassOrObject = classOrObject
 
     override fun getFqName(): FqName = classFqName
 
     override fun copy(): PsiElement {
-        return KotlinLightClassForExplicitDeclaration(manager, classFqName, classOrObject.copy() as JetClassOrObject)
+        return KotlinLightClassForExplicitDeclaration(manager, classFqName, classOrObject.copy() as KtClassOrObject)
     }
 
     override fun getDelegate(): PsiClass {
@@ -281,7 +281,7 @@ public open class KotlinLightClassForExplicitDeclaration(
         if (isAbstract() || isSealed()) {
             psiModifiers.add(PsiModifier.ABSTRACT)
         }
-        else if (!(classOrObject.hasModifier(OPEN_KEYWORD) || (classOrObject is JetClass && classOrObject.isEnum()))) {
+        else if (!(classOrObject.hasModifier(OPEN_KEYWORD) || (classOrObject is KtClass && classOrObject.isEnum()))) {
             psiModifiers.add(PsiModifier.FINAL)
         }
 
@@ -308,9 +308,9 @@ public open class KotlinLightClassForExplicitDeclaration(
             val typeReference = annotationEntry.typeReference ?: continue
 
             val typeElement = typeReference.typeElement
-            if (typeElement !is JetUserType) continue // If it's not a user type, it's definitely not a ref to deprecated
+            if (typeElement !is KtUserType) continue // If it's not a user type, it's definitely not a ref to deprecated
 
-            val fqName = JetPsiUtil.toQualifiedName(typeElement) ?: continue
+            val fqName = KtPsiUtil.toQualifiedName(typeElement) ?: continue
 
             if (deprecatedFqName == fqName) return true
             if (deprecatedName == fqName.asString()) return true
@@ -319,15 +319,15 @@ public open class KotlinLightClassForExplicitDeclaration(
     }
 
     override fun isInterface(): Boolean {
-        if (classOrObject !is JetClass) return false
+        if (classOrObject !is KtClass) return false
         return classOrObject.isInterface() || classOrObject.isAnnotation()
     }
 
-    override fun isAnnotationType(): Boolean = classOrObject is JetClass && classOrObject.isAnnotation()
+    override fun isAnnotationType(): Boolean = classOrObject is KtClass && classOrObject.isAnnotation()
 
-    override fun isEnum(): Boolean = classOrObject is JetClass && classOrObject.isEnum()
+    override fun isEnum(): Boolean = classOrObject is KtClass && classOrObject.isEnum()
 
-    override fun hasTypeParameters(): Boolean = classOrObject is JetClass && !classOrObject.typeParameters.isEmpty()
+    override fun hasTypeParameters(): Boolean = classOrObject is KtClass && !classOrObject.typeParameters.isEmpty()
 
     override fun isValid(): Boolean = classOrObject.isValid
 
@@ -364,7 +364,7 @@ public open class KotlinLightClassForExplicitDeclaration(
     override fun getOwnInnerClasses(): List<PsiClass> {
         return getDelegate().innerClasses
             .map {
-                val declaration = ClsWrapperStubPsiFactory.getOriginalDeclaration(it) as JetClassOrObject?
+                val declaration = ClsWrapperStubPsiFactory.getOriginalDeclaration(it) as KtClassOrObject?
                 if (declaration != null) create(myManager, declaration, it) else null
             }
             .filterNotNull()
@@ -373,7 +373,7 @@ public open class KotlinLightClassForExplicitDeclaration(
     override fun getUseScope(): SearchScope = getOrigin().useScope
 
     override fun getElementType(): IStubElementType<out StubElement<*>, *>? = classOrObject.elementType
-    override fun getStub(): KotlinClassOrObjectStub<out JetClassOrObject>? = classOrObject.stub
+    override fun getStub(): KotlinClassOrObjectStub<out KtClassOrObject>? = classOrObject.stub
 
     companion object {
         private val JAVA_API_STUB = Key.create<CachedValue<OutermostKotlinClassLightClassData>>("JAVA_API_STUB")
@@ -388,7 +388,7 @@ public open class KotlinLightClassForExplicitDeclaration(
         @JvmOverloads
         public fun create(
                 manager: PsiManager,
-                classOrObject: JetClassOrObject,
+                classOrObject: KtClassOrObject,
                 psiClass: PsiClass? = null
         ): KotlinLightClassForExplicitDeclaration? {
             if (LightClassUtil.belongsToKotlinBuiltIns(classOrObject.getContainingJetFile())) {
@@ -397,7 +397,7 @@ public open class KotlinLightClassForExplicitDeclaration(
 
             val fqName = predictFqName(classOrObject) ?: return null
 
-            if (classOrObject is JetObjectDeclaration && classOrObject.isObjectLiteral()) {
+            if (classOrObject is KtObjectDeclaration && classOrObject.isObjectLiteral()) {
                 return KotlinLightClassForAnonymousDeclaration(manager, fqName, classOrObject)
             }
 
@@ -411,7 +411,7 @@ public open class KotlinLightClassForExplicitDeclaration(
             return KotlinLightClassForExplicitDeclaration(manager, fqName, classOrObject)
         }
 
-        private fun predictFqName(classOrObject: JetClassOrObject): FqName? {
+        private fun predictFqName(classOrObject: KtClassOrObject): FqName? {
             if (classOrObject.isLocal()) {
                 val data = getLightClassDataExactly(classOrObject)
                 return data?.jvmQualifiedName
@@ -420,11 +420,11 @@ public open class KotlinLightClassForExplicitDeclaration(
             return if (internalName == null) null else JvmClassName.byInternalName(internalName).fqNameForClassNameWithoutDollars
         }
 
-        public fun getLightClassData(classOrObject: JetClassOrObject): OutermostKotlinClassLightClassData {
+        public fun getLightClassData(classOrObject: KtClassOrObject): OutermostKotlinClassLightClassData {
             return getLightClassCachedValue(classOrObject).value
         }
 
-        public fun getLightClassCachedValue(classOrObject: JetClassOrObject): CachedValue<OutermostKotlinClassLightClassData> {
+        public fun getLightClassCachedValue(classOrObject: KtClassOrObject): CachedValue<OutermostKotlinClassLightClassData> {
             val outermostClassOrObject = getOutermostClassOrObject(classOrObject)
             var value = outermostClassOrObject.getUserData(JAVA_API_STUB)
             if (value == null) {
@@ -435,13 +435,13 @@ public open class KotlinLightClassForExplicitDeclaration(
             return value
         }
 
-        private fun getLightClassDataExactly(classOrObject: JetClassOrObject): LightClassDataForKotlinClass? {
+        private fun getLightClassDataExactly(classOrObject: KtClassOrObject): LightClassDataForKotlinClass? {
             val data = getLightClassData(classOrObject)
             return data.dataForClass(classOrObject)
         }
 
-        private fun getOutermostClassOrObject(classOrObject: JetClassOrObject): JetClassOrObject {
-            val outermostClass = JetPsiUtil.getOutermostClassOrObject(classOrObject) ?:
+        private fun getOutermostClassOrObject(classOrObject: KtClassOrObject): KtClassOrObject {
+            val outermostClass = KtPsiUtil.getOutermostClassOrObject(classOrObject) ?:
                 throw IllegalStateException("Attempt to build a light class for a local class: " + classOrObject.text)
 
             return outermostClass
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForFacade.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForFacade.kt
index 3018a0adfac..3ed464a4a8c 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForFacade.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForFacade.kt
@@ -31,8 +31,8 @@ import com.intellij.util.containers.SLRUCache
 import org.jetbrains.annotations.NonNls
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtFile
 import javax.swing.Icon
 
 public class KotlinLightClassForFacade private constructor(
@@ -40,7 +40,7 @@ public class KotlinLightClassForFacade private constructor(
         private val facadeClassFqName: FqName,
         private val searchScope: GlobalSearchScope,
         private val lightClassDataCache: CachedValue<KotlinFacadeLightClassData>,
-        files: Collection<JetFile>,
+        files: Collection<KtFile>,
         private val deprecated: Boolean
 ) : KotlinWrappingLightClass(manager), JetJavaMirrorMarker {
 
@@ -100,7 +100,7 @@ public class KotlinLightClassForFacade private constructor(
         }
     }
 
-    public val files: Collection<JetFile> = files.toSet() // needed for hashCode
+    public val files: Collection<KtFile> = files.toSet() // needed for hashCode
 
     private val hashCode: Int =
             computeHashCode()
@@ -118,7 +118,7 @@ public class KotlinLightClassForFacade private constructor(
         lightClassDataCache.value.javaFileStub
     }
 
-    override fun getOrigin(): JetClassOrObject? = null
+    override fun getOrigin(): KtClassOrObject? = null
 
     override fun getFqName(): FqName = facadeClassFqName
 
@@ -240,7 +240,7 @@ public class KotlinLightClassForFacade private constructor(
                 manager: PsiManager,
                 facadeClassFqName: FqName,
                 searchScope: GlobalSearchScope,
-                files: Collection<JetFile>
+                files: Collection<KtFile>
         ): KotlinLightClassForFacade? {
             if (files.any { LightClassUtil.belongsToKotlinBuiltIns(it) }) {
                 return null
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForInterfaceDefaultImpls.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForInterfaceDefaultImpls.kt
index b2907320f08..5c73719b858 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForInterfaceDefaultImpls.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForInterfaceDefaultImpls.kt
@@ -19,16 +19,16 @@ package org.jetbrains.kotlin.asJava
 import com.intellij.psi.*
 import com.intellij.util.IncorrectOperationException
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 
 public open class KotlinLightClassForInterfaceDefaultImpls(
         manager: PsiManager,
         classFqName: FqName,
-        classOrObject: JetClassOrObject)
+        classOrObject: KtClassOrObject)
 : KotlinLightClassForExplicitDeclaration(manager, classFqName, classOrObject){
 
     override fun copy(): PsiElement {
-        return KotlinLightClassForInterfaceDefaultImpls(manager, classFqName, classOrObject.copy() as JetClassOrObject)
+        return KotlinLightClassForInterfaceDefaultImpls(manager, classFqName, classOrObject.copy() as KtClassOrObject)
     }
 
     override fun getTypeParameterList(): PsiTypeParameterList? = null
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightElement.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightElement.kt
index dacf46b6fbf..fa378ea35bd 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightElement.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightElement.kt
@@ -16,11 +16,11 @@
 
 package org.jetbrains.kotlin.asJava
 
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiNamedElement
 
-public interface KotlinLightElement<T : JetDeclaration, D : PsiElement> : PsiNamedElement {
+public interface KotlinLightElement<T : KtDeclaration, D : PsiElement> : PsiNamedElement {
     public fun getOrigin(): T?
 
     public fun getDelegate(): D
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightEnumConstant.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightEnumConstant.kt
index 917c484db07..59747e820fe 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightEnumConstant.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightEnumConstant.kt
@@ -17,15 +17,15 @@
 package org.jetbrains.kotlin.asJava
 
 import com.intellij.psi.*
-import org.jetbrains.kotlin.psi.JetEnumEntry
+import org.jetbrains.kotlin.psi.KtEnumEntry
 
 class KotlinLightEnumConstant(
         manager: PsiManager,
-        origin: JetEnumEntry,
+        origin: KtEnumEntry,
         enumConstant: PsiEnumConstant,
         containingClass: PsiClass,
         private val initializingClass: PsiEnumConstantInitializer?
-) : KotlinLightField<JetEnumEntry, PsiEnumConstant>(manager, origin, enumConstant, containingClass), PsiEnumConstant {
+) : KotlinLightField<KtEnumEntry, PsiEnumConstant>(manager, origin, enumConstant, containingClass), PsiEnumConstant {
     override fun copy() = KotlinLightEnumConstant(getManager()!!, getOrigin(), getDelegate(), getContainingClass()!!, initializingClass)
 
     // NOTE: we don't use "delegation by" because the compiler would generate method calls to ALL of PsiEnumConstant members,
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightField.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightField.java
index b99226f668a..21d9100eb9b 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightField.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightField.java
@@ -28,10 +28,10 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
-import org.jetbrains.kotlin.psi.JetDeclaration;
+import org.jetbrains.kotlin.psi.KtDeclaration;
 
 // Copied from com.intellij.psi.impl.light.LightField
-public abstract class KotlinLightField<T extends JetDeclaration, D extends PsiField> extends LightElement
+public abstract class KotlinLightField<T extends KtDeclaration, D extends PsiField> extends LightElement
         implements PsiField, KotlinLightElement<T, D> {
     private final T origin;
     private final D delegate;
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightFieldForDeclaration.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightFieldForDeclaration.kt
index 4637f1a7f89..f5fd571c3a5 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightFieldForDeclaration.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightFieldForDeclaration.kt
@@ -17,13 +17,13 @@
 package org.jetbrains.kotlin.asJava
 
 import com.intellij.psi.*
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 
 class KotlinLightFieldForDeclaration(
         manager: PsiManager,
-        origin: JetDeclaration,
+        origin: KtDeclaration,
         field: PsiField,
         containingClass: PsiClass
-) : KotlinLightField<JetDeclaration, PsiField>(manager, origin, field, containingClass) {
+) : KotlinLightField<KtDeclaration, PsiField>(manager, origin, field, containingClass) {
     override fun copy() = KotlinLightFieldForDeclaration(getManager()!!, getOrigin(), getDelegate(), getContainingClass()!!)
 }
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethod.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethod.kt
index 7d40c73d9b6..204404e14a0 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethod.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethod.kt
@@ -17,6 +17,6 @@
 package org.jetbrains.kotlin.asJava
 
 import com.intellij.psi.PsiMethod
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 
-public interface KotlinLightMethod: PsiMethod, KotlinLightElement<JetDeclaration, PsiMethod>
+public interface KotlinLightMethod: PsiMethod, KotlinLightElement<KtDeclaration, PsiMethod>
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForDeclaration.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForDeclaration.kt
index 8a9e32bfa1d..f7d30e01079 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForDeclaration.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForDeclaration.kt
@@ -18,14 +18,14 @@ package org.jetbrains.kotlin.asJava
 
 import com.intellij.psi.impl.light.LightMethod
 import com.intellij.psi.*
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import kotlin.properties.Delegates
 import com.intellij.psi.util.CachedValuesManager
 import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.CachedValue
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 import com.intellij.psi.search.SearchScope
 import com.intellij.lang.Language
 import com.intellij.psi.scope.PsiScopeProcessor
@@ -35,7 +35,7 @@ import com.intellij.psi.util.MethodSignatureBackedByPsiMethod
 open public class KotlinLightMethodForDeclaration(
         manager: PsiManager,
         private val delegate: PsiMethod,
-        private val origin: JetDeclaration,
+        private val origin: KtDeclaration,
         containingClass: PsiClass
 ): LightMethod(manager, delegate, containingClass), KotlinLightMethod {
 
@@ -55,7 +55,7 @@ open public class KotlinLightMethodForDeclaration(
     private val typeParamsList: CachedValue<PsiTypeParameterList> by lazy {
         val cacheManager = CachedValuesManager.getManager(delegate.getProject())
         cacheManager.createCachedValue<PsiTypeParameterList>({
-            val list = if (origin is JetClassOrObject) {
+            val list = if (origin is KtClassOrObject) {
                 KotlinLightTypeParameterListBuilder(getManager())
             }
             else {
@@ -70,7 +70,7 @@ open public class KotlinLightMethodForDeclaration(
 
     override fun getDelegate(): PsiMethod = delegate
 
-    override fun getOrigin(): JetDeclaration = origin
+    override fun getOrigin(): KtDeclaration = origin
 
     override fun getParent(): PsiElement? = getContainingClass()
 
@@ -108,7 +108,7 @@ open public class KotlinLightMethodForDeclaration(
     }
 
     override fun copy(): PsiElement {
-        return KotlinLightMethodForDeclaration(getManager()!!, delegate, origin.copy() as JetDeclaration, getContainingClass()!!)
+        return KotlinLightMethodForDeclaration(getManager()!!, delegate, origin.copy() as KtDeclaration, getContainingClass()!!)
     }
 
     override fun getUseScope(): SearchScope = origin.getUseScope()
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForTraitFakeOverride.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForTraitFakeOverride.kt
index 3328415221b..fe7e573617a 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForTraitFakeOverride.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForTraitFakeOverride.kt
@@ -18,21 +18,21 @@ package org.jetbrains.kotlin.asJava
 
 import com.intellij.psi.PsiManager
 import com.intellij.psi.PsiMethod
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
 
 public class KotlinLightMethodForTraitFakeOverride(
         manager: PsiManager,
         private val delegate: PsiMethod,
-        private val origin: JetDeclaration,
+        private val origin: KtDeclaration,
         containingClass: PsiClass
 ) : KotlinLightMethodForDeclaration(manager, delegate, origin, containingClass) {
     override fun getDelegate(): PsiMethod = delegate
 
-    override fun getOrigin(): JetDeclaration = origin
+    override fun getOrigin(): KtDeclaration = origin
 
     override fun copy(): PsiElement {
-        return KotlinLightMethodForTraitFakeOverride(getManager(), delegate, origin.copy() as JetDeclaration, getContainingClass()!!)
+        return KotlinLightMethodForTraitFakeOverride(getManager(), delegate, origin.copy() as KtDeclaration, getContainingClass()!!)
     }
 }
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/JetLightPackage.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightPackage.java
similarity index 85%
rename from compiler/light-classes/src/org/jetbrains/kotlin/asJava/JetLightPackage.java
rename to compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightPackage.java
index 54f3e35cf34..e8b08644f04 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/JetLightPackage.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightPackage.java
@@ -23,12 +23,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.name.FqName;
 
-public class JetLightPackage extends PsiPackageImpl {
+public class KotlinLightPackage extends PsiPackageImpl {
 
     private final FqName fqName;
     private final GlobalSearchScope scope;
 
-    public JetLightPackage(PsiManager manager, FqName qualifiedName, GlobalSearchScope scope) {
+    public KotlinLightPackage(PsiManager manager, FqName qualifiedName, GlobalSearchScope scope) {
         super(manager, qualifiedName.asString());
         this.fqName = qualifiedName;
         this.scope = scope;
@@ -37,7 +37,7 @@ public class JetLightPackage extends PsiPackageImpl {
     @NotNull
     @Override
     public PsiElement copy() {
-        return new JetLightPackage(getManager(), fqName, scope);
+        return new KotlinLightPackage(getManager(), fqName, scope);
     }
 
     @Override
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightParameter.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightParameter.java
index 377eec9d7af..c8367813b31 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightParameter.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightParameter.java
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.psi.psiUtil.JetPsiUtilKt;
 
 import java.util.List;
 
-public class KotlinLightParameter extends LightParameter implements KotlinLightElement<JetParameter, PsiParameter> {
+public class KotlinLightParameter extends LightParameter implements KotlinLightElement<KtParameter, PsiParameter> {
     private static String getName(PsiParameter delegate, int index) {
         String name = delegate.getName();
         return name != null ? name : "p" + index;
@@ -71,27 +71,27 @@ public class KotlinLightParameter extends LightParameter implements KotlinLightE
 
     @Nullable
     @Override
-    public JetParameter getOrigin() {
-        JetDeclaration declaration = method.getOrigin();
+    public KtParameter getOrigin() {
+        KtDeclaration declaration = method.getOrigin();
         if (declaration == null) return null;
 
         int jetIndex = JetPsiUtilKt.isExtensionDeclaration(declaration) ? index - 1 : index;
         if (jetIndex < 0) return null;
 
-        if (declaration instanceof JetFunction) {
-            List<JetParameter> paramList = ((JetFunction) declaration).getValueParameters();
+        if (declaration instanceof KtFunction) {
+            List<KtParameter> paramList = ((KtFunction) declaration).getValueParameters();
             return jetIndex < paramList.size() ? paramList.get(jetIndex) : null;
         }
 
         if (jetIndex != 0) return null;
 
-        JetPropertyAccessor setter = null;
-        if (declaration instanceof JetPropertyAccessor) {
-            JetPropertyAccessor accessor = (JetPropertyAccessor) declaration;
+        KtPropertyAccessor setter = null;
+        if (declaration instanceof KtPropertyAccessor) {
+            KtPropertyAccessor accessor = (KtPropertyAccessor) declaration;
             setter = accessor.isSetter() ? accessor : null;
         }
-        else if (declaration instanceof JetProperty) {
-            setter = ((JetProperty) declaration).getSetter();
+        else if (declaration instanceof KtProperty) {
+            setter = ((KtProperty) declaration).getSetter();
         }
 
         return setter != null ? setter.getParameter() : null;
@@ -100,13 +100,13 @@ public class KotlinLightParameter extends LightParameter implements KotlinLightE
     @NotNull
     @Override
     public PsiElement getNavigationElement() {
-        JetParameter origin = getOrigin();
+        KtParameter origin = getOrigin();
         return origin != null ? origin : super.getNavigationElement();
     }
 
     @Override
     public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
-        JetParameter origin = getOrigin();
+        KtParameter origin = getOrigin();
         if (origin != null) {
             origin.setName(name);
         }
@@ -115,7 +115,7 @@ public class KotlinLightParameter extends LightParameter implements KotlinLightE
 
     @Override
     public PsiFile getContainingFile() {
-        JetDeclaration declaration = method.getOrigin();
+        KtDeclaration declaration = method.getOrigin();
         return declaration != null ? declaration.getContainingFile() : super.getContainingFile();
     }
 
@@ -128,7 +128,7 @@ public class KotlinLightParameter extends LightParameter implements KotlinLightE
     @NotNull
     @Override
     public SearchScope getUseScope() {
-        JetParameter origin = getOrigin();
+        KtParameter origin = getOrigin();
         return origin != null ? origin.getUseScope() : GlobalSearchScope.EMPTY_SCOPE;
     }
 
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightTypeParameter.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightTypeParameter.java
index 6902be7b007..3c0f937b5ec 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightTypeParameter.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightTypeParameter.java
@@ -23,11 +23,11 @@ import com.intellij.psi.search.SearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
-import org.jetbrains.kotlin.psi.JetTypeParameter;
-import org.jetbrains.kotlin.psi.JetTypeParameterListOwner;
+import org.jetbrains.kotlin.psi.KtTypeParameter;
+import org.jetbrains.kotlin.psi.KtTypeParameterListOwner;
 
 public class KotlinLightTypeParameter
-        extends AbstractLightClass implements PsiTypeParameter, KotlinLightElement<JetTypeParameter, PsiTypeParameter> {
+        extends AbstractLightClass implements PsiTypeParameter, KotlinLightElement<KtTypeParameter, PsiTypeParameter> {
     private final PsiTypeParameterListOwner owner;
     private final int index;
     private final String name;
@@ -50,8 +50,8 @@ public class KotlinLightTypeParameter
 
     @NotNull
     @Override
-    public JetTypeParameter getOrigin() {
-        JetTypeParameterListOwner jetOwner = (JetTypeParameterListOwner) LightClassUtilsKt.getUnwrapped(owner);
+    public KtTypeParameter getOrigin() {
+        KtTypeParameterListOwner jetOwner = (KtTypeParameterListOwner) LightClassUtilsKt.getUnwrapped(owner);
         assert (jetOwner != null) : "Invalid type parameter owner: " + owner;
 
         return jetOwner.getTypeParameters().get(index);
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinWrappingLightClass.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinWrappingLightClass.java
index 997bc8d50bb..2e877e2d981 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinWrappingLightClass.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinWrappingLightClass.java
@@ -48,7 +48,7 @@ public abstract class KotlinWrappingLightClass extends AbstractLightClass implem
 
     @Nullable
     @Override
-    public abstract JetClassOrObject getOrigin();
+    public abstract KtClassOrObject getOrigin();
 
     @NotNull
     @Override
@@ -121,11 +121,11 @@ public abstract class KotlinWrappingLightClass extends AbstractLightClass implem
         return ContainerUtil.map(getDelegate().getFields(), new Function<PsiField, PsiField>() {
             @Override
             public PsiField fun(PsiField field) {
-                JetDeclaration declaration = ClsWrapperStubPsiFactory.getOriginalDeclaration(field);
-                if (declaration instanceof JetEnumEntry) {
+                KtDeclaration declaration = ClsWrapperStubPsiFactory.getOriginalDeclaration(field);
+                if (declaration instanceof KtEnumEntry) {
                     assert field instanceof PsiEnumConstant : "Field delegate should be an enum constant (" + field.getName() + "):\n" +
                                                               PsiUtilsKt.getElementTextWithContext(declaration);
-                    JetEnumEntry enumEntry = (JetEnumEntry) declaration;
+                    KtEnumEntry enumEntry = (KtEnumEntry) declaration;
                     PsiEnumConstant enumConstant = (PsiEnumConstant) field;
                     FqName enumConstantFqName = new FqName(getFqName().asString() + "." + enumEntry.getName());
                     KotlinLightClassForEnumEntry initializingClass =
@@ -148,9 +148,9 @@ public abstract class KotlinWrappingLightClass extends AbstractLightClass implem
         return ArraysKt.map(getDelegate().getMethods(), new Function1<PsiMethod, PsiMethod>() {
             @Override
             public PsiMethod invoke(PsiMethod method) {
-                JetDeclaration declaration = ClsWrapperStubPsiFactory.getOriginalDeclaration(method);
-                if (declaration instanceof JetPropertyAccessor) {
-                    declaration = PsiTreeUtil.getParentOfType(declaration, JetProperty.class);
+                KtDeclaration declaration = ClsWrapperStubPsiFactory.getOriginalDeclaration(method);
+                if (declaration instanceof KtPropertyAccessor) {
+                    declaration = PsiTreeUtil.getParentOfType(declaration, KtProperty.class);
                 }
 
                 if (declaration != null) {
@@ -177,7 +177,7 @@ public abstract class KotlinWrappingLightClass extends AbstractLightClass implem
 
     @Override
     public String getText() {
-        JetClassOrObject origin = getOrigin();
+        KtClassOrObject origin = getOrigin();
         return origin == null ? null : origin.getText();
     }
 
@@ -187,18 +187,18 @@ public abstract class KotlinWrappingLightClass extends AbstractLightClass implem
         return KotlinLanguage.INSTANCE;
     }
 
-    private boolean isTraitFakeOverride(@NotNull JetDeclaration originMethodDeclaration) {
-        if (!(originMethodDeclaration instanceof JetNamedFunction ||
-              originMethodDeclaration instanceof JetPropertyAccessor ||
-              originMethodDeclaration instanceof JetProperty)) {
+    private boolean isTraitFakeOverride(@NotNull KtDeclaration originMethodDeclaration) {
+        if (!(originMethodDeclaration instanceof KtNamedFunction ||
+              originMethodDeclaration instanceof KtPropertyAccessor ||
+              originMethodDeclaration instanceof KtProperty)) {
             return false;
         }
 
-        JetClassOrObject parentOfMethodOrigin = PsiTreeUtil.getParentOfType(originMethodDeclaration, JetClassOrObject.class);
-        JetClassOrObject thisClassDeclaration = getOrigin();
+        KtClassOrObject parentOfMethodOrigin = PsiTreeUtil.getParentOfType(originMethodDeclaration, KtClassOrObject.class);
+        KtClassOrObject thisClassDeclaration = getOrigin();
 
         // Method was generated from declaration in some other trait
-        return (parentOfMethodOrigin != null && thisClassDeclaration != parentOfMethodOrigin && JetPsiUtil.isTrait(parentOfMethodOrigin));
+        return (parentOfMethodOrigin != null && thisClassDeclaration != parentOfMethodOrigin && KtPsiUtil.isTrait(parentOfMethodOrigin));
     }
 
     @Override
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassGenerationSupport.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassGenerationSupport.java
index 9793c6c9838..6b559c37eae 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassGenerationSupport.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassGenerationSupport.java
@@ -24,8 +24,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtFile;
 
 import java.util.Collection;
 
@@ -37,13 +37,13 @@ public abstract class LightClassGenerationSupport {
     }
 
     @NotNull
-    public abstract LightClassConstructionContext getContextForPackage(@NotNull Collection<JetFile> files);
+    public abstract LightClassConstructionContext getContextForPackage(@NotNull Collection<KtFile> files);
 
     @NotNull
-    public abstract LightClassConstructionContext getContextForClassOrObject(@NotNull JetClassOrObject classOrObject);
+    public abstract LightClassConstructionContext getContextForClassOrObject(@NotNull KtClassOrObject classOrObject);
 
     @NotNull
-    public abstract Collection<JetClassOrObject> findClassOrObjectDeclarations(@NotNull FqName fqName, @NotNull GlobalSearchScope searchScope);
+    public abstract Collection<KtClassOrObject> findClassOrObjectDeclarations(@NotNull FqName fqName, @NotNull GlobalSearchScope searchScope);
 
     /*
      * Finds files whose package declaration is exactly {@code fqName}. For example, if a file declares
@@ -53,11 +53,11 @@ public abstract class LightClassGenerationSupport {
      * If the resulting collection is empty, it means that this package has not other declarations than sub-packages
      */
     @NotNull
-    public abstract Collection<JetFile> findFilesForPackage(@NotNull FqName fqName, @NotNull GlobalSearchScope searchScope);
+    public abstract Collection<KtFile> findFilesForPackage(@NotNull FqName fqName, @NotNull GlobalSearchScope searchScope);
 
     // Returns only immediately declared classes/objects, package classes are not included (they have no declarations)
     @NotNull
-    public abstract Collection<JetClassOrObject> findClassOrObjectDeclarationsInPackage(
+    public abstract Collection<KtClassOrObject> findClassOrObjectDeclarationsInPackage(
             @NotNull FqName packageFqName,
             @NotNull GlobalSearchScope searchScope
     );
@@ -68,10 +68,10 @@ public abstract class LightClassGenerationSupport {
     public abstract Collection<FqName> getSubPackages(@NotNull FqName fqn, @NotNull GlobalSearchScope scope);
 
     @Nullable
-    public abstract PsiClass getPsiClass(@NotNull JetClassOrObject classOrObject);
+    public abstract PsiClass getPsiClass(@NotNull KtClassOrObject classOrObject);
 
     @Nullable
-    public abstract ClassDescriptor resolveClassToDescriptor(@NotNull JetClassOrObject classOrObject);
+    public abstract ClassDescriptor resolveClassToDescriptor(@NotNull KtClassOrObject classOrObject);
 
     @NotNull
     public abstract Collection<PsiClass> getFacadeClasses(@NotNull FqName facadeFqName, @NotNull GlobalSearchScope scope);
@@ -83,9 +83,9 @@ public abstract class LightClassGenerationSupport {
     public abstract Collection<String> getFacadeNames(@NotNull FqName packageFqName, @NotNull GlobalSearchScope scope);
 
     @NotNull
-    public abstract Collection<JetFile> findFilesForFacade(@NotNull FqName facadeFqName, @NotNull GlobalSearchScope scope);
+    public abstract Collection<KtFile> findFilesForFacade(@NotNull FqName facadeFqName, @NotNull GlobalSearchScope scope);
 
     @NotNull
-    public abstract LightClassConstructionContext getContextForFacade(@NotNull Collection<JetFile> files);
+    public abstract LightClassConstructionContext getContextForFacade(@NotNull Collection<KtFile> files);
 
 }
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassStubWithData.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassStubWithData.kt
index e636bc74f89..39dbf047181 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassStubWithData.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassStubWithData.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.asJava
 
 import com.intellij.psi.impl.java.stubs.PsiJavaFileStub
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 
 interface LightClassData
@@ -29,7 +29,7 @@ interface WithFileStubAndExtraDiagnostics {
 }
 
 interface LightClassDataForKotlinClass: LightClassData {
-    val classOrObject: JetClassOrObject
+    val classOrObject: KtClassOrObject
     val jvmQualifiedName: FqName
 }
 
@@ -40,18 +40,18 @@ data class KotlinFacadeLightClassData(
 
 data class InnerKotlinClassLightClassData(
         override val jvmQualifiedName: FqName,
-        override val classOrObject: JetClassOrObject
+        override val classOrObject: KtClassOrObject
 ): LightClassDataForKotlinClass
 
 data class OutermostKotlinClassLightClassData(
         override val javaFileStub: PsiJavaFileStub,
         override val extraDiagnostics: Diagnostics,
         override val jvmQualifiedName: FqName,
-        override val classOrObject: JetClassOrObject,
-        val allInnerClasses: Map<JetClassOrObject, InnerKotlinClassLightClassData>
+        override val classOrObject: KtClassOrObject,
+        val allInnerClasses: Map<KtClassOrObject, InnerKotlinClassLightClassData>
 ): LightClassDataForKotlinClass, WithFileStubAndExtraDiagnostics {
 
-    fun dataForClass(cls: JetClassOrObject): LightClassDataForKotlinClass? =
+    fun dataForClass(cls: KtClassOrObject): LightClassDataForKotlinClass? =
             if (cls == classOrObject) this else allInnerClasses[cls]
 
 }
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassUtil.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassUtil.kt
index 344ede89ce6..876396ea7f8 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassUtil.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassUtil.kt
@@ -56,7 +56,7 @@ public object LightClassUtil {
 
      * Used to skip JetLightClass creation for built-ins, because built-in classes have no Java counterparts
      */
-    public fun belongsToKotlinBuiltIns(file: JetFile): Boolean {
+    public fun belongsToKotlinBuiltIns(file: KtFile): Boolean {
         val virtualFile = file.virtualFile
         if (virtualFile != null) {
             val parent = virtualFile.parent
@@ -125,22 +125,22 @@ public object LightClassUtil {
         return null
     }/*package*/
 
-    public fun getPsiClass(classOrObject: JetClassOrObject?): PsiClass? {
+    public fun getPsiClass(classOrObject: KtClassOrObject?): PsiClass? {
         if (classOrObject == null) return null
         return LightClassGenerationSupport.getInstance(classOrObject.project).getPsiClass(classOrObject)
     }
 
-    public fun getLightClassAccessorMethod(accessor: JetPropertyAccessor): PsiMethod? =
+    public fun getLightClassAccessorMethod(accessor: KtPropertyAccessor): PsiMethod? =
             getLightClassAccessorMethods(accessor).firstOrNull()
 
-    public fun getLightClassAccessorMethods(accessor: JetPropertyAccessor): List<PsiMethod> {
-        val property = accessor.getNonStrictParentOfType<JetProperty>() ?: return emptyList()
+    public fun getLightClassAccessorMethods(accessor: KtPropertyAccessor): List<PsiMethod> {
+        val property = accessor.getNonStrictParentOfType<KtProperty>() ?: return emptyList()
         val wrappers = getPsiMethodWrappers(property, true)
         return wrappers.filter { wrapper -> (accessor.isGetter && !JvmAbi.isSetterName(wrapper.name)) ||
                                             (accessor.isSetter && JvmAbi.isSetterName(wrapper.name)) }
     }
 
-    public fun getLightFieldForCompanionObject(companionObject: JetClassOrObject): PsiField? {
+    public fun getLightFieldForCompanionObject(companionObject: KtClassOrObject): PsiField? {
         val outerPsiClass = getWrappingClass(companionObject, true)
         if (outerPsiClass != null) {
             for (fieldOfParent in outerPsiClass.fields) {
@@ -152,7 +152,7 @@ public object LightClassUtil {
         return null
     }
 
-    public fun getLightClassPropertyMethods(property: JetProperty): PropertyAccessorsPsiMethods {
+    public fun getLightClassPropertyMethods(property: KtProperty): PropertyAccessorsPsiMethods {
         val getter = property.getter
         val setter = property.setter
 
@@ -162,13 +162,13 @@ public object LightClassUtil {
         return extractPropertyAccessors(property, getterWrapper, setterWrapper)
     }
 
-    private fun getLightClassBackingField(declaration: JetDeclaration): PsiField? {
+    private fun getLightClassBackingField(declaration: KtDeclaration): PsiField? {
         var psiClass: PsiClass = getWrappingClass(declaration, true) ?: return null
 
         if (psiClass is KotlinLightClass) {
             val origin = psiClass.getOrigin()
-            if (origin is JetObjectDeclaration && origin.isCompanion()) {
-                val containingClass = PsiTreeUtil.getParentOfType(origin, JetClass::class.java)
+            if (origin is KtObjectDeclaration && origin.isCompanion()) {
+                val containingClass = PsiTreeUtil.getParentOfType(origin, KtClass::class.java)
                 if (containingClass != null) {
                     val containingLightClass = getPsiClass(containingClass)
                     if (containingLightClass != null) {
@@ -186,23 +186,23 @@ public object LightClassUtil {
         return null
     }
 
-    public fun getLightClassPropertyMethods(parameter: JetParameter): PropertyAccessorsPsiMethods {
+    public fun getLightClassPropertyMethods(parameter: KtParameter): PropertyAccessorsPsiMethods {
         return extractPropertyAccessors(parameter, null, null)
     }
 
-    public fun getLightClassMethod(function: JetFunction): PsiMethod? {
+    public fun getLightClassMethod(function: KtFunction): PsiMethod? {
         return getPsiMethodWrapper(function)
     }
 
-    public fun getLightClassMethods(function: JetFunction): List<PsiMethod> {
+    public fun getLightClassMethods(function: KtFunction): List<PsiMethod> {
         return getPsiMethodWrappers(function, true)
     }
 
-    private fun getPsiMethodWrapper(declaration: JetDeclaration): PsiMethod? {
+    private fun getPsiMethodWrapper(declaration: KtDeclaration): PsiMethod? {
         return getPsiMethodWrappers(declaration, false).firstOrNull()
     }
 
-    private fun getPsiMethodWrappers(declaration: JetDeclaration, collectAll: Boolean): List<PsiMethod> {
+    private fun getPsiMethodWrappers(declaration: KtDeclaration, collectAll: Boolean): List<PsiMethod> {
         val psiClasses = getWrappingClasses(declaration, collectAll)
 
         val methods = SmartList<PsiMethod>()
@@ -227,9 +227,9 @@ public object LightClassUtil {
         return methods
     }
 
-    private fun getWrappingClasses(declaration: JetDeclaration, collectAll: Boolean): Collection<PsiClass> {
+    private fun getWrappingClasses(declaration: KtDeclaration, collectAll: Boolean): Collection<PsiClass> {
         val wrappingClass = getWrappingClass(declaration, true)
-        val oldPackagePartWrappingClass = if (declaration.parent is JetFile && collectAll)
+        val oldPackagePartWrappingClass = if (declaration.parent is KtFile && collectAll)
             getWrappingClass(declaration, false)
         else
             null
@@ -237,23 +237,23 @@ public object LightClassUtil {
         return setOf(wrappingClass, oldPackagePartWrappingClass).filterNotNull()
     }
 
-    private fun getWrappingClass(declaration: JetDeclaration, useNewPackageParts: Boolean): PsiClass? {
+    private fun getWrappingClass(declaration: KtDeclaration, useNewPackageParts: Boolean): PsiClass? {
         var declaration = declaration
-        if (declaration is JetParameter) {
-            val constructorClass = JetPsiUtil.getClassIfParameterIsProperty(declaration)
+        if (declaration is KtParameter) {
+            val constructorClass = KtPsiUtil.getClassIfParameterIsProperty(declaration)
             if (constructorClass != null) {
                 return getPsiClass(constructorClass)
             }
         }
 
-        if (declaration is JetPropertyAccessor) {
+        if (declaration is KtPropertyAccessor) {
             val propertyParent = declaration.parent
-            assert(propertyParent is JetProperty) { "JetProperty is expected to be parent of accessor" }
+            assert(propertyParent is KtProperty) { "JetProperty is expected to be parent of accessor" }
 
-            declaration = propertyParent as JetProperty
+            declaration = propertyParent as KtProperty
         }
 
-        if (declaration is JetConstructor<*>) {
+        if (declaration is KtConstructor<*>) {
             return getPsiClass(declaration.getContainingClassOrObject())
         }
 
@@ -265,7 +265,7 @@ public object LightClassUtil {
 
         val parent = declaration.parent
 
-        if (parent is JetFile) {
+        if (parent is KtFile) {
             // top-level declaration
             val fqName = if (useNewPackageParts)
                 parent.javaFileFacadeFqName
@@ -275,27 +275,27 @@ public object LightClassUtil {
             val project = declaration.project
             return JavaElementFinder.getInstance(project).findClass(fqName.asString(), GlobalSearchScope.allScope(project))
         }
-        else if (parent is JetClassBody) {
-            assert(parent.parent is JetClassOrObject)
-            return getPsiClass(parent.parent as JetClassOrObject)
+        else if (parent is KtClassBody) {
+            assert(parent.parent is KtClassOrObject)
+            return getPsiClass(parent.parent as KtClassOrObject)
         }
 
         return null
     }
 
-    public fun canGenerateLightClass(declaration: JetDeclaration): Boolean {
+    public fun canGenerateLightClass(declaration: KtDeclaration): Boolean {
         //noinspection unchecked
-        return PsiTreeUtil.getParentOfType(declaration, JetFunction::class.java, JetProperty::class.java) == null
+        return PsiTreeUtil.getParentOfType(declaration, KtFunction::class.java, KtProperty::class.java) == null
     }
 
     private fun extractPropertyAccessors(
-            jetDeclaration: JetDeclaration,
+            ktDeclaration: KtDeclaration,
             specialGetter: PsiMethod?, specialSetter: PsiMethod?): PropertyAccessorsPsiMethods {
         var getterWrapper = specialGetter
         var setterWrapper = specialSetter
         val additionalAccessors = arrayListOf<PsiMethod>()
 
-        val wrappers = getPsiMethodWrappers(jetDeclaration, true).filter {
+        val wrappers = getPsiMethodWrappers(ktDeclaration, true).filter {
             JvmAbi.isGetterName(it.name) || JvmAbi.isSetterName(it.name)
         }
 
@@ -318,15 +318,15 @@ public object LightClassUtil {
             }
         }
 
-        val backingField = getLightClassBackingField(jetDeclaration)
+        val backingField = getLightClassBackingField(ktDeclaration)
         return PropertyAccessorsPsiMethods(getterWrapper, setterWrapper, backingField, additionalAccessors)
     }
 
     public fun buildLightTypeParameterList(
             owner: PsiTypeParameterListOwner,
-            declaration: JetDeclaration): PsiTypeParameterList {
+            declaration: KtDeclaration): PsiTypeParameterList {
         val builder = KotlinLightTypeParameterListBuilder(owner.manager)
-        if (declaration is JetTypeParameterListOwner) {
+        if (declaration is KtTypeParameterListOwner) {
             val parameters = declaration.typeParameters
             for (i in parameters.indices) {
                 val jetTypeParameter = parameters.get(i)
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/StubClassBuilder.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/StubClassBuilder.java
index a1f9074cc92..f8db645c18a 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/StubClassBuilder.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/StubClassBuilder.java
@@ -25,9 +25,6 @@ import com.intellij.util.containers.Stack;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.AbstractClassBuilder;
-import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
-import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
 import org.jetbrains.org.objectweb.asm.ClassVisitor;
 import org.jetbrains.org.objectweb.asm.FieldVisitor;
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/duplicateJvmSignatureUtil.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/duplicateJvmSignatureUtil.kt
index dde918904c9..54d350358a0 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/duplicateJvmSignatureUtil.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/duplicateJvmSignatureUtil.kt
@@ -30,40 +30,40 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 
 public fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Diagnostics, moduleScope: GlobalSearchScope): Diagnostics? {
-    fun getDiagnosticsForPackage(file: JetFile): Diagnostics? {
+    fun getDiagnosticsForPackage(file: KtFile): Diagnostics? {
         val project = file.getProject()
         val cache = KotlinLightClassForFacade.PackageFacadeStubCache.getInstance(project)
         return cache[file.getPackageFqName(), moduleScope].getValue()?.extraDiagnostics
     }
 
-    fun getDiagnosticsForClass(jetClassOrObject: JetClassOrObject): Diagnostics {
-        return KotlinLightClassForExplicitDeclaration.getLightClassData(jetClassOrObject).extraDiagnostics
+    fun getDiagnosticsForClass(ktClassOrObject: KtClassOrObject): Diagnostics {
+        return KotlinLightClassForExplicitDeclaration.getLightClassData(ktClassOrObject).extraDiagnostics
     }
 
     fun doGetDiagnostics(): Diagnostics? {
         var parent = element.getParent()
-        if (element is JetPropertyAccessor) {
+        if (element is KtPropertyAccessor) {
             parent = parent?.getParent()
         }
-        if (element is JetParameter && element.hasValOrVar()) {
+        if (element is KtParameter && element.hasValOrVar()) {
             // property declared in constructor
-            val parentClass = (parent?.getParent()?.getParent() as? JetClass)
+            val parentClass = (parent?.getParent()?.getParent() as? KtClass)
             if (parentClass != null) {
                 return getDiagnosticsForClass(parentClass)
             }
         }
-        if (element is JetClassOrObject) {
+        if (element is KtClassOrObject) {
             return getDiagnosticsForClass(element)
         }
 
         when (parent) {
-            is JetFile -> {
+            is KtFile -> {
                 return getDiagnosticsForPackage(parent)
             }
-            is JetClassBody -> {
+            is KtClassBody -> {
                 val parentsParent = parent.getParent()
 
-                if (parentsParent is JetClassOrObject) {
+                if (parentsParent is KtClassOrObject) {
                     return getDiagnosticsForClass(parentsParent)
                 }
             }
@@ -83,7 +83,7 @@ class FilteredJvmDiagnostics(val jvmDiagnostics: Diagnostics, val otherDiagnosti
         val higherPriority = setOf<DiagnosticFactory<*>>(
                 CONFLICTING_OVERLOADS, REDECLARATION, NOTHING_TO_OVERRIDE, MANY_IMPL_MEMBER_NOT_IMPLEMENTED)
         return otherDiagnostics.forElement(psiElement).any { it.getFactory() in higherPriority }
-                || psiElement is JetPropertyAccessor && alreadyReported(psiElement.getParent()!!)
+                || psiElement is KtPropertyAccessor && alreadyReported(psiElement.getParent()!!)
     }
 
     override fun forElement(psiElement: PsiElement): Collection<Diagnostic> {
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/lightClassUtils.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/lightClassUtils.kt
index eaad210e621..b8efcca9505 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/lightClassUtils.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/lightClassUtils.kt
@@ -27,69 +27,69 @@ import org.jetbrains.kotlin.utils.addToStdlib.singletonList
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
 import java.util.*
 
-public fun JetClassOrObject.toLightClass(): KotlinLightClass? = LightClassUtil.getPsiClass(this) as KotlinLightClass?
+public fun KtClassOrObject.toLightClass(): KotlinLightClass? = LightClassUtil.getPsiClass(this) as KotlinLightClass?
 
-public fun JetDeclaration.toLightElements(): List<PsiNamedElement> =
+public fun KtDeclaration.toLightElements(): List<PsiNamedElement> =
         when (this) {
-            is JetClassOrObject -> LightClassUtil.getPsiClass(this).singletonOrEmptyList()
-            is JetNamedFunction,
-            is JetSecondaryConstructor -> LightClassUtil.getLightClassMethods(this as JetFunction)
-            is JetProperty -> LightClassUtil.getLightClassPropertyMethods(this).toList()
-            is JetPropertyAccessor -> LightClassUtil.getLightClassAccessorMethod(this).singletonOrEmptyList()
-            is JetParameter -> ArrayList<PsiNamedElement>().let { elements ->
+            is KtClassOrObject -> LightClassUtil.getPsiClass(this).singletonOrEmptyList()
+            is KtNamedFunction,
+            is KtSecondaryConstructor -> LightClassUtil.getLightClassMethods(this as KtFunction)
+            is KtProperty -> LightClassUtil.getLightClassPropertyMethods(this).toList()
+            is KtPropertyAccessor -> LightClassUtil.getLightClassAccessorMethod(this).singletonOrEmptyList()
+            is KtParameter -> ArrayList<PsiNamedElement>().let { elements ->
                 toPsiParameters().toCollection(elements)
                 LightClassUtil.getLightClassPropertyMethods(this).toCollection(elements)
 
                 elements
             }
-            is JetTypeParameter -> toPsiTypeParameters()
+            is KtTypeParameter -> toPsiTypeParameters()
             else -> listOf()
         }
 
 public fun PsiElement.toLightMethods(): List<PsiMethod> =
         when (this) {
-            is JetFunction -> LightClassUtil.getLightClassMethods(this)
-            is JetProperty -> LightClassUtil.getLightClassPropertyMethods(this).toList()
-            is JetParameter -> LightClassUtil.getLightClassPropertyMethods(this).toList()
-            is JetPropertyAccessor -> LightClassUtil.getLightClassAccessorMethods(this)
-            is JetClass -> LightClassUtil.getPsiClass(this)?.getConstructors()?.first().singletonOrEmptyList()
+            is KtFunction -> LightClassUtil.getLightClassMethods(this)
+            is KtProperty -> LightClassUtil.getLightClassPropertyMethods(this).toList()
+            is KtParameter -> LightClassUtil.getLightClassPropertyMethods(this).toList()
+            is KtPropertyAccessor -> LightClassUtil.getLightClassAccessorMethods(this)
+            is KtClass -> LightClassUtil.getPsiClass(this)?.getConstructors()?.first().singletonOrEmptyList()
             is PsiMethod -> this.singletonList()
             else -> listOf()
         }
 
 public fun PsiElement.getRepresentativeLightMethod(): PsiMethod? =
         when (this) {
-            is JetFunction -> LightClassUtil.getLightClassMethod(this)
-            is JetProperty -> LightClassUtil.getLightClassPropertyMethods(this).getter
-            is JetParameter -> LightClassUtil.getLightClassPropertyMethods(this).getter
-            is JetPropertyAccessor -> LightClassUtil.getLightClassAccessorMethod(this)
+            is KtFunction -> LightClassUtil.getLightClassMethod(this)
+            is KtProperty -> LightClassUtil.getLightClassPropertyMethods(this).getter
+            is KtParameter -> LightClassUtil.getLightClassPropertyMethods(this).getter
+            is KtPropertyAccessor -> LightClassUtil.getLightClassAccessorMethod(this)
             is PsiMethod -> this
             else -> null
         }
 
-public fun JetParameter.toPsiParameters(): Collection<PsiParameter> {
-    val paramList = getNonStrictParentOfType<JetParameterList>() ?: return emptyList()
+public fun KtParameter.toPsiParameters(): Collection<PsiParameter> {
+    val paramList = getNonStrictParentOfType<KtParameterList>() ?: return emptyList()
 
     val paramIndex = paramList.getParameters().indexOf(this)
     val owner = paramList.getParent()
-    val lightParamIndex = if (owner is JetDeclaration && owner.isExtensionDeclaration()) paramIndex + 1 else paramIndex
+    val lightParamIndex = if (owner is KtDeclaration && owner.isExtensionDeclaration()) paramIndex + 1 else paramIndex
 
     val methods: Collection<PsiMethod> =
             when (owner) {
-                is JetFunction -> LightClassUtil.getLightClassMethods(owner)
-                is JetPropertyAccessor -> LightClassUtil.getLightClassAccessorMethods(owner)
+                is KtFunction -> LightClassUtil.getLightClassMethods(owner)
+                is KtPropertyAccessor -> LightClassUtil.getLightClassAccessorMethods(owner)
                 else -> null
             } ?: return emptyList()
 
     return methods.map { it.getParameterList().getParameters()[lightParamIndex] }
 }
 
-public fun JetTypeParameter.toPsiTypeParameters(): List<PsiTypeParameter> {
-    val paramList = getNonStrictParentOfType<JetTypeParameterList>()
+public fun KtTypeParameter.toPsiTypeParameters(): List<PsiTypeParameter> {
+    val paramList = getNonStrictParentOfType<KtTypeParameterList>()
     if (paramList == null) return listOf()
 
     val paramIndex = paramList.getParameters().indexOf(this)
-    val jetDeclaration = paramList.getNonStrictParentOfType<JetDeclaration>() ?: return listOf()
+    val jetDeclaration = paramList.getNonStrictParentOfType<KtDeclaration>() ?: return listOf()
     val lightOwners = jetDeclaration.toLightElements()
 
     return lightOwners.map { lightOwner -> (lightOwner as PsiTypeParameterListOwner).getTypeParameters()[paramIndex] }
@@ -103,8 +103,8 @@ public val PsiElement.namedUnwrappedElement: PsiNamedElement?
     get() = unwrapped?.getNonStrictParentOfType<PsiNamedElement>()
 
 
-val JetClassOrObject.hasInterfaceDefaultImpls: Boolean
-    get() = this is JetClass && isInterface()
+val KtClassOrObject.hasInterfaceDefaultImpls: Boolean
+    get() = this is KtClass && isInterface()
 
 private val DEFAULT_IMPLS_CLASS_NAME = Name.identifier(JvmAbi.DEFAULT_IMPLS_CLASS_NAME)
 fun FqName.defaultImplsChild() = child(DEFAULT_IMPLS_CLASS_NAME)
diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java
index c87c51e8cca..01ad515263f 100644
--- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java
+++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java
@@ -139,7 +139,7 @@ public class DescriptorSerializer {
 
         if (!KotlinBuiltIns.isSpecialClassWithNoSupertypes(classDescriptor)) {
             // Special classes (Any, Nothing) have no supertypes
-            for (JetType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
+            for (KtType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
                 if (useTypeTable()) {
                     builder.addSupertypeId(typeId(supertype));
                 }
@@ -382,7 +382,7 @@ public class DescriptorSerializer {
             builder.setType(type(descriptor.getType()));
         }
 
-        JetType varargElementType = descriptor.getVarargElementType();
+        KtType varargElementType = descriptor.getVarargElementType();
         if (varargElementType != null) {
             if (useTypeTable()) {
                 builder.setVarargElementTypeId(typeId(varargElementType));
@@ -414,10 +414,10 @@ public class DescriptorSerializer {
         }
         extension.serializeTypeParameter(typeParameter, builder);
 
-        Set<JetType> upperBounds = typeParameter.getUpperBounds();
+        Set<KtType> upperBounds = typeParameter.getUpperBounds();
         if (upperBounds.size() == 1 && KotlinBuiltIns.isDefaultBound(CollectionsKt.single(upperBounds))) return builder;
 
-        for (JetType upperBound : upperBounds) {
+        for (KtType upperBound : upperBounds) {
             if (useTypeTable()) {
                 builder.addUpperBoundId(typeId(upperBound));
             }
@@ -441,12 +441,12 @@ public class DescriptorSerializer {
         throw new IllegalStateException("Unknown variance: " + variance);
     }
 
-    private int typeId(@NotNull JetType type) {
+    private int typeId(@NotNull KtType type) {
         return typeTable.get(type(type));
     }
 
     @NotNull
-    private ProtoBuf.Type.Builder type(@NotNull JetType type) {
+    private ProtoBuf.Type.Builder type(@NotNull KtType type) {
         assert !type.isError() : "Can't serialize error types: " + type; // TODO
 
         if (FlexibleTypesKt.isFlexible(type)) {
diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtension.java b/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtension.java
index 3a5f57b7957..5b6a7bcb15d 100644
--- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtension.java
+++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtension.java
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.serialization;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collection;
 
@@ -48,7 +48,7 @@ public abstract class SerializerExtension {
     public void serializeValueParameter(@NotNull ValueParameterDescriptor descriptor, @NotNull ProtoBuf.ValueParameter.Builder proto) {
     }
 
-    public void serializeType(@NotNull JetType type, @NotNull ProtoBuf.Type.Builder proto) {
+    public void serializeType(@NotNull KtType type, @NotNull ProtoBuf.Type.Builder proto) {
     }
 
     public void serializeTypeParameter(@NotNull TypeParameterDescriptor typeParameter, @NotNull ProtoBuf.TypeParameter.Builder proto) {
diff --git a/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/Baz.java~- InnerClasses & EnclosingMethod attributes for local classes b/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/Baz.java~- InnerClasses & EnclosingMethod attributes for local classes
new file mode 100644
index 00000000000..d5fd7bcb24a
--- /dev/null
+++ b/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/Baz.java~- InnerClasses & EnclosingMethod attributes for local classes	
@@ -0,0 +1,5 @@
+public class Baz {
+    public static String baz() {
+        return Util.foo() + Util.bar();
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/Baz.java~HEAD b/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/Baz.java~HEAD
new file mode 100644
index 00000000000..d5fd7bcb24a
--- /dev/null
+++ b/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/Baz.java~HEAD
@@ -0,0 +1,5 @@
+public class Baz {
+    public static String baz() {
+        return Util.foo() + Util.bar();
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/foo.kt~- InnerClasses & EnclosingMethod attributes for local classes b/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/foo.kt~- InnerClasses & EnclosingMethod attributes for local classes
new file mode 100644
index 00000000000..6c6939f4453
--- /dev/null
+++ b/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/foo.kt~- InnerClasses & EnclosingMethod attributes for local classes	
@@ -0,0 +1,5 @@
+@file:JvmName("Util")
+@file:JvmMultifileClass
+public fun foo(): String = foox()
+
+public fun barx(): String = "K"
\ No newline at end of file
diff --git a/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/foo.kt~HEAD b/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/foo.kt~HEAD
new file mode 100644
index 00000000000..6c6939f4453
--- /dev/null
+++ b/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/foo.kt~HEAD
@@ -0,0 +1,5 @@
+@file:JvmName("Util")
+@file:JvmMultifileClass
+public fun foo(): String = foox()
+
+public fun barx(): String = "K"
\ No newline at end of file
diff --git a/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/multifileClassWithInternal.kt~- InnerClasses & EnclosingMethod attributes for local classes b/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/multifileClassWithInternal.kt~- InnerClasses & EnclosingMethod attributes for local classes
new file mode 100644
index 00000000000..936b887daa8
--- /dev/null
+++ b/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/multifileClassWithInternal.kt~- InnerClasses & EnclosingMethod attributes for local classes	
@@ -0,0 +1 @@
+fun box(): String = Baz.baz()
\ No newline at end of file
diff --git a/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/multifileClassWithInternal.kt~HEAD b/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/multifileClassWithInternal.kt~HEAD
new file mode 100644
index 00000000000..936b887daa8
--- /dev/null
+++ b/compiler/testData/codegen/boxWithJava/fileClasses/multifileClassWithCrossCall/multifileClassWithInternal.kt~HEAD
@@ -0,0 +1 @@
+fun box(): String = Baz.baz()
\ No newline at end of file
diff --git a/compiler/tests/org/jetbrains/kotlin/cfg/AbstractPseudoValueTest.kt b/compiler/tests/org/jetbrains/kotlin/cfg/AbstractPseudoValueTest.kt
index ac2be2fa8ed..8c631908e0e 100644
--- a/compiler/tests/org/jetbrains/kotlin/cfg/AbstractPseudoValueTest.kt
+++ b/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)
         }
diff --git a/compiler/tests/org/jetbrains/kotlin/cfg/AbstractPseudocodeTest.java b/compiler/tests/org/jetbrains/kotlin/cfg/AbstractPseudocodeTest.java
index c2cdbad92e1..3596bbc8e14 100644
--- a/compiler/tests/org/jetbrains/kotlin/cfg/AbstractPseudocodeTest.java
+++ b/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");
diff --git a/compiler/tests/org/jetbrains/kotlin/cfg/CFGraphToDotFilePrinter.java b/compiler/tests/org/jetbrains/kotlin/cfg/CFGraphToDotFilePrinter.java
index b21258c3a15..ab6412dd6d9 100644
--- a/compiler/tests/org/jetbrains/kotlin/cfg/CFGraphToDotFilePrinter.java
+++ b/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 {
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java
index 3b59674c786..973105a053d 100644
--- a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java
+++ b/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();
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLib.java b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLib.java
index 8ed866fdbe1..9ebf56220c9 100644
--- a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLib.java
+++ b/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);
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLibAndBackendCompilation.kt b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLibAndBackendCompilation.kt
index 8f6759e49c2..81b95271b50 100644
--- a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLibAndBackendCompilation.kt
+++ b/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())
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.java b/compiler/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.java
index 5f0852146c4..c5601072251 100644
--- a/compiler/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.java
+++ b/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;
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/CheckerTestUtilTest.java b/compiler/tests/org/jetbrains/kotlin/checkers/CheckerTestUtilTest.java
index 43adead9166..0849e5893c9 100644
--- a/compiler/tests/org/jetbrains/kotlin/checkers/CheckerTestUtilTest.java
+++ b/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();
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/LazyOperationsLog.kt b/compiler/tests/org/jetbrains/kotlin/checkers/LazyOperationsLog.kt
index 3204db359b2..6b22b5275bb 100644
--- a/compiler/tests/org/jetbrains/kotlin/checkers/LazyOperationsLog.kt
+++ b/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()) {
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java
index 019da24d9e9..09ca79cdfe8 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java
+++ b/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);
 
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java
index 1f7d1feb27c..c4e1581ac86 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java
+++ b/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");
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestFiles.java b/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestFiles.java
index 1bd94b7d29d..40100051ec6 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestFiles.java
+++ b/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;
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/GenerateNotNullAssertionsTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/GenerateNotNullAssertionsTest.java
index e86e8a500d0..e3ffd4cafd0 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/GenerateNotNullAssertionsTest.java
+++ b/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);
         }
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/GenerationUtils.java b/compiler/tests/org/jetbrains/kotlin/codegen/GenerationUtils.java
index dc6e4001a34..64f0fc7a584 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/GenerationUtils.java
+++ b/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();
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/InlineTestUtil.kt b/compiler/tests/org/jetbrains/kotlin/codegen/InlineTestUtil.kt
index 56382eccf7b..e809c322aa3 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/InlineTestUtil.kt
+++ b/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" }
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/TestlibTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/TestlibTest.java
index d08746bc320..9cd781f1184 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/TestlibTest.java
+++ b/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();
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java
index 7843ccd0894..6de47ddb865 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java
+++ b/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);
 
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java
index b37b7f998fb..f2c5b9086c8 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java
+++ b/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 {
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java
index 011bd87837a..7e06dc4842a 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java
+++ b/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());
 
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstKotlinTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstKotlinTest.java
index 2cadb539eee..6816707d001 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstKotlinTest.java
+++ b/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"));
 
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java
index fd5fec09a4c..eeef9f60a08 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java
+++ b/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)
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractSMAPBaseTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractSMAPBaseTest.kt
index f8e86e71371..461b9db2c10 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractSMAPBaseTest.kt
+++ b/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
         }
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractSdkAnnotationsValidityTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractSdkAnnotationsValidityTest.java
index 363284f9704..1bf1ebb714c 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractSdkAnnotationsValidityTest.java
+++ b/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);
             }
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/DeserializedScopeValidationVisitor.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/DeserializedScopeValidationVisitor.kt
index c0b7559d99a..ebb9d9a7db9 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/DeserializedScopeValidationVisitor.kt
+++ b/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()
     }
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java
index 77b4dc3a3f9..bcc71fe13f9 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java
+++ b/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);
                 }
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java
index 24f01667d44..f847b4e40a5 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java
+++ b/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;
         }
 
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt
index 8e1bd39441a..cc468af388b 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt
+++ b/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()
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt
index 85afd847a42..8c3f8db2619 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt
+++ b/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)
diff --git a/compiler/tests/org/jetbrains/kotlin/parsing/AbstractJetParsingTest.java b/compiler/tests/org/jetbrains/kotlin/parsing/AbstractJetParsingTest.java
index 83b36ad457a..e2bb683c48e 100644
--- a/compiler/tests/org/jetbrains/kotlin/parsing/AbstractJetParsingTest.java
+++ b/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 {
diff --git a/compiler/tests/org/jetbrains/kotlin/psi/JetPsiUtilTest.java b/compiler/tests/org/jetbrains/kotlin/psi/JetPsiUtilTest.java
index 419d3d60341..68cce022405 100644
--- a/compiler/tests/org/jetbrains/kotlin/psi/JetPsiUtilTest.java
+++ b/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));
         }
     }
 }
diff --git a/compiler/tests/org/jetbrains/kotlin/psi/JetSimpleNameExpressionTest.kt b/compiler/tests/org/jetbrains/kotlin/psi/JetSimpleNameExpressionTest.kt
index 788880ac5f5..695b9d6bb7f 100644
--- a/compiler/tests/org/jetbrains/kotlin/psi/JetSimpleNameExpressionTest.kt
+++ b/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 {
diff --git a/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt b/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt
index 17732a9517b..cd2d4c32768 100644
--- a/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt
+++ b/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)
diff --git a/compiler/tests/org/jetbrains/kotlin/renderer/AbstractFunctionDescriptorInExpressionRendererTest.kt b/compiler/tests/org/jetbrains/kotlin/renderer/AbstractFunctionDescriptorInExpressionRendererTest.kt
index 07b665f73ba..9d525996d84 100644
--- a/compiler/tests/org/jetbrains/kotlin/renderer/AbstractFunctionDescriptorInExpressionRendererTest.kt
+++ b/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())!!)
             }
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/AbstractResolveTest.java b/compiler/tests/org/jetbrains/kotlin/resolve/AbstractResolveTest.java
index 44c94dfffff..ddb3a4d567a 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/AbstractResolveTest.java
+++ b/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);
             }
         };
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/ExpectedResolveData.java b/compiler/tests/org/jetbrains/kotlin/resolve/ExpectedResolveData.java
index eaf1870c5a1..72d8cb34111 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/ExpectedResolveData.java
+++ b/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);
 
 
 
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/ExtensibleResolveTestCase.java b/compiler/tests/org/jetbrains/kotlin/resolve/ExtensibleResolveTestCase.java
index 696b0279539..f2c8131b7b7 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/ExtensibleResolveTestCase.java
+++ b/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);
             }
         });
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java
index 361c8328ffc..1b23ce3cf9e 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java
+++ b/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);
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/MutableDiagnosticsTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/MutableDiagnosticsTest.kt
index 807f40a447a..87911a11ccb 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/MutableDiagnosticsTest.kt
+++ b/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
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java b/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java
index f0f0326368c..8dc1695a722 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java
+++ b/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;
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt
index 1756c970afd..6f5dca91d08 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt
+++ b/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)
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedConstructorDelegationCallsTests.kt b/compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedConstructorDelegationCallsTests.kt
index b787fd20fb3..d34985a0090 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedConstructorDelegationCallsTests.kt
+++ b/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)
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/constants/evaluate/AbstractEvaluateExpressionTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/constants/evaluate/AbstractEvaluateExpressionTest.kt
index 57ae64d2424..d0d5d5e8ad9 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/constants/evaluate/AbstractEvaluateExpressionTest.kt
+++ b/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"),
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt
index 3d18cb13eef..8ce82aa77d7 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt
+++ b/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
         }
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt b/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt
index 0f15f95f268..b3ffefd2b63 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt
+++ b/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)
     }
 }
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java
index abdc0f147a4..960d881543e 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java
+++ b/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
     ) {
 
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java
index c490de28c59..c413501352d 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java
+++ b/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);
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtils.kt b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtils.kt
index 5813874fa41..d6d3889b003 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtils.kt
+++ b/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)
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt
index 3f273172a53..7323a09adbf 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt
+++ b/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" } ?:
diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/builtins/LoadBuiltinsTest.java b/compiler/tests/org/jetbrains/kotlin/serialization/builtins/LoadBuiltinsTest.java
index 80d35e4705c..8d7c632944b 100644
--- a/compiler/tests/org/jetbrains/kotlin/serialization/builtins/LoadBuiltinsTest.java
+++ b/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")
         ));
diff --git a/compiler/tests/org/jetbrains/kotlin/test/JetLiteFixture.java b/compiler/tests/org/jetbrains/kotlin/test/JetLiteFixture.java
index 3977ffe0a29..f5da315de56 100644
--- a/compiler/tests/org/jetbrains/kotlin/test/JetLiteFixture.java
+++ b/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()));
diff --git a/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java b/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java
index 2386302b492..8b41cc34f06 100644
--- a/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java
+++ b/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));
         }
diff --git a/compiler/tests/org/jetbrains/kotlin/test/util/DescriptorValidator.java b/compiler/tests/org/jetbrains/kotlin/test/util/DescriptorValidator.java
index 6502074b082..fedb60fc0a5 100644
--- a/compiler/tests/org/jetbrains/kotlin/test/util/DescriptorValidator.java
+++ b/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;
diff --git a/compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java b/compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java
index 76f36eaa1f7..a4c8a1ba45f 100644
--- a/compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java
+++ b/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
     ) {
diff --git a/compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessorTest.java b/compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessorTest.java
index b8c95bc8ead..f8ea0279933 100644
--- a/compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessorTest.java
+++ b/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")));
 
diff --git a/compiler/tests/org/jetbrains/kotlin/test/util/jetTestUtils.kt b/compiler/tests/org/jetbrains/kotlin/test/util/jetTestUtils.kt
index 4a6019f97bc..0450b9bca4d 100644
--- a/compiler/tests/org/jetbrains/kotlin/test/util/jetTestUtils.kt
+++ b/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
 
diff --git a/compiler/tests/org/jetbrains/kotlin/types/AbstractJetTypeBindingTest.kt b/compiler/tests/org/jetbrains/kotlin/types/AbstractJetTypeBindingTest.kt
index 513b01d3bb4..fb3e1eec756 100644
--- a/compiler/tests/org/jetbrains/kotlin/types/AbstractJetTypeBindingTest.kt
+++ b/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 {
diff --git a/compiler/tests/org/jetbrains/kotlin/types/BoundsSubstitutorTest.java b/compiler/tests/org/jetbrains/kotlin/types/BoundsSubstitutorTest.java
index 5a717027cff..05caa489b10 100644
--- a/compiler/tests/org/jetbrains/kotlin/types/BoundsSubstitutorTest.java
+++ b/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);
diff --git a/compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java
index cb8f2d1e6b0..bfb3ad987ad 100644
--- a/compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java
+++ b/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
diff --git a/compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java b/compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java
index 558d8f03526..89f5930c1f2 100644
--- a/compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java
+++ b/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);
     }
diff --git a/compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java b/compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java
index 4cdc77ef9bc..944068525ba 100644
--- a/compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java
+++ b/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);
diff --git a/compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java
index ace5ed14225..ef16ff1faab 100644
--- a/compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java
+++ b/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);
     }
 }
diff --git a/compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java b/compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java
index 0a26896f23c..b7fc4532175 100644
--- a/compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java
+++ b/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(),
diff --git a/compiler/tests/org/jetbrains/kotlin/types/TypeUnifierTest.java b/compiler/tests/org/jetbrains/kotlin/types/TypeUnifierTest.java
index 555d7d323c4..b8682c1535f 100644
--- a/compiler/tests/org/jetbrains/kotlin/types/TypeUnifierTest.java
+++ b/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:
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/ExternalSignatureResolver.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/ExternalSignatureResolver.java
index 338adf9e7d5..60e9972313a 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/ExternalSignatureResolver.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/ExternalSignatureResolver.java
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.load.java.structure.JavaField;
 import org.jetbrains.kotlin.load.java.structure.JavaMember;
 import org.jetbrains.kotlin.load.java.structure.JavaMethod;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collections;
 import java.util.List;
@@ -34,8 +34,8 @@ public interface ExternalSignatureResolver {
         public PropagatedMethodSignature resolvePropagatedSignature(
                 @NotNull JavaMethod method,
                 @NotNull ClassDescriptor owner,
-                @NotNull JetType returnType,
-                @Nullable JetType receiverType,
+                @NotNull KtType returnType,
+                @Nullable KtType receiverType,
                 @NotNull List<ValueParameterDescriptor> valueParameters,
                 @NotNull List<TypeParameterDescriptor> typeParameters
         ) {
@@ -50,8 +50,8 @@ public interface ExternalSignatureResolver {
         public AlternativeMethodSignature resolveAlternativeMethodSignature(
                 @NotNull JavaMember methodOrConstructor,
                 boolean hasSuperMethods,
-                @Nullable JetType returnType,
-                @Nullable JetType receiverType,
+                @Nullable KtType returnType,
+                @Nullable KtType receiverType,
                 @NotNull List<ValueParameterDescriptor> valueParameters,
                 @NotNull List<TypeParameterDescriptor> typeParameters,
                 boolean hasStableParameterNames
@@ -64,7 +64,7 @@ public interface ExternalSignatureResolver {
         @NotNull
         @Override
         public AlternativeFieldSignature resolveAlternativeFieldSignature(
-                @NotNull JavaField field, @NotNull JetType returnType, boolean isVar
+                @NotNull JavaField field, @NotNull KtType returnType, boolean isVar
         ) {
             return new AlternativeFieldSignature(returnType, null);
         }
@@ -89,15 +89,15 @@ public interface ExternalSignatureResolver {
     }
 
     class AlternativeMethodSignature extends MemberSignature {
-        private final JetType returnType;
-        private final JetType receiverType;
+        private final KtType returnType;
+        private final KtType receiverType;
         private final List<ValueParameterDescriptor> valueParameters;
         private final List<TypeParameterDescriptor> typeParameters;
         private final boolean hasStableParameterNames;
 
         public AlternativeMethodSignature(
-                @Nullable JetType returnType,
-                @Nullable JetType receiverType,
+                @Nullable KtType returnType,
+                @Nullable KtType receiverType,
                 @NotNull List<ValueParameterDescriptor> valueParameters,
                 @NotNull List<TypeParameterDescriptor> typeParameters,
                 @NotNull List<String> signatureErrors,
@@ -112,12 +112,12 @@ public interface ExternalSignatureResolver {
         }
 
         @Nullable
-        public JetType getReturnType() {
+        public KtType getReturnType() {
             return returnType;
         }
 
         @Nullable
-        public JetType getReceiverType() {
+        public KtType getReceiverType() {
             return receiverType;
         }
 
@@ -137,15 +137,15 @@ public interface ExternalSignatureResolver {
     }
 
     class AlternativeFieldSignature extends MemberSignature {
-        private final JetType returnType;
+        private final KtType returnType;
 
-        public AlternativeFieldSignature(@NotNull JetType returnType, @Nullable String signatureError) {
+        public AlternativeFieldSignature(@NotNull KtType returnType, @Nullable String signatureError) {
             super(signatureError == null ? Collections.<String>emptyList() : Collections.singletonList(signatureError));
             this.returnType = returnType;
         }
 
         @NotNull
-        public JetType getReturnType() {
+        public KtType getReturnType() {
             return returnType;
         }
     }
@@ -154,8 +154,8 @@ public interface ExternalSignatureResolver {
         private final List<FunctionDescriptor> superMethods;
 
         public PropagatedMethodSignature(
-                @Nullable JetType returnType,
-                @Nullable JetType receiverType,
+                @Nullable KtType returnType,
+                @Nullable KtType receiverType,
                 @NotNull List<ValueParameterDescriptor> valueParameters,
                 @NotNull List<TypeParameterDescriptor> typeParameters,
                 @NotNull List<String> signatureErrors,
@@ -176,8 +176,8 @@ public interface ExternalSignatureResolver {
     PropagatedMethodSignature resolvePropagatedSignature(
             @NotNull JavaMethod method,
             @NotNull ClassDescriptor owner,
-            @NotNull JetType returnType,
-            @Nullable JetType receiverType,
+            @NotNull KtType returnType,
+            @Nullable KtType receiverType,
             @NotNull List<ValueParameterDescriptor> valueParameters,
             @NotNull List<TypeParameterDescriptor> typeParameters
     );
@@ -186,8 +186,8 @@ public interface ExternalSignatureResolver {
     AlternativeMethodSignature resolveAlternativeMethodSignature(
             @NotNull JavaMember methodOrConstructor,
             boolean hasSuperMethods,
-            @Nullable JetType returnType,
-            @Nullable JetType receiverType,
+            @Nullable KtType returnType,
+            @Nullable KtType receiverType,
             @NotNull List<ValueParameterDescriptor> valueParameters,
             @NotNull List<TypeParameterDescriptor> typeParameters,
             boolean hasStableParameterNames
@@ -196,7 +196,7 @@ public interface ExternalSignatureResolver {
     @NotNull
     AlternativeFieldSignature resolveAlternativeFieldSignature(
             @NotNull JavaField field,
-            @NotNull JetType returnType,
+            @NotNull KtType returnType,
             boolean isVar
     );
 
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/SamConversionResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/SamConversionResolver.kt
index 4a2a3528408..b17b1a52550 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/SamConversionResolver.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/SamConversionResolver.kt
@@ -21,24 +21,24 @@ import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptor
 import org.jetbrains.kotlin.load.java.structure.JavaMethod
 import org.jetbrains.kotlin.name.Name
-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
 
 public interface SamConversionResolver {
     public companion object EMPTY : SamConversionResolver {
         override fun <D : FunctionDescriptor> resolveSamAdapter(original: D) = null
-        override fun resolveSamConstructor(name: Name, scope: JetScope) = null
+        override fun resolveSamConstructor(name: Name, scope: KtScope) = null
         override fun resolveFunctionTypeIfSamInterface(
                 classDescriptor: JavaClassDescriptor, resolveMethod: (JavaMethod) -> FunctionDescriptor
-        ): JetType? = null
+        ): KtType? = null
     }
 
-    public fun resolveSamConstructor(name: Name, scope: JetScope): SamConstructorDescriptor?
+    public fun resolveSamConstructor(name: Name, scope: KtScope): SamConstructorDescriptor?
 
     public fun <D : FunctionDescriptor> resolveSamAdapter(original: D): D?
 
     public fun resolveFunctionTypeIfSamInterface(
             classDescriptor: JavaClassDescriptor,
             resolveMethod: (JavaMethod) -> FunctionDescriptor
-    ): JetType?
+    ): KtType?
 }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaCallableMemberDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaCallableMemberDescriptor.java
index c64326a2bf3..78c5a899d3c 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaCallableMemberDescriptor.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaCallableMemberDescriptor.java
@@ -19,16 +19,15 @@ package org.jetbrains.kotlin.load.java.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor;
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.List;
 
 public interface JavaCallableMemberDescriptor extends CallableMemberDescriptor {
     @NotNull
     JavaCallableMemberDescriptor enhance(
-            @Nullable JetType enhancedReceiverType,
-            @NotNull List<JetType> enhancedValueParametersTypes,
-            @NotNull JetType enhancedReturnType
+            @Nullable KtType enhancedReceiverType,
+            @NotNull List<KtType> enhancedValueParametersTypes,
+            @NotNull KtType enhancedReturnType
     );
 }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaClassDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaClassDescriptor.java
index 47906d20c2a..5b184f2790d 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaClassDescriptor.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaClassDescriptor.java
@@ -18,9 +18,9 @@ package org.jetbrains.kotlin.load.java.descriptors;
 
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public interface JavaClassDescriptor extends ClassDescriptor {
     @Nullable
-    JetType getFunctionTypeForSamInterface();
+    KtType getFunctionTypeForSamInterface();
 }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaConstructorDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaConstructorDescriptor.java
index 5459b1a9849..4670d4533b2 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaConstructorDescriptor.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaConstructorDescriptor.java
@@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.ConstructorDescriptorImpl;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.List;
 
@@ -96,9 +96,9 @@ public class JavaConstructorDescriptor extends ConstructorDescriptorImpl impleme
     @Override
     @NotNull
     public JavaConstructorDescriptor enhance(
-            @Nullable JetType enhancedReceiverType,
-            @NotNull List<JetType> enhancedValueParametersTypes,
-            @NotNull JetType enhancedReturnType
+            @Nullable KtType enhancedReceiverType,
+            @NotNull List<KtType> enhancedValueParametersTypes,
+            @NotNull KtType enhancedReturnType
     ) {
         JavaConstructorDescriptor enhanced = createSubstitutedCopy(getContainingDeclaration(), getOriginal(), getKind());
         // We do not use doSubstitute here as in JavaMethodDescriptor.enhance because type parameters of constructor belongs to class
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java
index 27df08bcc14..2470ad67c22 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 import org.jetbrains.kotlin.util.OperatorChecks;
 
@@ -77,11 +77,11 @@ public class JavaMethodDescriptor extends SimpleFunctionDescriptorImpl implement
     @NotNull
     @Override
     public SimpleFunctionDescriptorImpl initialize(
-            @Nullable JetType receiverParameterType,
+            @Nullable KtType receiverParameterType,
             @Nullable ReceiverParameterDescriptor dispatchReceiverParameter,
             @NotNull List<? extends TypeParameterDescriptor> typeParameters,
             @NotNull List<ValueParameterDescriptor> unsubstitutedValueParameters,
-            @Nullable JetType unsubstitutedReturnType,
+            @Nullable KtType unsubstitutedReturnType,
             @Nullable Modality modality,
             @NotNull Visibility visibility
     ) {
@@ -130,9 +130,9 @@ public class JavaMethodDescriptor extends SimpleFunctionDescriptorImpl implement
     @Override
     @NotNull
     public JavaMethodDescriptor enhance(
-            @Nullable JetType enhancedReceiverType,
-            @NotNull List<JetType> enhancedValueParametersTypes,
-            @NotNull JetType enhancedReturnType
+            @Nullable KtType enhancedReceiverType,
+            @NotNull List<KtType> enhancedValueParametersTypes,
+            @NotNull KtType enhancedReturnType
     ) {
         List<ValueParameterDescriptor> enhancedValueParameters =
                 UtilKt.copyValueParameters(enhancedValueParametersTypes, getValueParameters(), this);
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java
index eed0428eb07..a47a4bf42b6 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.PropertyGetterDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.PropertySetterDescriptorImpl;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.List;
 
@@ -55,9 +55,9 @@ public class JavaPropertyDescriptor extends PropertyDescriptorImpl implements Ja
     @NotNull
     @Override
     public JavaCallableMemberDescriptor enhance(
-            @Nullable JetType enhancedReceiverType,
-            @NotNull List<JetType> enhancedValueParametersTypes,
-            @NotNull JetType enhancedReturnType
+            @Nullable KtType enhancedReceiverType,
+            @NotNull List<KtType> enhancedValueParametersTypes,
+            @NotNull KtType enhancedReturnType
     ) {
         JavaPropertyDescriptor enhanced = new JavaPropertyDescriptor(
                 getContainingDeclaration(),
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt
index 35428f2dae7..a213d2bea94 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt
@@ -29,10 +29,10 @@ import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.NameResolver
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 fun copyValueParameters(
-        newValueParametersTypes: Collection<JetType>,
+        newValueParametersTypes: Collection<KtType>,
         oldValueParameters: Collection<ValueParameterDescriptor>,
         newOwner: CallableDescriptor
 ): List<ValueParameterDescriptor> {
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt
index fc8a167f718..ccc856d119a 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt
@@ -65,7 +65,7 @@ class LazyJavaAnnotationDescriptor(
 
     private val factory = ConstantValueFactory(c.module.builtIns)
 
-    override fun getType(): JetType = type()
+    override fun getType(): KtType = type()
 
     private val allValueArguments = c.storageManager.createLazyValue {
         computeValueArguments()
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt
index 3b568f71e91..ffb22516462 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.isValidJavaFqName
 import org.jetbrains.kotlin.resolve.constants.StringValue
 import org.jetbrains.kotlin.resolve.scopes.InnerClassesScopeWrapper
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.toReadOnlyList
@@ -82,10 +82,10 @@ class LazyJavaClassDescriptor(
     override fun getUnsubstitutedMemberScope() = unsubstitutedMemberScope
 
     private val innerClassesScope = InnerClassesScopeWrapper(getUnsubstitutedMemberScope())
-    override fun getUnsubstitutedInnerClassesScope(): JetScope = innerClassesScope
+    override fun getUnsubstitutedInnerClassesScope(): KtScope = innerClassesScope
 
     private val staticScope = LazyJavaStaticClassScope(c, jClass, this)
-    override fun getStaticScope(): JetScope = staticScope
+    override fun getStaticScope(): KtScope = staticScope
 
     override fun getUnsubstitutedPrimaryConstructor(): ConstructorDescriptor? = null
 
@@ -102,7 +102,7 @@ class LazyJavaClassDescriptor(
         }
     }
 
-    override fun getFunctionTypeForSamInterface(): JetType? = functionTypeForSamInterface()
+    override fun getFunctionTypeForSamInterface(): KtType? = functionTypeForSamInterface()
 
     override fun isCompanionObject() = false
 
@@ -120,12 +120,12 @@ class LazyJavaClassDescriptor(
 
         override fun getParameters(): List<TypeParameterDescriptor> = parameters()
 
-        private val supertypes = c.storageManager.createLazyValue<Collection<JetType>> {
+        private val supertypes = c.storageManager.createLazyValue<Collection<KtType>> {
             val javaTypes = jClass.getSupertypes()
-            val result = ArrayList<JetType>(javaTypes.size())
+            val result = ArrayList<KtType>(javaTypes.size())
             val incomplete = ArrayList<JavaType>(0)
 
-            val purelyImplementedSupertype: JetType? = getPurelyImplementedSupertype()
+            val purelyImplementedSupertype: KtType? = getPurelyImplementedSupertype()
 
             for (javaType in javaTypes) {
                 val jetType = c.typeResolver.transformJavaType(javaType, TypeUsage.SUPERTYPE.toAttributes())
@@ -154,7 +154,7 @@ class LazyJavaClassDescriptor(
             if (result.isNotEmpty()) result.toReadOnlyList() else listOf(c.module.builtIns.getAnyType())
         }
 
-        private fun getPurelyImplementedSupertype(): JetType? {
+        private fun getPurelyImplementedSupertype(): KtType? {
             val purelyImplementedFqName = getPurelyImplementsFqNameFromAnnotation()
                                           ?: FakePureImplementationsProvider.getPurelyImplementedInterface(fqName)
                                           ?: return null
@@ -169,7 +169,7 @@ class LazyJavaClassDescriptor(
                 parameter -> TypeProjectionImpl(Variance.INVARIANT, parameter.getDefaultType())
             }
 
-            return JetTypeImpl.create(
+            return KtTypeImpl.create(
                     Annotations.EMPTY, classDescriptor,
                     /* nullable =*/ false, parametersAsTypeProjections
             )
@@ -186,7 +186,7 @@ class LazyJavaClassDescriptor(
             return FqName(fqNameString)
         }
 
-        override fun getSupertypes(): Collection<JetType> = supertypes()
+        override fun getSupertypes(): Collection<KtType> = supertypes()
 
         override fun getAnnotations() = Annotations.EMPTY
 
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt
index 02892557b25..0edc6566d61 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt
@@ -52,9 +52,9 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.OverridingUtil
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.utils.*
 import org.jetbrains.kotlin.utils.addToStdlib.check
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
@@ -165,7 +165,7 @@ public class LazyJavaClassMemberScope(
             val descriptor = resolveMethodToFunctionDescriptor(javaMethod)
             if (descriptor.valueParameters.size != 0) return@factory null
 
-            descriptor.check { JetTypeChecker.DEFAULT.isSubtypeOf(descriptor.returnType ?: return@check false, type) }
+            descriptor.check { KotlinTypeChecker.DEFAULT.isSubtypeOf(descriptor.returnType ?: return@check false, type) }
         }
     }
 
@@ -176,7 +176,7 @@ public class LazyJavaClassMemberScope(
             if (descriptor.valueParameters.size != 1) return@factory null
 
             if (!KotlinBuiltIns.isUnit(descriptor.returnType ?: return@factory null)) return@factory null
-            descriptor.check { JetTypeChecker.DEFAULT.equalTypes(descriptor.valueParameters.single().type, type) }
+            descriptor.check { KotlinTypeChecker.DEFAULT.equalTypes(descriptor.valueParameters.single().type, type) }
         }
     }
 
@@ -263,7 +263,7 @@ public class LazyJavaClassMemberScope(
     }
 
     private fun createPropertyDescriptorWithDefaultGetter(
-            method: JavaMethod, givenType: JetType? = null, modality: Modality
+            method: JavaMethod, givenType: KtType? = null, modality: Modality
     ): JavaPropertyDescriptor {
         val annotations = c.resolveAnnotations(method)
 
@@ -277,7 +277,7 @@ public class LazyJavaClassMemberScope(
         propertyDescriptor.initialize(getter, null)
 
         val returnType = givenType ?: computeMethodReturnType(method, annotations, c.child(propertyDescriptor, method))
-        propertyDescriptor.setType(returnType, listOf(), getDispatchReceiverParameter(), null as JetType?)
+        propertyDescriptor.setType(returnType, listOf(), getDispatchReceiverParameter(), null as KtType?)
         getter.initialize(returnType)
 
         return propertyDescriptor
@@ -302,7 +302,7 @@ public class LazyJavaClassMemberScope(
                 /* isStaticFinal = */ false
         )
 
-        propertyDescriptor.setType(getterMethod.returnType!!, listOf(), getDispatchReceiverParameter(), null as JetType?)
+        propertyDescriptor.setType(getterMethod.returnType!!, listOf(), getDispatchReceiverParameter(), null as KtType?)
 
         val getter = DescriptorFactory.createGetter(
                 propertyDescriptor, getterMethod.annotations, /* isDefault = */false,
@@ -326,7 +326,7 @@ public class LazyJavaClassMemberScope(
     }
 
     override fun resolveMethodSignature(
-            method: JavaMethod, methodTypeParameters: List<TypeParameterDescriptor>, returnType: JetType,
+            method: JavaMethod, methodTypeParameters: List<TypeParameterDescriptor>, returnType: KtType,
             valueParameters: LazyJavaScope.ResolvedValueParameters
     ): LazyJavaScope.MethodSignatureData {
         val propagated = c.components.externalSignatureResolver.resolvePropagatedSignature(
@@ -406,12 +406,12 @@ public class LazyJavaClassMemberScope(
             val currentType = valueParameters[index].type
             val overriddenCandidate = RawSubstitution.eraseType(
                     builtinWithErasedParameters.original.valueParameters[index].type)
-            JetTypeChecker.DEFAULT.equalTypes(currentType, overriddenCandidate)
+            KotlinTypeChecker.DEFAULT.equalTypes(currentType, overriddenCandidate)
         } && returnType.isSubtypeOf(builtinWithErasedParameters.returnType)
     }
 
-    private fun JetType?.isSubtypeOf(other: JetType?): Boolean {
-        return JetTypeChecker.DEFAULT.isSubtypeOf(this ?: return false, other ?: return false)
+    private fun KtType?.isSubtypeOf(other: KtType?): Boolean {
+        return KotlinTypeChecker.DEFAULT.isSubtypeOf(this ?: return false, other ?: return false)
     }
 
     private fun resolveConstructor(constructor: JavaConstructor): JavaConstructorDescriptor {
@@ -510,8 +510,8 @@ public class LazyJavaClassMemberScope(
             constructor: ConstructorDescriptor,
             index: Int,
             method: JavaMethod,
-            returnType: JetType,
-            varargElementType: JetType?
+            returnType: KtType,
+            varargElementType: KtType?
     ) {
         add(ValueParameterDescriptorImpl(
                 constructor,
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageScope.kt
index 5d05543774e..e7a29126428 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageScope.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageScope.kt
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.SpecialNames
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.utils.addIfNotNull
 
 public class LazyJavaPackageScope(
@@ -75,7 +75,7 @@ public class LazyJavaPackageScope(
                 c.components.deserializedDescriptorResolver.readData(binaryClass, DeserializedDescriptorResolver.KOTLIN_PACKAGE_FACADE)
             }
 
-            JetScope.Empty
+            KtScope.Empty
         }
         else {
             c.components.deserializedDescriptorResolver.createKotlinPackageScope(packageFragment, containingDeclaration.kotlinBinaryClasses)
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt
index a86b62ef756..9da1ea2ef42 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt
@@ -40,10 +40,10 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.jvm.PLATFORM_TYPES
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindExclude.NonExtensions
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
+import org.jetbrains.kotlin.resolve.scopes.KtScope
+import org.jetbrains.kotlin.resolve.scopes.KtScopeImpl
 import org.jetbrains.kotlin.storage.NotNullLazyValue
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.addIfNotNull
@@ -53,11 +53,11 @@ import java.util.*
 public abstract class LazyJavaScope(
         protected val c: LazyJavaResolverContext,
         private val containingDeclaration: DeclarationDescriptor
-) : JetScopeImpl() {
+) : KtScopeImpl() {
     // this lazy value is not used at all in LazyPackageFragmentScopeForJavaPackage because we do not use caching there
     // but is placed in the base class to not duplicate code
     private val allDescriptors = c.storageManager.createRecursionTolerantLazyValue<Collection<DeclarationDescriptor>>(
-            { computeDescriptors(DescriptorKindFilter.ALL, JetScope.ALL_NAME_FILTER, NoLookupLocation.WHEN_GET_ALL_DESCRIPTORS) },
+            { computeDescriptors(DescriptorKindFilter.ALL, KtScope.ALL_NAME_FILTER, NoLookupLocation.WHEN_GET_ALL_DESCRIPTORS) },
             // This is to avoid the following recursive case:
             //    when computing getAllPackageNames() we ask the JavaPsiFacade for all subpackages of foo
             //    it, in turn, asks JavaElementFinder for subpackages of Kotlin package foo, which calls getAllPackageNames() recursively
@@ -106,7 +106,7 @@ public abstract class LazyJavaScope(
     protected abstract fun resolveMethodSignature(
             method: JavaMethod,
             methodTypeParameters: List<TypeParameterDescriptor>,
-            returnType: JetType,
+            returnType: KtType,
             valueParameters: ResolvedValueParameters): MethodSignatureData
 
     open fun resolveMethodToFunctionDescriptor(method: JavaMethod): JavaMethodDescriptor {
@@ -147,7 +147,7 @@ public abstract class LazyJavaScope(
         return functionDescriptorImpl
     }
 
-    protected fun computeMethodReturnType(method: JavaMethod, annotations: Annotations, c: LazyJavaResolverContext): JetType {
+    protected fun computeMethodReturnType(method: JavaMethod, annotations: Annotations, c: LazyJavaResolverContext): KtType {
         val annotationMethod = method.getContainingClass().isAnnotationType()
         val returnTypeAttrs = LazyJavaTypeAttributes(
                 TypeUsage.MEMBER_SIGNATURE_COVARIANT, annotations,
@@ -255,7 +255,7 @@ public abstract class LazyJavaScope(
             c.components.externalSignatureResolver.reportSignatureErrors(propertyDescriptor, signatureErrors)
         }
 
-        propertyDescriptor.setType(effectiveSignature.getReturnType(), listOf(), getDispatchReceiverParameter(), null as JetType?)
+        propertyDescriptor.setType(effectiveSignature.getReturnType(), listOf(), getDispatchReceiverParameter(), null as KtType?)
 
         if (DescriptorUtils.shouldRecordInitializerForProperty(propertyDescriptor, propertyDescriptor.getType())) {
             propertyDescriptor.setCompileTimeInitializer(
@@ -282,7 +282,7 @@ public abstract class LazyJavaScope(
     private val JavaField.isFinalStatic: Boolean
         get() = isFinal && isStatic
 
-    private fun getPropertyType(field: JavaField, annotations: Annotations): JetType {
+    private fun getPropertyType(field: JavaField, annotations: Annotations): KtType {
         // Fields do not have their own generic parameters
         val finalStatic = field.isFinalStatic
         // simple static constants should not have flexible types:
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticClassScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticClassScope.kt
index 286b2ead9e8..a58cbaa8c1e 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticClassScope.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticClassScope.kt
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.resolve.DescriptorFactory.createEnumValuesMethod
 import org.jetbrains.kotlin.resolve.DescriptorFactory.createEnumValuesProperty
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.addIfNotNull
 
 public class LazyJavaStaticClassScope(
@@ -117,7 +117,7 @@ public class LazyJavaStaticClassScope(
 
     private fun getStaticPropertiesFromJavaSupertypes(name: Name, descriptor: ClassDescriptor): Set<PropertyDescriptor> {
 
-        fun getStaticProperties(supertype: JetType): Iterable<PropertyDescriptor> {
+        fun getStaticProperties(supertype: KtType): Iterable<PropertyDescriptor> {
             val superTypeDescriptor = supertype.constructor.declarationDescriptor as? ClassDescriptor ?: return emptyList()
 
             val staticScope = superTypeDescriptor.staticScope
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticScope.kt
index 99a45a23937..046994b490d 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticScope.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticScope.kt
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext
 import org.jetbrains.kotlin.load.java.structure.JavaMethod
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 public abstract class LazyJavaStaticScope(
         c: LazyJavaResolverContext,
@@ -40,7 +40,7 @@ public abstract class LazyJavaStaticScope(
     override fun getImplicitReceiversHierarchy(): List<ReceiverParameterDescriptor> = listOf()
 
     override fun resolveMethodSignature(
-            method: JavaMethod, methodTypeParameters: List<TypeParameterDescriptor>, returnType: JetType,
+            method: JavaMethod, methodTypeParameters: List<TypeParameterDescriptor>, returnType: KtType,
             valueParameters: LazyJavaScope.ResolvedValueParameters
     ): LazyJavaScope.MethodSignatureData {
         val effectiveSignature = c.components.externalSignatureResolver.resolveAlternativeMethodSignature(
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaTypeParameterDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaTypeParameterDescriptor.kt
index 816a7b3a78b..afd198e7a5a 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaTypeParameterDescriptor.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaTypeParameterDescriptor.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.load.java.lazy.descriptors
 import org.jetbrains.kotlin.descriptors.impl.AbstractLazyTypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.types.Variance
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
@@ -45,7 +45,7 @@ class LazyJavaTypeParameterDescriptor(
         SourceElement.NO_SOURCE
 ) {
 
-    override fun resolveUpperBounds(): Set<JetType> {
+    override fun resolveUpperBounds(): Set<KtType> {
         val bounds = javaTypeParameter.getUpperBounds()
         if (bounds.isEmpty()) {
             return setOf(LazyJavaTypeResolver.FlexibleJavaClassifierTypeCapabilities.create(
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt
index 66338ce7320..810837cd575 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt
@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.Variance.INVARIANT
 import org.jetbrains.kotlin.types.Variance.IN_VARIANCE
 import org.jetbrains.kotlin.types.Variance.OUT_VARIANCE
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.typeUtil.createProjection
 import org.jetbrains.kotlin.types.typeUtil.replaceAnnotations
 import org.jetbrains.kotlin.utils.sure
@@ -52,7 +52,7 @@ class LazyJavaTypeResolver(
         private val typeParameterResolver: TypeParameterResolver
 ) {
 
-    public fun transformJavaType(javaType: JavaType, attr: JavaTypeAttributes): JetType {
+    public fun transformJavaType(javaType: JavaType, attr: JavaTypeAttributes): KtType {
         return when (javaType) {
             is JavaPrimitiveType -> {
                 val primitiveType = javaType.getType()
@@ -71,7 +71,7 @@ class LazyJavaTypeResolver(
         }
     }
 
-    public fun transformArrayType(arrayType: JavaArrayType, attr: JavaTypeAttributes, isVararg: Boolean = false): JetType {
+    public fun transformArrayType(arrayType: JavaArrayType, attr: JavaTypeAttributes, isVararg: Boolean = false): KtType {
         return run {
             val javaComponentType = arrayType.getComponentType()
             val primitiveType = (javaComponentType as? JavaPrimitiveType)?.getType()
@@ -169,17 +169,17 @@ class LazyJavaTypeResolver(
 
         // We do not memoize the results of this method, because it would consume much memory, and the real gain is little:
         // the case this method accounts for is very rare, not point in optimizing it
-        private fun getConstructorTypeParameterSubstitute(): JetType {
+        private fun getConstructorTypeParameterSubstitute(): KtType {
             // If a Java-constructor declares its own type parameters, we have no way of directly expressing them in Kotlin,
             // so we replace them by intersections of their upper bounds
-            val supertypesJet = HashSet<JetType>()
+            val supertypesJet = HashSet<KtType>()
             for (supertype in (classifier() as JavaTypeParameter).getUpperBounds()) {
                 supertypesJet.add(transformJavaType(supertype, UPPER_BOUND.toAttributes()))
             }
             if (supertypesJet.isEmpty()) {
                 return c.module.builtIns.nullableAnyType
             }
-            return TypeIntersector.intersectTypes(JetTypeChecker.DEFAULT, supertypesJet)
+            return TypeIntersector.intersectTypes(KotlinTypeChecker.DEFAULT, supertypesJet)
                         ?: ErrorUtils.createErrorType("Can't intersect upper bounds of " + javaType.getPresentableText())
         }
 
@@ -290,11 +290,11 @@ class LazyJavaTypeResolver(
 
     public object FlexibleJavaClassifierTypeCapabilities : FlexibleTypeCapabilities {
         @JvmStatic
-        fun create(lowerBound: JetType, upperBound: JetType) = DelegatingFlexibleType.create(lowerBound, upperBound, this)
+        fun create(lowerBound: KtType, upperBound: KtType) = DelegatingFlexibleType.create(lowerBound, upperBound, this)
 
         override val id: String get() = "kotlin.jvm.PlatformType"
 
-        override fun <T : TypeCapability> getCapability(capabilityClass: Class<T>, jetType: JetType, flexibility: Flexibility): T? {
+        override fun <T : TypeCapability> getCapability(capabilityClass: Class<T>, jetType: KtType, flexibility: Flexibility): T? {
             @Suppress("UNCHECKED_CAST")
             return when (capabilityClass) {
                 javaClass<CustomTypeVariable>(), javaClass<Specificity>() -> Impl(flexibility) as T
@@ -305,8 +305,8 @@ class LazyJavaTypeResolver(
 
         private class Impl(val flexibility: Flexibility) : CustomTypeVariable, Specificity {
 
-            private val lowerBound: JetType get() = flexibility.lowerBound
-            private val upperBound: JetType get() = flexibility.upperBound
+            private val lowerBound: KtType get() = flexibility.lowerBound
+            private val upperBound: KtType get() = flexibility.upperBound
 
             override val isTypeVariable: Boolean = lowerBound.getConstructor() == upperBound.getConstructor()
                                                    && lowerBound.getConstructor().getDeclarationDescriptor() is TypeParameterDescriptor
@@ -314,12 +314,12 @@ class LazyJavaTypeResolver(
             override val typeParameterDescriptor: TypeParameterDescriptor? =
                     if (isTypeVariable) lowerBound.getConstructor().getDeclarationDescriptor() as TypeParameterDescriptor else null
 
-            override fun substitutionResult(replacement: JetType): JetType {
+            override fun substitutionResult(replacement: KtType): KtType {
                 return if (replacement.isFlexible()) replacement
                        else create(replacement, TypeUtils.makeNullable(replacement))
             }
 
-            override fun getSpecificityRelationTo(otherType: JetType): Specificity.Relation {
+            override fun getSpecificityRelationTo(otherType: KtType): Specificity.Relation {
                 // For primitive types we have to take care of the case when there are two overloaded methods like
                 //    foo(int) and foo(Integer)
                 // if we do not discriminate one of them, any call to foo(kotlin.Int) will result in overload resolution ambiguity
@@ -425,8 +425,8 @@ internal fun TypeParameterDescriptor.getErasedUpperBound(
         // E.g. `class A<T extends A, F extends A>`
         // To prevent recursive calls return defaultValue() instead
         potentiallyRecursiveTypeParameter: TypeParameterDescriptor? = null,
-        defaultValue: (() -> JetType) = { ErrorUtils.createErrorType("Can't compute erased upper bound of type parameter `$this`") }
-): JetType {
+        defaultValue: (() -> KtType) = { ErrorUtils.createErrorType("Can't compute erased upper bound of type parameter `$this`") }
+): KtType {
     if (this === potentiallyRecursiveTypeParameter) return defaultValue()
 
     val firstUpperBound = upperBounds.first()
@@ -450,7 +450,7 @@ internal fun TypeParameterDescriptor.getErasedUpperBound(
     return defaultValue()
 }
 
-private fun JetType.replaceArgumentsWithStarProjections(): JetType {
+private fun KtType.replaceArgumentsWithStarProjections(): KtType {
     if (constructor.parameters.isEmpty() || constructor.declarationDescriptor == null) return this
 
     // We could just create JetTypeImpl with current type constructor and star projections,
@@ -459,7 +459,7 @@ private fun JetType.replaceArgumentsWithStarProjections(): JetType {
 }
 
 private object ConstantStarSubstitution : TypeSubstitution() {
-    override fun get(key: JetType): TypeProjection? {
+    override fun get(key: KtType): TypeProjection? {
         // Let substitutor deal with flexibility
         if (key.isFlexible()) return null
 
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/RawType.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/RawType.kt
index f305bad0841..d91b8322e5b 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/RawType.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/RawType.kt
@@ -32,14 +32,14 @@ public object RawTypeCapabilities : TypeCapabilities {
     }
 
     private object RawFlexibleRendering : CustomFlexibleRendering {
-        private fun DescriptorRenderer.renderArguments(jetType: JetType) = jetType.arguments.map { renderTypeProjection(it) }
+        private fun DescriptorRenderer.renderArguments(jetType: KtType) = jetType.arguments.map { renderTypeProjection(it) }
 
         private fun String.replaceArgs(newArgs: String): String {
             if (!contains('<')) return this
             return "${substringBefore('<')}<$newArgs>${substringAfterLast('>')}"
         }
 
-        override fun renderInflexible(type: JetType, renderer: DescriptorRenderer): String? {
+        override fun renderInflexible(type: KtType, renderer: DescriptorRenderer): String? {
             if (type.arguments.isNotEmpty()) return null
 
             return StringBuilder {
@@ -81,12 +81,12 @@ public object RawTypeCapabilities : TypeCapabilities {
 }
 
 internal object RawSubstitution : TypeSubstitution() {
-    override fun get(key: JetType) = TypeProjectionImpl(eraseType(key))
+    override fun get(key: KtType) = TypeProjectionImpl(eraseType(key))
 
     private val lowerTypeAttr = TypeUsage.MEMBER_SIGNATURE_INVARIANT.toAttributes().toFlexible(JavaTypeFlexibility.FLEXIBLE_LOWER_BOUND)
     private val upperTypeAttr = TypeUsage.MEMBER_SIGNATURE_INVARIANT.toAttributes().toFlexible(JavaTypeFlexibility.FLEXIBLE_UPPER_BOUND)
 
-    public fun eraseType(type: JetType): JetType {
+    public fun eraseType(type: KtType): KtType {
         val declaration = type.constructor.declarationDescriptor
         return when (declaration) {
             is TypeParameterDescriptor -> eraseType(declaration.getErasedUpperBound())
@@ -102,20 +102,20 @@ internal object RawSubstitution : TypeSubstitution() {
         }
     }
 
-    private fun eraseInflexibleBasedOnClassDescriptor(type: JetType, declaration: ClassDescriptor, attr: JavaTypeAttributes): JetType {
+    private fun eraseInflexibleBasedOnClassDescriptor(type: KtType, declaration: ClassDescriptor, attr: JavaTypeAttributes): KtType {
         if (KotlinBuiltIns.isArray(type)) {
             val componentTypeProjection = type.arguments[0]
             val arguments = listOf(
                     TypeProjectionImpl(componentTypeProjection.projectionKind, eraseType(componentTypeProjection.type))
             )
-            return JetTypeImpl.create(
+            return KtTypeImpl.create(
                     type.annotations, type.constructor, type.isMarkedNullable, arguments,
                     (type.constructor.declarationDescriptor as ClassDescriptor).getMemberScope(arguments)
             )
         }
 
         val constructor = type.constructor
-        return JetTypeImpl.create(
+        return KtTypeImpl.create(
                 type.annotations, constructor, type.isMarkedNullable,
                 type.constructor.parameters.map {
                     parameter ->
@@ -130,7 +130,7 @@ internal object RawSubstitution : TypeSubstitution() {
     fun computeProjection(
             parameter: TypeParameterDescriptor,
             attr: JavaTypeAttributes,
-            erasedUpperBound: JetType = parameter.getErasedUpperBound()
+            erasedUpperBound: KtType = parameter.getErasedUpperBound()
     ) = when (attr.flexibility) {
         // Raw(List<T>) => (List<Any?>..List<*>)
         // Raw(Enum<T>) => (Enum<Enum<*>>..Enum<out Enum<*>>)
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/signatureEnhancement.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/signatureEnhancement.kt
index 54d66a2612d..0967064620e 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/signatureEnhancement.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/signatureEnhancement.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.load.java.typeEnhacement
 
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 public fun <D : CallableMemberDescriptor> enhanceSignatures(platformSignatures: Collection<D>): Collection<D> {
     return platformSignatures.map {
@@ -51,17 +51,17 @@ public fun <D : CallableMemberDescriptor> D.enhanceSignature(): D {
 }
 
 private class SignatureParts(
-    val fromOverride: JetType,
-    val fromOverridden: Collection<JetType>,
-    val isCovariant: Boolean
+        val fromOverride: KtType,
+        val fromOverridden: Collection<KtType>,
+        val isCovariant: Boolean
 ) {
-    fun enhance(): JetType {
+    fun enhance(): KtType {
         val qualifiers = fromOverride.computeIndexedQualifiersForOverride(this.fromOverridden, isCovariant)
         return fromOverride.enhance(qualifiers)
     }
 }
 
-private fun <D : CallableMemberDescriptor> D.parts(isCovariant: Boolean, collector: (D) -> JetType): SignatureParts {
+private fun <D : CallableMemberDescriptor> D.parts(isCovariant: Boolean, collector: (D) -> KtType): SignatureParts {
     return SignatureParts(
             collector(this),
             this.getOverriddenDescriptors().map {
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt
index f4a2f3ae679..4f6fec3ccb1 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt
@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.utils.toReadOnlyList
 // Example: for `A<B, C<D, E>>`, indices go as follows: `0 - A<...>, 1 - B, 2 - C<D, E>, 3 - D, 4 - E`,
 // which corresponds to the left-to-right breadth-first walk of the tree representation of the type.
 // For flexible types, both bounds are indexed in the same way: `(A<B>..C<D>)` gives `0 - (A<B>..C<D>), 1 - B and D`.
-fun JetType.enhance(qualifiers: (Int) -> JavaTypeQualifiers) = this.enhancePossiblyFlexible(qualifiers, 0).type
+fun KtType.enhance(qualifiers: (Int) -> JavaTypeQualifiers) = this.enhancePossiblyFlexible(qualifiers, 0).type
 
 
 private enum class TypeComponentPosition {
@@ -46,9 +46,9 @@ private enum class TypeComponentPosition {
     INFLEXIBLE
 }
 
-private data class Result(val type: JetType, val subtreeSize: Int)
+private data class Result(val type: KtType, val subtreeSize: Int)
 
-private fun JetType.enhancePossiblyFlexible(qualifiers: (Int) -> JavaTypeQualifiers, index: Int): Result {
+private fun KtType.enhancePossiblyFlexible(qualifiers: (Int) -> JavaTypeQualifiers, index: Int): Result {
     if (this.isError()) return Result(this, 1)
     return if (this.isFlexible()) {
         with(this.flexibility()) {
@@ -67,7 +67,7 @@ private fun JetType.enhancePossiblyFlexible(qualifiers: (Int) -> JavaTypeQualifi
     else this.enhanceInflexible(qualifiers, index, TypeComponentPosition.INFLEXIBLE)
 }
 
-private fun JetType.enhanceInflexible(qualifiers: (Int) -> JavaTypeQualifiers, index: Int, position: TypeComponentPosition): Result {
+private fun KtType.enhanceInflexible(qualifiers: (Int) -> JavaTypeQualifiers, index: Int, position: TypeComponentPosition): Result {
     val shouldEnhance = position.shouldEnhance()
     if (!shouldEnhance && getArguments().isEmpty()) return Result(this, 1)
 
@@ -104,7 +104,7 @@ private fun JetType.enhanceInflexible(qualifiers: (Int) -> JavaTypeQualifiers, i
         typeConstructor.parameters, enhancedArguments
     )
 
-    val enhancedType = JetTypeImpl.create(
+    val enhancedType = KtTypeImpl.create(
             newAnnotations,
             typeConstructor,
             enhancedNullability,
@@ -153,7 +153,7 @@ private fun ClassifierDescriptor.enhanceMutability(qualifiers: JavaTypeQualifier
     return this.noChange()
 }
 
-private fun JetType.getEnhancedNullability(qualifiers: JavaTypeQualifiers, position: TypeComponentPosition): EnhancementResult<Boolean> {
+private fun KtType.getEnhancedNullability(qualifiers: JavaTypeQualifiers, position: TypeComponentPosition): EnhancementResult<Boolean> {
     if (!position.shouldEnhance()) return this.isMarkedNullable().noChange()
 
     return when (qualifiers.nullability) {
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeQualifiers.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeQualifiers.kt
index 5c46b8e4d9f..1cda769252f 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeQualifiers.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeQualifiers.kt
@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.load.java.typeEnhacement.NullabilityQualifier.NOT_NU
 import org.jetbrains.kotlin.load.java.typeEnhacement.NullabilityQualifier.NULLABLE
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.KtType
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.flexibility
 import org.jetbrains.kotlin.types.isFlexible
 import java.util.ArrayList
@@ -65,7 +65,7 @@ class JavaTypeQualifiers(
     }
 }
 
-private fun JetType.extractQualifiers(): JavaTypeQualifiers {
+private fun KtType.extractQualifiers(): JavaTypeQualifiers {
     val (lower, upper) =
             if (this.isFlexible())
                 flexibility().let { Pair(it.lowerBound, it.upperBound) }
@@ -88,11 +88,11 @@ private fun Annotations.extractQualifiers(): JavaTypeQualifiers {
     )
 }
 
-fun JetType.computeIndexedQualifiersForOverride(fromSupertypes: Collection<JetType>, isCovariant: Boolean): (Int) -> JavaTypeQualifiers {
-    fun JetType.toIndexed(): List<JetType> {
-        val list = ArrayList<JetType>(1)
+fun KtType.computeIndexedQualifiersForOverride(fromSupertypes: Collection<KtType>, isCovariant: Boolean): (Int) -> JavaTypeQualifiers {
+    fun KtType.toIndexed(): List<KtType> {
+        val list = ArrayList<KtType>(1)
 
-        fun add(type: JetType) {
+        fun add(type: KtType) {
             list.add(type)
             for (arg in type.getArguments()) {
                 if (arg.isStarProjection()) {
@@ -116,7 +116,7 @@ fun JetType.computeIndexedQualifiersForOverride(fromSupertypes: Collection<JetTy
     // (outermost type), unless the type in the subclass is interchangeable with the all the types in superclasses:
     // e.g. we have (Mutable)List<String!>! in the subclass and { List<String!>, (Mutable)List<String>! } from superclasses
     // Note that `this` is flexible here, so it's equal to it's bounds
-    val onlyHeadTypeConstructor = isCovariant && fromSupertypes.any { !JetTypeChecker.DEFAULT.equalTypes(it, this) }
+    val onlyHeadTypeConstructor = isCovariant && fromSupertypes.any { !KotlinTypeChecker.DEFAULT.equalTypes(it, this) }
 
     val treeSize = if (onlyHeadTypeConstructor) 1 else indexedThisType.size()
     val computedResult = Array(treeSize) {
@@ -134,7 +134,7 @@ fun JetType.computeIndexedQualifiersForOverride(fromSupertypes: Collection<JetTy
     return { index -> computedResult.getOrElse(index) { JavaTypeQualifiers.NONE } }
 }
 
-private fun JetType.computeQualifiersForOverride(fromSupertypes: Collection<JetType>, isCovariant: Boolean): JavaTypeQualifiers {
+private fun KtType.computeQualifiersForOverride(fromSupertypes: Collection<KtType>, isCovariant: Boolean): JavaTypeQualifiers {
     val nullabilityFromSupertypes = fromSupertypes.map { it.extractQualifiers().nullability }.filterNotNull().toSet()
     val mutabilityFromSupertypes = fromSupertypes.map { it.extractQualifiers().mutability }.filterNotNull().toSet()
     val own = getAnnotations().extractQualifiers()
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt
index f7695f199f5..57960dd1991 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.propertyImplClassName
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.propertySignature
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
 import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.util.*
 
 public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C : Any, T : Any>(
@@ -170,7 +170,7 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
         return typeParameter.getExtension(JvmProtoBuf.typeParameterAnnotation).map { loadTypeAnnotation(it, nameResolver) }
     }
 
-    override fun loadPropertyConstant(container: ProtoContainer, proto: ProtoBuf.Property, expectedType: JetType): C? {
+    override fun loadPropertyConstant(container: ProtoContainer, proto: ProtoBuf.Property, expectedType: KtType): C? {
         val nameResolver = container.nameResolver
         val signature = getCallableSignature(proto, nameResolver, container.typeTable, AnnotatedCallableKind.PROPERTY) ?: return null
 
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BuiltInClassesAreSerializableOnJvm.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BuiltInClassesAreSerializableOnJvm.kt
index b5f55aa61e5..7dbac3083da 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BuiltInClassesAreSerializableOnJvm.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BuiltInClassesAreSerializableOnJvm.kt
@@ -27,11 +27,11 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.platform.JvmBuiltIns
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.serialization.deserialization.AdditionalSupertypes
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor
 import org.jetbrains.kotlin.types.DelegatingType
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.io.Serializable
 
 class BuiltInClassesAreSerializableOnJvm(
@@ -40,14 +40,14 @@ class BuiltInClassesAreSerializableOnJvm(
 
     private val mockSerializableType = createMockJavaIoSerializableType()
 
-    private fun createMockJavaIoSerializableType(): JetType {
+    private fun createMockJavaIoSerializableType(): KtType {
         val mockJavaIoPackageFragment = object : PackageFragmentDescriptorImpl(moduleDescriptor, FqName("java.io")) {
-            override fun getMemberScope() = JetScope.Empty
+            override fun getMemberScope() = KtScope.Empty
         }
 
         //NOTE: can't reference anyType right away, because this is sometimes called when JvmBuiltIns are initializing
         val superTypes = listOf(object : DelegatingType() {
-            override fun getDelegate(): JetType {
+            override fun getDelegate(): KtType {
                 return JvmBuiltIns.Instance.anyType
             }
         })
@@ -56,11 +56,11 @@ class BuiltInClassesAreSerializableOnJvm(
                 mockJavaIoPackageFragment, Name.identifier("Serializable"), Modality.ABSTRACT, superTypes, SourceElement.NO_SOURCE
         )
 
-        mockSerializableClass.initialize(JetScope.Empty, emptySet(), null)
+        mockSerializableClass.initialize(KtScope.Empty, emptySet(), null)
         return mockSerializableClass.defaultType
     }
 
-    override fun forClass(classDescriptor: DeserializedClassDescriptor): Collection<JetType> {
+    override fun forClass(classDescriptor: DeserializedClassDescriptor): Collection<KtType> {
         if (isSerializableInJava(classDescriptor.fqNameSafe)) {
             return listOf(mockSerializableType)
         }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java
index 868a4f6b2e9..a411909c803 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.scopes.ChainedScope;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.serialization.ClassData;
 import org.jetbrains.kotlin.serialization.ClassDataWithSource;
 import org.jetbrains.kotlin.serialization.PackageData;
@@ -74,7 +74,7 @@ public final class DeserializedDescriptorResolver {
     }
 
     @Nullable
-    public JetScope createKotlinPackagePartScope(@NotNull PackageFragmentDescriptor descriptor, @NotNull KotlinJvmBinaryClass kotlinClass) {
+    public KtScope createKotlinPackagePartScope(@NotNull PackageFragmentDescriptor descriptor, @NotNull KotlinJvmBinaryClass kotlinClass) {
         String[] data = readData(kotlinClass, KOTLIN_FILE_FACADE_OR_MULTIFILE_CLASS_PART);
         if (data != null) {
             String[] strings = kotlinClass.getClassHeader().getStrings();
@@ -95,18 +95,18 @@ public final class DeserializedDescriptorResolver {
     }
 
     @NotNull
-    public JetScope createKotlinPackageScope(@NotNull PackageFragmentDescriptor descriptor, @NotNull List<KotlinJvmBinaryClass> packageParts) {
-        List<JetScope> list = new ArrayList<JetScope>();
+    public KtScope createKotlinPackageScope(@NotNull PackageFragmentDescriptor descriptor, @NotNull List<KotlinJvmBinaryClass> packageParts) {
+        List<KtScope> list = new ArrayList<KtScope>();
         for (KotlinJvmBinaryClass callable : packageParts) {
-            JetScope scope = createKotlinPackagePartScope(descriptor, callable);
+            KtScope scope = createKotlinPackagePartScope(descriptor, callable);
             if (scope != null) {
                 list.add(scope);
             }
         }
         if (list.isEmpty()) {
-            return JetScope.Empty.INSTANCE$;
+            return KtScope.Empty.INSTANCE$;
         }
-        return new ChainedScope(descriptor, "Member scope for union of package parts data", list.toArray(new JetScope[list.size()]));
+        return new ChainedScope(descriptor, "Member scope for union of package parts data", list.toArray(new KtScope[list.size()]));
     }
 
     @Nullable
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.java
index f577885ab2c..7fbc13b6830 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.java
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.name.FqNameUnsafe;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 
 import java.lang.annotation.Annotation;
@@ -184,7 +184,7 @@ public class JavaToKotlinClassMap implements PlatformToKotlinClassMap {
         return mutableToReadOnly.containsKey(mutable);
     }
 
-    public boolean isMutable(@NotNull JetType type) {
+    public boolean isMutable(@NotNull KtType type) {
         ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(type);
         return classDescriptor != null && isMutable(classDescriptor);
     }
@@ -193,7 +193,7 @@ public class JavaToKotlinClassMap implements PlatformToKotlinClassMap {
         return readOnlyToMutable.containsKey(readOnly);
     }
 
-    public boolean isReadOnly(@NotNull JetType type) {
+    public boolean isReadOnly(@NotNull KtType type) {
         ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(type);
         return classDescriptor != null && isReadOnly(classDescriptor);
     }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/resolve/jvm/JavaDescriptorResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/resolve/jvm/JavaDescriptorResolver.kt
index e37bbf7ad6a..8b132578cad 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/resolve/jvm/JavaDescriptorResolver.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/resolve/jvm/JavaDescriptorResolver.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve.jvm
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.load.java.structure.*
 import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.load.java.sources.JavaSourceElement
 
 public var PLATFORM_TYPES: Boolean = true
diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt
index 2df05fe371f..9f30d7a149d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.*
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 class BuiltInsAnnotationAndConstantLoader(
         module: ModuleDescriptor
@@ -81,7 +81,7 @@ class BuiltInsAnnotationAndConstantLoader(
     override fun loadPropertyConstant(
             container: ProtoContainer,
             proto: ProtoBuf.Property,
-            expectedType: JetType
+            expectedType: KtType
     ): ConstantValue<*>? {
         if (!proto.hasExtension(BuiltInsProtoBuf.compileTimeValue)) return null
         val value = proto.getExtension(BuiltInsProtoBuf.compileTimeValue)
diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java
index e8d752dd918..b18f4e924df 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java
@@ -32,11 +32,11 @@ import org.jetbrains.kotlin.name.FqNameUnsafe;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.serialization.deserialization.AdditionalSupertypes;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.types.*;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.io.InputStream;
 import java.util.*;
@@ -61,9 +61,9 @@ public abstract class KotlinBuiltIns {
     private final BuiltinsPackageFragment builtinsPackageFragment;
     private final BuiltinsPackageFragment annotationPackageFragment;
 
-    private final Map<PrimitiveType, JetType> primitiveTypeToArrayJetType;
-    private final Map<JetType, JetType> primitiveJetTypeToJetArrayType;
-    private final Map<JetType, JetType> jetArrayTypeToPrimitiveJetType;
+    private final Map<PrimitiveType, KtType> primitiveTypeToArrayJetType;
+    private final Map<KtType, KtType> primitiveJetTypeToJetArrayType;
+    private final Map<KtType, KtType> jetArrayTypeToPrimitiveJetType;
 
     public static final FqNames FQ_NAMES = new FqNames();
 
@@ -91,9 +91,9 @@ public abstract class KotlinBuiltIns {
         builtinsPackageFragment = (BuiltinsPackageFragment) single(packageFragmentProvider.getPackageFragments(BUILT_INS_PACKAGE_FQ_NAME));
         annotationPackageFragment = (BuiltinsPackageFragment) single(packageFragmentProvider.getPackageFragments(ANNOTATION_PACKAGE_FQ_NAME));
 
-        primitiveTypeToArrayJetType = new EnumMap<PrimitiveType, JetType>(PrimitiveType.class);
-        primitiveJetTypeToJetArrayType = new HashMap<JetType, JetType>();
-        jetArrayTypeToPrimitiveJetType = new HashMap<JetType, JetType>();
+        primitiveTypeToArrayJetType = new EnumMap<PrimitiveType, KtType>(PrimitiveType.class);
+        primitiveJetTypeToJetArrayType = new HashMap<KtType, KtType>();
+        jetArrayTypeToPrimitiveJetType = new HashMap<KtType, KtType>();
         for (PrimitiveType primitive : PrimitiveType.values()) {
             makePrimitive(primitive);
         }
@@ -105,8 +105,8 @@ public abstract class KotlinBuiltIns {
     }
 
     private void makePrimitive(@NotNull PrimitiveType primitiveType) {
-        JetType type = getBuiltInTypeByClassName(primitiveType.getTypeName().asString());
-        JetType arrayType = getBuiltInTypeByClassName(primitiveType.getArrayTypeName().asString());
+        KtType type = getBuiltInTypeByClassName(primitiveType.getTypeName().asString());
+        KtType arrayType = getBuiltInTypeByClassName(primitiveType.getArrayTypeName().asString());
 
         primitiveTypeToArrayJetType.put(primitiveType, arrayType);
         primitiveJetTypeToJetArrayType.put(type, arrayType);
@@ -202,12 +202,12 @@ public abstract class KotlinBuiltIns {
     }
 
     @NotNull
-    public JetScope getBuiltInsPackageScope() {
+    public KtScope getBuiltInsPackageScope() {
         return builtinsPackageFragment.getMemberScope();
     }
 
     @NotNull
-    public JetScope getAnnotationPackageScope() {
+    public KtScope getAnnotationPackageScope() {
         return annotationPackageFragment.getMemberScope();
     }
 
@@ -540,100 +540,100 @@ public abstract class KotlinBuiltIns {
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     @NotNull
-    private JetType getBuiltInTypeByClassName(@NotNull String classSimpleName) {
+    private KtType getBuiltInTypeByClassName(@NotNull String classSimpleName) {
         return getBuiltInClassByName(classSimpleName).getDefaultType();
     }
 
     // Special
 
     @NotNull
-    public JetType getNothingType() {
+    public KtType getNothingType() {
         return getNothing().getDefaultType();
     }
 
     @NotNull
-    public JetType getNullableNothingType() {
+    public KtType getNullableNothingType() {
         return TypeUtils.makeNullable(getNothingType());
     }
 
     @NotNull
-    public JetType getAnyType() {
+    public KtType getAnyType() {
         return getAny().getDefaultType();
     }
 
     @NotNull
-    public JetType getNullableAnyType() {
+    public KtType getNullableAnyType() {
         return TypeUtils.makeNullable(getAnyType());
     }
 
     // Primitive
 
     @NotNull
-    public JetType getPrimitiveJetType(@NotNull PrimitiveType type) {
+    public KtType getPrimitiveJetType(@NotNull PrimitiveType type) {
         return getPrimitiveClassDescriptor(type).getDefaultType();
     }
 
     @NotNull
-    public JetType getByteType() {
+    public KtType getByteType() {
         return getPrimitiveJetType(BYTE);
     }
 
     @NotNull
-    public JetType getShortType() {
+    public KtType getShortType() {
         return getPrimitiveJetType(SHORT);
     }
 
     @NotNull
-    public JetType getIntType() {
+    public KtType getIntType() {
         return getPrimitiveJetType(INT);
     }
 
     @NotNull
-    public JetType getLongType() {
+    public KtType getLongType() {
         return getPrimitiveJetType(LONG);
     }
 
     @NotNull
-    public JetType getFloatType() {
+    public KtType getFloatType() {
         return getPrimitiveJetType(FLOAT);
     }
 
     @NotNull
-    public JetType getDoubleType() {
+    public KtType getDoubleType() {
         return getPrimitiveJetType(DOUBLE);
     }
 
     @NotNull
-    public JetType getCharType() {
+    public KtType getCharType() {
         return getPrimitiveJetType(CHAR);
     }
 
     @NotNull
-    public JetType getBooleanType() {
+    public KtType getBooleanType() {
         return getPrimitiveJetType(BOOLEAN);
     }
 
     // Recognized
 
     @NotNull
-    public JetType getUnitType() {
+    public KtType getUnitType() {
         return getUnit().getDefaultType();
     }
 
     @NotNull
-    public JetType getStringType() {
+    public KtType getStringType() {
         return getString().getDefaultType();
     }
 
     @NotNull
-    public JetType getArrayElementType(@NotNull JetType arrayType) {
+    public KtType getArrayElementType(@NotNull KtType arrayType) {
         if (isArray(arrayType)) {
             if (arrayType.getArguments().size() != 1) {
                 throw new IllegalStateException();
             }
             return arrayType.getArguments().get(0).getType();
         }
-        JetType primitiveType = jetArrayTypeToPrimitiveJetType.get(TypeUtils.makeNotNullable(arrayType));
+        KtType primitiveType = jetArrayTypeToPrimitiveJetType.get(TypeUtils.makeNotNullable(arrayType));
         if (primitiveType == null) {
             throw new IllegalStateException("not array: " + arrayType);
         }
@@ -641,7 +641,7 @@ public abstract class KotlinBuiltIns {
     }
 
     @NotNull
-    public JetType getPrimitiveArrayJetType(@NotNull PrimitiveType primitiveType) {
+    public KtType getPrimitiveArrayJetType(@NotNull PrimitiveType primitiveType) {
         return primitiveTypeToArrayJetType.get(primitiveType);
     }
 
@@ -649,7 +649,7 @@ public abstract class KotlinBuiltIns {
      * @return {@code null} if not primitive
      */
     @Nullable
-    public JetType getPrimitiveArrayJetTypeByPrimitiveJetType(@NotNull JetType jetType) {
+    public KtType getPrimitiveArrayJetTypeByPrimitiveJetType(@NotNull KtType jetType) {
         return primitiveJetTypeToJetArrayType.get(jetType);
     }
 
@@ -668,9 +668,9 @@ public abstract class KotlinBuiltIns {
     }
 
     @NotNull
-    public JetType getArrayType(@NotNull Variance projectionType, @NotNull JetType argument) {
+    public KtType getArrayType(@NotNull Variance projectionType, @NotNull KtType argument) {
         List<TypeProjectionImpl> types = Collections.singletonList(new TypeProjectionImpl(projectionType, argument));
-        return JetTypeImpl.create(
+        return KtTypeImpl.create(
                 Annotations.Companion.getEMPTY(),
                 getArray(),
                 false,
@@ -679,10 +679,10 @@ public abstract class KotlinBuiltIns {
     }
 
     @NotNull
-    public JetType getEnumType(@NotNull JetType argument) {
+    public KtType getEnumType(@NotNull KtType argument) {
         Variance projectionType = Variance.INVARIANT;
         List<TypeProjectionImpl> types = Collections.singletonList(new TypeProjectionImpl(projectionType, argument));
-        return JetTypeImpl.create(
+        return KtTypeImpl.create(
                 Annotations.Companion.getEMPTY(),
                 getEnum(),
                 false,
@@ -691,7 +691,7 @@ public abstract class KotlinBuiltIns {
     }
 
     @NotNull
-    public JetType getAnnotationType() {
+    public KtType getAnnotationType() {
         return getAnnotation().getDefaultType();
     }
 
@@ -701,16 +701,16 @@ public abstract class KotlinBuiltIns {
                                             Collections.<ValueParameterDescriptor, ConstantValue<?>>emptyMap(), SourceElement.NO_SOURCE);
     }
 
-    private static boolean isTypeAnnotatedWithExtension(@NotNull JetType type) {
+    private static boolean isTypeAnnotatedWithExtension(@NotNull KtType type) {
         return type.getAnnotations().findAnnotation(FQ_NAMES.extension) != null;
     }
 
     @NotNull
-    public JetType getFunctionType(
+    public KtType getFunctionType(
             @NotNull Annotations annotations,
-            @Nullable JetType receiverType,
-            @NotNull List<JetType> parameterTypes,
-            @NotNull JetType returnType
+            @Nullable KtType receiverType,
+            @NotNull List<KtType> parameterTypes,
+            @NotNull KtType returnType
     ) {
         List<TypeProjection> arguments = getFunctionTypeArgumentProjections(receiverType, parameterTypes, returnType);
         int size = parameterTypes.size();
@@ -718,7 +718,7 @@ public abstract class KotlinBuiltIns {
 
         Annotations typeAnnotations = receiverType == null ? annotations : addExtensionAnnotation(annotations);
 
-        return JetTypeImpl.create(typeAnnotations, classDescriptor, false, arguments);
+        return KtTypeImpl.create(typeAnnotations, classDescriptor, false, arguments);
     }
 
     @NotNull
@@ -731,22 +731,22 @@ public abstract class KotlinBuiltIns {
 
     @NotNull
     public static List<TypeProjection> getFunctionTypeArgumentProjections(
-            @Nullable JetType receiverType,
-            @NotNull List<JetType> parameterTypes,
-            @NotNull JetType returnType
+            @Nullable KtType receiverType,
+            @NotNull List<KtType> parameterTypes,
+            @NotNull KtType returnType
     ) {
         List<TypeProjection> arguments = new ArrayList<TypeProjection>(parameterTypes.size() + (receiverType != null ? 1 : 0) + 1);
         if (receiverType != null) {
             arguments.add(defaultProjection(receiverType));
         }
-        for (JetType parameterType : parameterTypes) {
+        for (KtType parameterType : parameterTypes) {
             arguments.add(defaultProjection(parameterType));
         }
         arguments.add(defaultProjection(returnType));
         return arguments;
     }
 
-    private static TypeProjection defaultProjection(JetType returnType) {
+    private static TypeProjection defaultProjection(KtType returnType) {
         return new TypeProjectionImpl(Variance.INVARIANT, returnType);
     }
 
@@ -756,16 +756,16 @@ public abstract class KotlinBuiltIns {
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-    public static boolean isArray(@NotNull JetType type) {
+    public static boolean isArray(@NotNull KtType type) {
         return isConstructedFromGivenClass(type, FQ_NAMES.array);
     }
 
-    public static boolean isPrimitiveArray(@NotNull JetType type) {
+    public static boolean isPrimitiveArray(@NotNull KtType type) {
         ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
         return descriptor != null && getPrimitiveTypeByArrayClassFqName(getFqName(descriptor)) != null;
     }
 
-    public static boolean isPrimitiveType(@NotNull JetType type) {
+    public static boolean isPrimitiveType(@NotNull KtType type) {
         ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
         return !type.isMarkedNullable() && descriptor instanceof ClassDescriptor && isPrimitiveClass((ClassDescriptor) descriptor);
     }
@@ -776,40 +776,40 @@ public abstract class KotlinBuiltIns {
 
     // Functions
 
-    public static boolean isFunctionOrExtensionFunctionType(@NotNull JetType type) {
+    public static boolean isFunctionOrExtensionFunctionType(@NotNull KtType type) {
         return isFunctionType(type) || isExtensionFunctionType(type);
     }
 
-    public static boolean isFunctionType(@NotNull JetType type) {
+    public static boolean isFunctionType(@NotNull KtType type) {
         if (isExactFunctionType(type)) return true;
 
-        for (JetType superType : type.getConstructor().getSupertypes()) {
+        for (KtType superType : type.getConstructor().getSupertypes()) {
             if (isFunctionType(superType)) return true;
         }
 
         return false;
     }
 
-    public static boolean isExtensionFunctionType(@NotNull JetType type) {
+    public static boolean isExtensionFunctionType(@NotNull KtType type) {
         if (isExactExtensionFunctionType(type)) return true;
 
-        for (JetType superType : type.getConstructor().getSupertypes()) {
+        for (KtType superType : type.getConstructor().getSupertypes()) {
             if (isExtensionFunctionType(superType)) return true;
         }
 
         return false;
     }
 
-    public static boolean isExactFunctionOrExtensionFunctionType(@NotNull JetType type) {
+    public static boolean isExactFunctionOrExtensionFunctionType(@NotNull KtType type) {
         ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
         return descriptor != null && isNumberedFunctionClassFqName(getFqName(descriptor));
     }
 
-    public static boolean isExactFunctionType(@NotNull JetType type) {
+    public static boolean isExactFunctionType(@NotNull KtType type) {
         return isExactFunctionOrExtensionFunctionType(type) && !isTypeAnnotatedWithExtension(type);
     }
 
-    public static boolean isExactExtensionFunctionType(@NotNull JetType type) {
+    public static boolean isExactExtensionFunctionType(@NotNull KtType type) {
         return isExactFunctionOrExtensionFunctionType(type) && isTypeAnnotatedWithExtension(type);
     }
 
@@ -828,7 +828,7 @@ public abstract class KotlinBuiltIns {
     }
 
     @Nullable
-    public static JetType getReceiverType(@NotNull JetType type) {
+    public static KtType getReceiverType(@NotNull KtType type) {
         assert isFunctionOrExtensionFunctionType(type) : type;
         if (isExtensionFunctionType(type)) {
             // TODO: this is incorrect when a class extends from an extension function and swaps type arguments
@@ -838,7 +838,7 @@ public abstract class KotlinBuiltIns {
     }
 
     @NotNull
-    public static List<ValueParameterDescriptor> getValueParameters(@NotNull FunctionDescriptor functionDescriptor, @NotNull JetType type) {
+    public static List<ValueParameterDescriptor> getValueParameters(@NotNull FunctionDescriptor functionDescriptor, @NotNull KtType type) {
         assert isFunctionOrExtensionFunctionType(type);
         List<TypeProjection> parameterTypes = getParameterTypeProjectionsFromFunctionType(type);
         List<ValueParameterDescriptor> valueParameters = new ArrayList<ValueParameterDescriptor>(parameterTypes.size());
@@ -858,14 +858,14 @@ public abstract class KotlinBuiltIns {
     }
 
     @NotNull
-    public static JetType getReturnTypeFromFunctionType(@NotNull JetType type) {
+    public static KtType getReturnTypeFromFunctionType(@NotNull KtType type) {
         assert isFunctionOrExtensionFunctionType(type);
         List<TypeProjection> arguments = type.getArguments();
         return arguments.get(arguments.size() - 1).getType();
     }
 
     @NotNull
-    public static List<TypeProjection> getParameterTypeProjectionsFromFunctionType(@NotNull JetType type) {
+    public static List<TypeProjection> getParameterTypeProjectionsFromFunctionType(@NotNull KtType type) {
         assert isFunctionOrExtensionFunctionType(type);
         List<TypeProjection> arguments = type.getArguments();
         int first = isExtensionFunctionType(type) ? 1 : 0;
@@ -879,14 +879,14 @@ public abstract class KotlinBuiltIns {
 
     // Recognized & special
 
-    private static boolean isConstructedFromGivenClass(@NotNull JetType type, @NotNull FqNameUnsafe fqName) {
+    private static boolean isConstructedFromGivenClass(@NotNull KtType type, @NotNull FqNameUnsafe fqName) {
         ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
         return descriptor != null &&
                /* quick check to avoid creation of full FqName instance */ descriptor.getName().equals(fqName.shortName()) &&
                fqName.equals(getFqName(descriptor));
     }
 
-    private static boolean isNotNullConstructedFromGivenClass(@NotNull JetType type, @NotNull FqNameUnsafe fqName) {
+    private static boolean isNotNullConstructedFromGivenClass(@NotNull KtType type, @NotNull FqNameUnsafe fqName) {
         return !type.isMarkedNullable() && isConstructedFromGivenClass(type, fqName);
     }
 
@@ -899,16 +899,16 @@ public abstract class KotlinBuiltIns {
         return isAny(getFqName(descriptor));
     }
 
-    public static boolean isAny(@NotNull JetType type) {
+    public static boolean isAny(@NotNull KtType type) {
         return isConstructedFromGivenClassAndNotNullable(type, FQ_NAMES.any);
     }
 
-    public static boolean isBoolean(@NotNull JetType type) {
+    public static boolean isBoolean(@NotNull KtType type) {
 
         return isConstructedFromGivenClassAndNotNullable(type, FQ_NAMES._boolean);
     }
 
-    public static boolean isBooleanOrNullableBoolean(@NotNull JetType type) {
+    public static boolean isBooleanOrNullableBoolean(@NotNull KtType type) {
         return isConstructedFromGivenClass(type, FQ_NAMES._boolean);
     }
 
@@ -916,35 +916,35 @@ public abstract class KotlinBuiltIns {
         return FQ_NAMES._boolean.equals(getFqName(classDescriptor));
     }
 
-    public static boolean isChar(@NotNull JetType type) {
+    public static boolean isChar(@NotNull KtType type) {
         return isConstructedFromGivenClassAndNotNullable(type, FQ_NAMES._char);
     }
 
-    public static boolean isInt(@NotNull JetType type) {
+    public static boolean isInt(@NotNull KtType type) {
         return isConstructedFromGivenClassAndNotNullable(type, FQ_NAMES._int);
     }
 
-    public static boolean isByte(@NotNull JetType type) {
+    public static boolean isByte(@NotNull KtType type) {
         return isConstructedFromGivenClassAndNotNullable(type, FQ_NAMES._byte);
     }
 
-    public static boolean isLong(@NotNull JetType type) {
+    public static boolean isLong(@NotNull KtType type) {
         return isConstructedFromGivenClassAndNotNullable(type, FQ_NAMES._long);
     }
 
-    public static boolean isShort(@NotNull JetType type) {
+    public static boolean isShort(@NotNull KtType type) {
         return isConstructedFromGivenClassAndNotNullable(type, FQ_NAMES._short);
     }
 
-    public static boolean isFloat(@NotNull JetType type) {
+    public static boolean isFloat(@NotNull KtType type) {
         return isConstructedFromGivenClassAndNotNullable(type, FQ_NAMES._float);
     }
 
-    public static boolean isDouble(@NotNull JetType type) {
+    public static boolean isDouble(@NotNull KtType type) {
         return isConstructedFromGivenClassAndNotNullable(type, FQ_NAMES._double);
     }
 
-    private static boolean isConstructedFromGivenClassAndNotNullable(@NotNull JetType type, @NotNull FqNameUnsafe fqName) {
+    private static boolean isConstructedFromGivenClassAndNotNullable(@NotNull KtType type, @NotNull FqNameUnsafe fqName) {
         return isConstructedFromGivenClass(type, fqName) && !type.isMarkedNullable();
     }
 
@@ -952,57 +952,57 @@ public abstract class KotlinBuiltIns {
         return FQ_NAMES.any.equals(fqName);
     }
 
-    public static boolean isNothing(@NotNull JetType type) {
+    public static boolean isNothing(@NotNull KtType type) {
         return isNothingOrNullableNothing(type)
                && !type.isMarkedNullable();
     }
 
-    public static boolean isNullableNothing(@NotNull JetType type) {
+    public static boolean isNullableNothing(@NotNull KtType type) {
         return isNothingOrNullableNothing(type)
                && type.isMarkedNullable();
     }
 
-    public static boolean isNothingOrNullableNothing(@NotNull JetType type) {
+    public static boolean isNothingOrNullableNothing(@NotNull KtType type) {
         return isConstructedFromGivenClass(type, FQ_NAMES.nothing);
     }
 
-    public static boolean isAnyOrNullableAny(@NotNull JetType type) {
+    public static boolean isAnyOrNullableAny(@NotNull KtType type) {
         return isConstructedFromGivenClass(type, FQ_NAMES.any);
     }
 
-    public static boolean isNullableAny(@NotNull JetType type) {
+    public static boolean isNullableAny(@NotNull KtType type) {
         return isAnyOrNullableAny(type) && type.isMarkedNullable();
     }
 
-    public static boolean isDefaultBound(@NotNull JetType type) {
+    public static boolean isDefaultBound(@NotNull KtType type) {
         return isNullableAny(type);
     }
 
-    public static boolean isUnit(@NotNull JetType type) {
+    public static boolean isUnit(@NotNull KtType type) {
         return isNotNullConstructedFromGivenClass(type, FQ_NAMES.unit);
     }
 
-    public boolean isBooleanOrSubtype(@NotNull JetType type) {
-        return JetTypeChecker.DEFAULT.isSubtypeOf(type, getBooleanType());
+    public boolean isBooleanOrSubtype(@NotNull KtType type) {
+        return KotlinTypeChecker.DEFAULT.isSubtypeOf(type, getBooleanType());
     }
 
-    public static boolean isString(@Nullable JetType type) {
+    public static boolean isString(@Nullable KtType type) {
         return type != null && isNotNullConstructedFromGivenClass(type, FQ_NAMES.string);
     }
 
-    public static boolean isCollectionOrNullableCollection(@NotNull JetType type) {
+    public static boolean isCollectionOrNullableCollection(@NotNull KtType type) {
         return isConstructedFromGivenClass(type, FQ_NAMES._collection);
     }
 
-    public static boolean isListOrNullableList(@NotNull JetType type) {
+    public static boolean isListOrNullableList(@NotNull KtType type) {
         return isConstructedFromGivenClass(type, FQ_NAMES._list);
     }
 
-    public static boolean isSetOrNullableSet(@NotNull JetType type) {
+    public static boolean isSetOrNullableSet(@NotNull KtType type) {
         return isConstructedFromGivenClass(type, FQ_NAMES._set);
     }
 
-    public static boolean isIterableOrNullableIterable(@NotNull JetType type) {
+    public static boolean isIterableOrNullableIterable(@NotNull KtType type) {
         return isConstructedFromGivenClass(type, FQ_NAMES._iterable);
     }
 
@@ -1045,7 +1045,7 @@ public abstract class KotlinBuiltIns {
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     @NotNull
-    public JetType getDefaultBound() {
+    public KtType getDefaultBound() {
         return getNullableAnyType();
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/ReflectionTypes.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/ReflectionTypes.kt
index f8928eab600..8d479148dac 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/builtins/ReflectionTypes.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/ReflectionTypes.kt
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.serialization.deserialization.findClassAcrossModuleDependencies
 import org.jetbrains.kotlin.types.*
 import java.util.*
@@ -32,7 +32,7 @@ import java.util.*
 val KOTLIN_REFLECT_FQ_NAME = FqName("kotlin.reflect")
 
 public class ReflectionTypes(private val module: ModuleDescriptor) {
-    private val kotlinReflectScope: JetScope by lazy {
+    private val kotlinReflectScope: KtScope by lazy {
         module.getPackage(KOTLIN_REFLECT_FQ_NAME).memberScope
     }
 
@@ -57,22 +57,22 @@ public class ReflectionTypes(private val module: ModuleDescriptor) {
     public val kMutableProperty0: ClassDescriptor by ClassLookup
     public val kMutableProperty1: ClassDescriptor by ClassLookup
 
-    public fun getKClassType(annotations: Annotations, type: JetType): JetType {
+    public fun getKClassType(annotations: Annotations, type: KtType): KtType {
         val descriptor = kClass
         if (ErrorUtils.isError(descriptor)) {
             return descriptor.defaultType
         }
 
         val arguments = listOf(TypeProjectionImpl(Variance.INVARIANT, type))
-        return JetTypeImpl.create(annotations, descriptor, false, arguments)
+        return KtTypeImpl.create(annotations, descriptor, false, arguments)
     }
 
     public fun getKFunctionType(
             annotations: Annotations,
-            receiverType: JetType?,
-            parameterTypes: List<JetType>,
-            returnType: JetType
-    ): JetType {
+            receiverType: KtType?,
+            parameterTypes: List<KtType>,
+            returnType: KtType
+    ): KtType {
         val arguments = KotlinBuiltIns.getFunctionTypeArgumentProjections(receiverType, parameterTypes, returnType)
 
         val classDescriptor = getKFunction(arguments.size() - 1 /* return type */)
@@ -81,10 +81,10 @@ public class ReflectionTypes(private val module: ModuleDescriptor) {
             return classDescriptor.defaultType
         }
 
-        return JetTypeImpl.create(annotations, classDescriptor, false, arguments)
+        return KtTypeImpl.create(annotations, classDescriptor, false, arguments)
     }
 
-    public fun getKPropertyType(annotations: Annotations, receiverType: JetType?, returnType: JetType, mutable: Boolean): JetType {
+    public fun getKPropertyType(annotations: Annotations, receiverType: KtType?, returnType: KtType, mutable: Boolean): KtType {
         val classDescriptor =
                 when {
                     receiverType != null -> when {
@@ -106,7 +106,7 @@ public class ReflectionTypes(private val module: ModuleDescriptor) {
             arguments.add(TypeProjectionImpl(receiverType))
         }
         arguments.add(TypeProjectionImpl(returnType))
-        return JetTypeImpl.create(annotations, classDescriptor, false, arguments)
+        return KtTypeImpl.create(annotations, classDescriptor, false, arguments)
     }
 
     companion object {
@@ -115,21 +115,21 @@ public class ReflectionTypes(private val module: ModuleDescriptor) {
             return containingPackage != null && containingPackage.fqName == KOTLIN_REFLECT_FQ_NAME
         }
 
-        public fun isCallableType(type: JetType): Boolean =
+        public fun isCallableType(type: KtType): Boolean =
                 KotlinBuiltIns.isFunctionOrExtensionFunctionType(type) || isKCallableType(type)
 
-        private fun isKCallableType(type: JetType): Boolean =
+        private fun isKCallableType(type: KtType): Boolean =
                 isExactKCallableType(type) ||
                 type.constructor.supertypes.any { isKCallableType(it) }
 
-        private fun isExactKCallableType(type: JetType): Boolean {
+        private fun isExactKCallableType(type: KtType): Boolean {
             val descriptor = type.constructor.declarationDescriptor
             return descriptor is ClassDescriptor && DescriptorUtils.getFqName(descriptor) == KotlinBuiltIns.FQ_NAMES.kCallable
         }
 
-        public fun createKPropertyStarType(module: ModuleDescriptor): JetType? {
+        public fun createKPropertyStarType(module: ModuleDescriptor): KtType? {
             val kPropertyClass = module.findClassAcrossModuleDependencies(KotlinBuiltIns.FQ_NAMES.kProperty) ?: return null
-            return JetTypeImpl.create(
+            return KtTypeImpl.create(
                     Annotations.EMPTY, kPropertyClass, false,
                     listOf(StarProjectionImpl(kPropertyClass.typeConstructor.parameters.single()))
             )
diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt
index 98b6902d275..204733b577e 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt
@@ -108,7 +108,7 @@ public class FunctionClassDescriptor(
         }
 
         private val supertypes = storageManager.createLazyValue {
-            val result = ArrayList<JetType>(2)
+            val result = ArrayList<KtType>(2)
 
             fun add(packageFragment: PackageFragmentDescriptor, name: Name) {
                 val descriptor = packageFragment.getMemberScope().getClassifier(name, NoLookupLocation.FROM_BUILTINS) as? ClassDescriptor
@@ -121,7 +121,7 @@ public class FunctionClassDescriptor(
                     TypeProjectionImpl(it.getDefaultType())
                 }
 
-                result.add(JetTypeImpl.create(Annotations.EMPTY, descriptor, false, arguments))
+                result.add(KtTypeImpl.create(Annotations.EMPTY, descriptor, false, arguments))
             }
 
             // Add unnumbered base class, e.g. Function for Function{n}, KFunction for KFunction{n}
@@ -140,7 +140,7 @@ public class FunctionClassDescriptor(
 
         override fun getParameters() = parameters
 
-        override fun getSupertypes(): Collection<JetType> = supertypes()
+        override fun getSupertypes(): Collection<KtType> = supertypes()
 
         override fun getDeclarationDescriptor() = this@FunctionClassDescriptor
         override fun isDenotable() = true
diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt
index ee0ac26ec44..00e82bf42ae 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.OverridingUtil
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
+import org.jetbrains.kotlin.resolve.scopes.KtScopeImpl
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.utils.Printer
@@ -30,7 +30,7 @@ import java.util.ArrayList
 class FunctionClassScope(
         private val storageManager: StorageManager,
         private val functionClass: FunctionClassDescriptor
-) : JetScopeImpl() {
+) : KtScopeImpl() {
     private val allDescriptors = storageManager.createLazyValue {
         if (functionClass.functionKind == FunctionClassDescriptor.Kind.Function) {
             val invoke = FunctionInvokeDescriptor.create(functionClass)
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/CallableDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/CallableDescriptor.java
index c14d99e9df1..3eb526d3e9f 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/CallableDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/CallableDescriptor.java
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 
 import java.util.Collection;
@@ -38,7 +38,7 @@ public interface CallableDescriptor extends DeclarationDescriptorWithVisibility,
      * Method may return null for not yet fully initialized object or if error occurred.
      */
     @Nullable
-    JetType getReturnType();
+    KtType getReturnType();
 
     @NotNull
     @Override
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassDescriptor.java
index e47c536b729..3a2198b18c6 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassDescriptor.java
@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.ReadOnly;
-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.jetbrains.kotlin.types.TypeProjection;
 import org.jetbrains.kotlin.types.TypeSubstitution;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
@@ -30,19 +30,19 @@ import java.util.List;
 
 public interface ClassDescriptor extends ClassifierDescriptor, MemberDescriptor, ClassOrPackageFragmentDescriptor {
     @NotNull
-    JetScope getMemberScope(@NotNull List<? extends TypeProjection> typeArguments);
+    KtScope getMemberScope(@NotNull List<? extends TypeProjection> typeArguments);
 
     @NotNull
-    JetScope getMemberScope(@NotNull TypeSubstitution typeSubstitution);
+    KtScope getMemberScope(@NotNull TypeSubstitution typeSubstitution);
 
     @NotNull
-    JetScope getUnsubstitutedMemberScope();
+    KtScope getUnsubstitutedMemberScope();
 
     @NotNull
-    JetScope getUnsubstitutedInnerClassesScope();
+    KtScope getUnsubstitutedInnerClassesScope();
 
     @NotNull
-    JetScope getStaticScope();
+    KtScope getStaticScope();
 
     @NotNull
     @ReadOnly
@@ -57,7 +57,7 @@ public interface ClassDescriptor extends ClassifierDescriptor, MemberDescriptor,
      */
     @NotNull
     @Override
-    JetType getDefaultType();
+    KtType getDefaultType();
 
     @NotNull
     @Override
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassifierDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassifierDescriptor.java
index 3d7c7292904..b32a5604f21 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassifierDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassifierDescriptor.java
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.descriptors;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeConstructor;
 
 public interface ClassifierDescriptor extends DeclarationDescriptorNonRoot {
@@ -25,5 +25,5 @@ public interface ClassifierDescriptor extends DeclarationDescriptorNonRoot {
     TypeConstructor getTypeConstructor();
 
     @NotNull
-    JetType getDefaultType();
+    KtType getDefaultType();
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ConstUtil.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ConstUtil.kt
index 3efb5b67702..0badeaad74d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ConstUtil.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ConstUtil.kt
@@ -19,11 +19,11 @@
 package org.jetbrains.kotlin.descriptors
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 object ConstUtil {
     @JvmStatic
-    public fun canBeUsedForConstVal(type: JetType) = type.canBeUsedForConstVal()
+    public fun canBeUsedForConstVal(type: KtType) = type.canBeUsedForConstVal()
 }
 
-public fun JetType.canBeUsedForConstVal() = KotlinBuiltIns.isPrimitiveType(this) || KotlinBuiltIns.isString(this)
+public fun KtType.canBeUsedForConstVal() = KotlinBuiltIns.isPrimitiveType(this) || KotlinBuiltIns.isString(this)
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ConstructorDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ConstructorDescriptor.java
index 7f32cbae552..5bf438978d5 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ConstructorDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ConstructorDescriptor.java
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.List;
 
@@ -29,7 +29,7 @@ public interface ConstructorDescriptor extends FunctionDescriptor {
 
     @NotNull
     @Override
-    JetType getReturnType();
+    KtType getReturnType();
 
     @NotNull
     @Override
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/EffectiveVisibility.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/EffectiveVisibility.kt
index fa8d3dc79b9..ecb0c5a200a 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/EffectiveVisibility.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/EffectiveVisibility.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.descriptors
 
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeConstructor
 
 sealed class EffectiveVisibility(val name: String) {
@@ -231,9 +231,9 @@ sealed class EffectiveVisibility(val name: String) {
                     lowerBound(visibility.forVisibility(this), this?.forClass(classes + this@forClass) ?: Public)
                 }
 
-        fun JetType.forType() = forType(emptySet())
+        fun KtType.forType() = forType(emptySet())
 
-        private fun JetType.forType(types: Set<JetType>): EffectiveVisibility =
+        private fun KtType.forType(types: Set<KtType>): EffectiveVisibility =
                 if (this in types) Public
                 else lowerBound(constructor.forTypeConstructor(),
                                 arguments.map { it.type.forType(types + this) } )
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/PackageFragmentDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/PackageFragmentDescriptor.kt
index 774e9cfa20b..fd5dc97bdcc 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/PackageFragmentDescriptor.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/PackageFragmentDescriptor.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.descriptors
 
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 
 public interface PackageFragmentDescriptor : ClassOrPackageFragmentDescriptor {
 
@@ -25,5 +25,5 @@ public interface PackageFragmentDescriptor : ClassOrPackageFragmentDescriptor {
 
     public val fqName: FqName
 
-    public fun getMemberScope(): JetScope
+    public fun getMemberScope(): KtScope
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/PackageViewDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/PackageViewDescriptor.kt
index 16f487046c4..0eaee42f52a 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/PackageViewDescriptor.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/PackageViewDescriptor.kt
@@ -17,14 +17,14 @@
 package org.jetbrains.kotlin.descriptors
 
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 
 public interface PackageViewDescriptor : DeclarationDescriptor {
     override fun getContainingDeclaration(): PackageViewDescriptor?
 
     public val fqName: FqName
 
-    public val memberScope: JetScope
+    public val memberScope: KtScope
 
     public val module: ModuleDescriptor
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ParameterDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ParameterDescriptor.java
index 7b081702197..cf21a80b157 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ParameterDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ParameterDescriptor.java
@@ -17,11 +17,11 @@
 package org.jetbrains.kotlin.descriptors;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public interface ParameterDescriptor extends CallableDescriptor {
     @NotNull
-    JetType getType();
+    KtType getType();
 
     @Override
     @NotNull
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ScriptDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ScriptDescriptor.java
index 2212017188a..85a5d6f4260 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ScriptDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ScriptDescriptor.java
@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.impl.ScriptCodeDescriptor;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
 
 public interface ScriptDescriptor extends DeclarationDescriptorNonRoot {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/TypeParameterDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/TypeParameterDescriptor.java
index 67a10f4798e..fd14091ddfd 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/TypeParameterDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/TypeParameterDescriptor.java
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.descriptors;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeConstructor;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 import org.jetbrains.kotlin.types.Variance;
@@ -31,13 +31,13 @@ public interface TypeParameterDescriptor extends ClassifierDescriptor {
     Variance getVariance();
 
     @NotNull
-    Set<JetType> getUpperBounds();
+    Set<KtType> getUpperBounds();
 
     @NotNull
-    JetType getUpperBoundsAsType();
+    KtType getUpperBoundsAsType();
 
     @NotNull
-    Set<JetType> getLowerBounds();
+    Set<KtType> getLowerBounds();
 
     @NotNull
     @Override
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ValueParameterDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ValueParameterDescriptor.java
index 569ce1b7f98..0783ebfdae0 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ValueParameterDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ValueParameterDescriptor.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collection;
 
@@ -42,7 +42,7 @@ public interface ValueParameterDescriptor extends VariableDescriptor, ParameterD
     boolean declaresDefaultValue();
 
     @Nullable
-    JetType getVarargElementType();
+    KtType getVarargElementType();
 
     @NotNull
     @Override
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/VariableDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/VariableDescriptor.java
index 8d069a454b0..43917585040 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/VariableDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/VariableDescriptor.java
@@ -19,12 +19,12 @@ package org.jetbrains.kotlin.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 
 public interface VariableDescriptor extends CallableDescriptor {
     @NotNull
-    JetType getType();
+    KtType getType();
 
     @Override
     @NotNull
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.java
index 1ad538fee5b..531f0429028 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.java
@@ -21,13 +21,13 @@ import org.jetbrains.annotations.ReadOnly;
 import org.jetbrains.kotlin.descriptors.SourceElement;
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Map;
 
 public interface AnnotationDescriptor {
     @NotNull
-    JetType getType();
+    KtType getType();
 
     @NotNull
     @ReadOnly
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java
index 99b5f350915..581f52c7e78 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java
@@ -21,18 +21,18 @@ import org.jetbrains.kotlin.descriptors.SourceElement;
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collections;
 import java.util.Map;
 
 public class AnnotationDescriptorImpl implements AnnotationDescriptor {
-    private final JetType annotationType;
+    private final KtType annotationType;
     private final Map<ValueParameterDescriptor, ConstantValue<?>> valueArguments;
     private final SourceElement source;
 
     public AnnotationDescriptorImpl(
-            @NotNull JetType annotationType,
+            @NotNull KtType annotationType,
             @NotNull Map<ValueParameterDescriptor, ConstantValue<?>> valueArguments,
             @NotNull SourceElement source
     ) {
@@ -43,7 +43,7 @@ public class AnnotationDescriptorImpl implements AnnotationDescriptor {
 
     @Override
     @NotNull
-    public JetType getType() {
+    public KtType getType() {
         return annotationType;
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractClassDescriptor.java
index 68ff3bf791d..2b02370a44e 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractClassDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractClassDescriptor.java
@@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.scopes.InnerClassesScopeWrapper;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.resolve.scopes.SubstitutingScope;
 import org.jetbrains.kotlin.storage.NotNullLazyValue;
 import org.jetbrains.kotlin.storage.StorageManager;
@@ -31,21 +31,21 @@ import java.util.List;
 
 public abstract class AbstractClassDescriptor implements ClassDescriptor {
     private final Name name;
-    protected final NotNullLazyValue<JetType> defaultType;
-    private final NotNullLazyValue<JetScope> unsubstitutedInnerClassesScope;
+    protected final NotNullLazyValue<KtType> defaultType;
+    private final NotNullLazyValue<KtScope> unsubstitutedInnerClassesScope;
     private final NotNullLazyValue<ReceiverParameterDescriptor> thisAsReceiverParameter;
 
     public AbstractClassDescriptor(@NotNull StorageManager storageManager, @NotNull Name name) {
         this.name = name;
-        this.defaultType = storageManager.createLazyValue(new Function0<JetType>() {
+        this.defaultType = storageManager.createLazyValue(new Function0<KtType>() {
             @Override
-            public JetType invoke() {
+            public KtType invoke() {
                 return TypeUtils.makeUnsubstitutedType(AbstractClassDescriptor.this, getUnsubstitutedMemberScope());
             }
         });
-        this.unsubstitutedInnerClassesScope = storageManager.createLazyValue(new Function0<JetScope>() {
+        this.unsubstitutedInnerClassesScope = storageManager.createLazyValue(new Function0<KtScope>() {
             @Override
-            public JetScope invoke() {
+            public KtScope invoke() {
                 return new InnerClassesScopeWrapper(getUnsubstitutedMemberScope());
             }
         });
@@ -71,7 +71,7 @@ public abstract class AbstractClassDescriptor implements ClassDescriptor {
 
     @NotNull
     @Override
-    public JetScope getUnsubstitutedInnerClassesScope() {
+    public KtScope getUnsubstitutedInnerClassesScope() {
         return unsubstitutedInnerClassesScope.invoke();
     }
 
@@ -83,7 +83,7 @@ public abstract class AbstractClassDescriptor implements ClassDescriptor {
 
     @NotNull
     @Override
-    public JetScope getMemberScope(@NotNull List<? extends TypeProjection> typeArguments) {
+    public KtScope getMemberScope(@NotNull List<? extends TypeProjection> typeArguments) {
         assert typeArguments.size() == getTypeConstructor().getParameters().size() : "Illegal number of type arguments: expected "
                                                                                      + getTypeConstructor().getParameters().size() + " but was " + typeArguments.size()
                                                                                      + " for " + getTypeConstructor() + " " + getTypeConstructor().getParameters();
@@ -95,7 +95,7 @@ public abstract class AbstractClassDescriptor implements ClassDescriptor {
 
     @NotNull
     @Override
-    public JetScope getMemberScope(@NotNull TypeSubstitution typeSubstitution) {
+    public KtScope getMemberScope(@NotNull TypeSubstitution typeSubstitution) {
         if (typeSubstitution.isEmpty()) return getUnsubstitutedMemberScope();
 
         TypeSubstitutor substitutor = TypeSubstitutor.create(typeSubstitution);
@@ -113,7 +113,7 @@ public abstract class AbstractClassDescriptor implements ClassDescriptor {
 
     @NotNull
     @Override
-    public JetType getDefaultType() {
+    public KtType getDefaultType() {
         return defaultType.invoke();
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractLazyTypeParameterDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractLazyTypeParameterDescriptor.java
index a23fa2ecceb..a9ccfa353e0 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractLazyTypeParameterDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractLazyTypeParameterDescriptor.java
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeConstructor;
 import org.jetbrains.kotlin.types.Variance;
 
@@ -53,7 +53,7 @@ public abstract class AbstractLazyTypeParameterDescriptor extends AbstractTypePa
         return new TypeConstructor() {
             @NotNull
             @Override
-            public Collection<JetType> getSupertypes() {
+            public Collection<KtType> getSupertypes() {
                 return AbstractLazyTypeParameterDescriptor.this.getUpperBounds();
             }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractReceiverParameterDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractReceiverParameterDescriptor.java
index d3e079307cf..e5938e57958 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractReceiverParameterDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractReceiverParameterDescriptor.java
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 import org.jetbrains.kotlin.types.Variance;
 
@@ -41,7 +41,7 @@ public abstract class AbstractReceiverParameterDescriptor extends DeclarationDes
     @Override
     public ReceiverParameterDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
         if (substitutor.isEmpty()) return this;
-        JetType substitutedType = substitutor.substitute(getType(), Variance.INVARIANT);
+        KtType substitutedType = substitutor.substitute(getType(), Variance.INVARIANT);
         if (substitutedType == null) return null;
 
         return new ReceiverParameterDescriptorImpl(getContainingDeclaration(), new TransientReceiver(substitutedType));
@@ -72,13 +72,13 @@ public abstract class AbstractReceiverParameterDescriptor extends DeclarationDes
 
     @Nullable
     @Override
-    public JetType getReturnType() {
+    public KtType getReturnType() {
         return getType();
     }
 
     @NotNull
     @Override
-    public JetType getType() {
+    public KtType getType() {
         return getValue().getType();
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java
index 9f339ea5d9c..25ad9a1cac8 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java
@@ -19,19 +19,18 @@ package org.jetbrains.kotlin.descriptors.impl;
 import kotlin.jvm.functions.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.ReadOnly;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptorVisitor;
 import org.jetbrains.kotlin.descriptors.SourceElement;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.resolve.scopes.LazyScopeAdapter;
 import org.jetbrains.kotlin.storage.NotNullLazyValue;
 import org.jetbrains.kotlin.storage.StorageManager;
 import org.jetbrains.kotlin.types.*;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.Collections;
 import java.util.Set;
@@ -44,9 +43,9 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip
     private final int index;
 
     private final NotNullLazyValue<TypeConstructor> typeConstructor;
-    private final NotNullLazyValue<JetType> defaultType;
-    private final NotNullLazyValue<Set<JetType>> upperBounds;
-    private final NotNullLazyValue<JetType> upperBoundsAsType;
+    private final NotNullLazyValue<KtType> defaultType;
+    private final NotNullLazyValue<Set<KtType>> upperBounds;
+    private final NotNullLazyValue<KtType> upperBoundsAsType;
 
     protected AbstractTypeParameterDescriptor(
             @NotNull final StorageManager storageManager,
@@ -69,29 +68,29 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip
                 return createTypeConstructor();
             }
         });
-        this.defaultType = storageManager.createLazyValue(new Function0<JetType>() {
+        this.defaultType = storageManager.createLazyValue(new Function0<KtType>() {
             @Override
-            public JetType invoke() {
-                return JetTypeImpl.create(Annotations.Companion.getEMPTY(), getTypeConstructor(), false, Collections.<TypeProjection>emptyList(),
-                                       new LazyScopeAdapter(storageManager.createLazyValue(
-                                               new Function0<JetScope>() {
+            public KtType invoke() {
+                return KtTypeImpl.create(Annotations.Companion.getEMPTY(), getTypeConstructor(), false, Collections.<TypeProjection>emptyList(),
+                                         new LazyScopeAdapter(storageManager.createLazyValue(
+                                               new Function0<KtScope>() {
                                                    @Override
-                                                   public JetScope invoke() {
+                                                   public KtScope invoke() {
                                                        return getUpperBoundsAsType().getMemberScope();
                                                    }
                                                }
                                        )));
             }
         });
-        this.upperBounds = storageManager.createRecursionTolerantLazyValue(new Function0<Set<JetType>>() {
+        this.upperBounds = storageManager.createRecursionTolerantLazyValue(new Function0<Set<KtType>>() {
             @Override
-            public Set<JetType> invoke() {
+            public Set<KtType> invoke() {
                 return resolveUpperBounds();
             }
         }, Collections.singleton(ErrorUtils.createErrorType("Recursion while calculating upper bounds")));
-        this.upperBoundsAsType = storageManager.createLazyValue(new Function0<JetType>() {
+        this.upperBoundsAsType = storageManager.createLazyValue(new Function0<KtType>() {
             @Override
-            public JetType invoke() {
+            public KtType invoke() {
                 return computeUpperBoundsAsType();
             }
         });
@@ -99,7 +98,7 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip
 
     @NotNull
     @ReadOnly
-    protected abstract Set<JetType> resolveUpperBounds();
+    protected abstract Set<KtType> resolveUpperBounds();
 
     @NotNull
     protected abstract TypeConstructor createTypeConstructor();
@@ -122,21 +121,21 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip
 
     @NotNull
     @Override
-    public Set<JetType> getUpperBounds() {
+    public Set<KtType> getUpperBounds() {
         return upperBounds.invoke();
     }
 
     @NotNull
     @Override
-    public JetType getUpperBoundsAsType() {
+    public KtType getUpperBoundsAsType() {
         return upperBoundsAsType.invoke();
     }
 
     @NotNull
-    private JetType computeUpperBoundsAsType() {
-        Set<JetType> upperBounds = getUpperBounds();
+    private KtType computeUpperBoundsAsType() {
+        Set<KtType> upperBounds = getUpperBounds();
         assert !upperBounds.isEmpty() : "Upper bound list is empty in " + getName();
-        JetType upperBoundsAsType = TypeIntersector.intersectTypes(JetTypeChecker.DEFAULT, upperBounds);
+        KtType upperBoundsAsType = TypeIntersector.intersectTypes(KotlinTypeChecker.DEFAULT, upperBounds);
         return upperBoundsAsType != null ? upperBoundsAsType : getBuiltIns(this).getNothingType();
     }
 
@@ -148,13 +147,13 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip
 
     @NotNull
     @Override
-    public JetType getDefaultType() {
+    public KtType getDefaultType() {
         return defaultType.invoke();
     }
 
     @NotNull
     @Override
-    public Set<JetType> getLowerBounds() {
+    public Set<KtType> getLowerBounds() {
         return Collections.singleton(getBuiltIns(this).getNothingType());
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java
index 64be2dc03b4..62dd2012038 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java
@@ -21,10 +21,10 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.resolve.scopes.StaticScopeForKotlinClass;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeConstructor;
 import org.jetbrains.kotlin.types.TypeConstructorImpl;
 
@@ -35,9 +35,9 @@ import java.util.Set;
 public class ClassDescriptorImpl extends ClassDescriptorBase {
     private final Modality modality;
     private final TypeConstructor typeConstructor;
-    private final JetScope staticScope = new StaticScopeForKotlinClass(this);
+    private final KtScope staticScope = new StaticScopeForKotlinClass(this);
 
-    private JetScope unsubstitutedMemberScope;
+    private KtScope unsubstitutedMemberScope;
     private Set<ConstructorDescriptor> constructors;
     private ConstructorDescriptor primaryConstructor;
 
@@ -45,7 +45,7 @@ public class ClassDescriptorImpl extends ClassDescriptorBase {
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull Name name,
             @NotNull Modality modality,
-            @NotNull Collection<JetType> supertypes,
+            @NotNull Collection<KtType> supertypes,
             @NotNull SourceElement source
     ) {
         super(LockBasedStorageManager.NO_LOCKS, containingDeclaration, name, source);
@@ -56,7 +56,7 @@ public class ClassDescriptorImpl extends ClassDescriptorBase {
     }
 
     public final void initialize(
-            @NotNull JetScope unsubstitutedMemberScope,
+            @NotNull KtScope unsubstitutedMemberScope,
             @NotNull Set<ConstructorDescriptor> constructors,
             @Nullable ConstructorDescriptor primaryConstructor
     ) {
@@ -89,13 +89,13 @@ public class ClassDescriptorImpl extends ClassDescriptorBase {
 
     @NotNull
     @Override
-    public JetScope getUnsubstitutedMemberScope() {
+    public KtScope getUnsubstitutedMemberScope() {
         return unsubstitutedMemberScope;
     }
 
     @NotNull
     @Override
-    public JetScope getStaticScope() {
+    public KtScope getStaticScope() {
         return staticScope;
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java
index 98bf3c8025e..47d0e8cbfd0 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java
@@ -28,13 +28,13 @@ import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.DescriptorFactory;
 import org.jetbrains.kotlin.resolve.OverridingUtil;
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScopeImpl;
 import org.jetbrains.kotlin.resolve.scopes.StaticScopeForKotlinClass;
 import org.jetbrains.kotlin.storage.MemoizedFunctionToNotNull;
 import org.jetbrains.kotlin.storage.NotNullLazyValue;
 import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeConstructor;
 import org.jetbrains.kotlin.types.TypeConstructorImpl;
 import org.jetbrains.kotlin.utils.Printer;
@@ -47,8 +47,8 @@ import java.util.Set;
 public class EnumEntrySyntheticClassDescriptor extends ClassDescriptorBase {
     private final TypeConstructor typeConstructor;
     private final ConstructorDescriptor primaryConstructor;
-    private final JetScope scope;
-    private final JetScope staticScope = new StaticScopeForKotlinClass(this);
+    private final KtScope scope;
+    private final KtScope staticScope = new StaticScopeForKotlinClass(this);
     private final NotNullLazyValue<Collection<Name>> enumMemberNames;
 
     /**
@@ -63,7 +63,7 @@ public class EnumEntrySyntheticClassDescriptor extends ClassDescriptorBase {
             @NotNull NotNullLazyValue<Collection<Name>> enumMemberNames,
             @NotNull SourceElement source
     ) {
-        JetType enumType = enumClass.getDefaultType();
+        KtType enumType = enumClass.getDefaultType();
 
         return new EnumEntrySyntheticClassDescriptor(storageManager, enumClass, enumType, name, enumMemberNames, source);
     }
@@ -71,7 +71,7 @@ public class EnumEntrySyntheticClassDescriptor extends ClassDescriptorBase {
     private EnumEntrySyntheticClassDescriptor(
             @NotNull StorageManager storageManager,
             @NotNull ClassDescriptor containingClass,
-            @NotNull JetType supertype,
+            @NotNull KtType supertype,
             @NotNull Name name,
             @NotNull NotNullLazyValue<Collection<Name>> enumMemberNames,
             @NotNull SourceElement source
@@ -93,13 +93,13 @@ public class EnumEntrySyntheticClassDescriptor extends ClassDescriptorBase {
 
     @NotNull
     @Override
-    public JetScope getUnsubstitutedMemberScope() {
+    public KtScope getUnsubstitutedMemberScope() {
         return scope;
     }
 
     @NotNull
     @Override
-    public JetScope getStaticScope() {
+    public KtScope getStaticScope() {
         return staticScope;
     }
 
@@ -172,7 +172,7 @@ public class EnumEntrySyntheticClassDescriptor extends ClassDescriptorBase {
         return "enum entry " + getName();
     }
 
-    private class EnumEntryScope extends JetScopeImpl {
+    private class EnumEntryScope extends KtScopeImpl {
         private final MemoizedFunctionToNotNull<Name, Collection<FunctionDescriptor>> functions;
         private final MemoizedFunctionToNotNull<Name, Collection<PropertyDescriptor>> properties;
         private final NotNullLazyValue<Collection<DeclarationDescriptor>> allDescriptors;
@@ -224,8 +224,8 @@ public class EnumEntrySyntheticClassDescriptor extends ClassDescriptorBase {
         }
 
         @NotNull
-        private JetScope getSupertypeScope() {
-            Collection<JetType> supertype = getTypeConstructor().getSupertypes();
+        private KtScope getSupertypeScope() {
+            Collection<KtType> supertype = getTypeConstructor().getSupertypes();
             assert supertype.size() == 1 : "Enum entry and its companion object both should have exactly one supertype: " + supertype;
             return supertype.iterator().next().getMemberScope();
         }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java
index 89e0a36e8f4..b39551e4fa3 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java
@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.descriptors.impl;
 
+import kotlin.reflect.jvm.internal.impl.types.JetType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
@@ -23,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.DescriptorFactory;
 import org.jetbrains.kotlin.types.DescriptorSubstitutor;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 import org.jetbrains.kotlin.types.Variance;
 import org.jetbrains.kotlin.utils.CollectionsKt;
@@ -37,7 +38,7 @@ import java.util.Set;
 public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRootImpl implements FunctionDescriptor {
     private List<TypeParameterDescriptor> typeParameters;
     private List<ValueParameterDescriptor> unsubstitutedValueParameters;
-    private JetType unsubstitutedReturnType;
+    private KtType unsubstitutedReturnType;
     private ReceiverParameterDescriptor extensionReceiverParameter;
     private ReceiverParameterDescriptor dispatchReceiverParameter;
     private Modality modality;
@@ -66,11 +67,11 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
 
     @NotNull
     public FunctionDescriptorImpl initialize(
-            @Nullable JetType receiverParameterType,
+            @Nullable KtType receiverParameterType,
             @Nullable ReceiverParameterDescriptor dispatchReceiverParameter,
             @NotNull List<? extends TypeParameterDescriptor> typeParameters,
             @NotNull List<ValueParameterDescriptor> unsubstitutedValueParameters,
-            @Nullable JetType unsubstitutedReturnType,
+            @Nullable KtType unsubstitutedReturnType,
             @Nullable Modality modality,
             @NotNull Visibility visibility
     ) {
@@ -125,7 +126,7 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
         this.isTailrec = isTailrec;
     }
 
-    public void setReturnType(@NotNull JetType unsubstitutedReturnType) {
+    public void setReturnType(@NotNull KtType unsubstitutedReturnType) {
         if (this.unsubstitutedReturnType != null) {
             // TODO: uncomment and fix tests
             //throw new IllegalStateException("returnType already set");
@@ -228,7 +229,7 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
     }
 
     @Override
-    public JetType getReturnType() {
+    public KtType getReturnType() {
         return unsubstitutedReturnType;
     }
 
@@ -275,7 +276,7 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
     }
 
     @Nullable
-    protected JetType getExtensionReceiverParameterType() {
+    protected KtType getExtensionReceiverParameterType() {
         if (extensionReceiverParameter == null) return null;
         return extensionReceiverParameter.getType();
     }
@@ -295,8 +296,8 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
             boolean copyOverrides,
             @NotNull Kind kind,
             @NotNull List<ValueParameterDescriptor> newValueParameterDescriptors,
-            @Nullable JetType newExtensionReceiverParameterType,
-            @NotNull JetType newReturnType
+            @Nullable KtType newExtensionReceiverParameterType,
+            @NotNull KtType newReturnType
     ) {
         FunctionDescriptorImpl substitutedDescriptor = createSubstitutedCopy(newOwner, original, kind);
 
@@ -306,7 +307,7 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
                 originalTypeParameters, originalSubstitutor.getSubstitution(), substitutedDescriptor, substitutedTypeParameters
         );
 
-        JetType substitutedReceiverParameterType = null;
+        KtType substitutedReceiverParameterType = null;
         if (newExtensionReceiverParameterType != null) {
             substitutedReceiverParameterType = substitutor.substitute(newExtensionReceiverParameterType, Variance.IN_VARIANCE);
             if (substitutedReceiverParameterType == null) {
@@ -339,7 +340,7 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
             return null;
         }
 
-        JetType substitutedReturnType = substitutor.substitute(newReturnType, Variance.OUT_VARIANCE);
+        KtType substitutedReturnType = substitutor.substitute(newReturnType, Variance.OUT_VARIANCE);
         if (substitutedReturnType == null) {
             return null;
         }
@@ -389,9 +390,9 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
         List<ValueParameterDescriptor> result = new ArrayList<ValueParameterDescriptor>(unsubstitutedValueParameters.size());
         for (ValueParameterDescriptor unsubstitutedValueParameter : unsubstitutedValueParameters) {
             // TODO : Lazy?
-            JetType substitutedType = substitutor.substitute(unsubstitutedValueParameter.getType(), Variance.IN_VARIANCE);
-            JetType varargElementType = unsubstitutedValueParameter.getVarargElementType();
-            JetType substituteVarargElementType =
+            KtType substitutedType = substitutor.substitute(unsubstitutedValueParameter.getType(), Variance.IN_VARIANCE);
+            KtType varargElementType = unsubstitutedValueParameter.getVarargElementType();
+            KtType substituteVarargElementType =
                     varargElementType == null ? null : substitutor.substitute(varargElementType, Variance.IN_VARIANCE);
             if (substitutedType == null) return null;
             result.add(
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazyPackageViewDescriptorImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazyPackageViewDescriptorImpl.kt
index 2292398f3f5..67456a09efb 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazyPackageViewDescriptorImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazyPackageViewDescriptorImpl.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.scopes.ChainedScope
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.LazyScopeAdapter
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.storage.getValue
@@ -39,9 +39,9 @@ public class LazyPackageViewDescriptorImpl(
         module.packageFragmentProvider.getPackageFragments(fqName)
     }
 
-    override val memberScope: JetScope = LazyScopeAdapter(storageManager.createLazyValue {
+    override val memberScope: KtScope = LazyScopeAdapter(storageManager.createLazyValue {
         if (fragments.isEmpty()) {
-            JetScope.Empty
+            KtScope.Empty
         }
         else {
             val scopes = fragments.map { it.getMemberScope() } + SubpackagesScope(module, fqName)
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java
index 66f5b3eed75..b271fd743b7 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java
@@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.resolve.scopes.SubstitutingScope;
 import org.jetbrains.kotlin.types.*;
 
@@ -68,9 +68,9 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
         if (typeConstructor == null) {
             TypeSubstitutor substitutor = getSubstitutor();
 
-            Collection<JetType> originalSupertypes = originalTypeConstructor.getSupertypes();
-            Collection<JetType> supertypes = new ArrayList<JetType>(originalSupertypes.size());
-            for (JetType supertype : originalSupertypes) {
+            Collection<KtType> originalSupertypes = originalTypeConstructor.getSupertypes();
+            Collection<KtType> supertypes = new ArrayList<KtType>(originalSupertypes.size());
+            for (KtType supertype : originalSupertypes) {
                 supertypes.add(substitutor.substitute(supertype, Variance.INVARIANT));
             }
 
@@ -89,8 +89,8 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
 
     @NotNull
     @Override
-    public JetScope getMemberScope(@NotNull List<? extends TypeProjection> typeArguments) {
-        JetScope memberScope = original.getMemberScope(typeArguments);
+    public KtScope getMemberScope(@NotNull List<? extends TypeProjection> typeArguments) {
+        KtScope memberScope = original.getMemberScope(typeArguments);
         if (originalSubstitutor.isEmpty()) {
             return memberScope;
         }
@@ -99,8 +99,8 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
 
     @NotNull
     @Override
-    public JetScope getMemberScope(@NotNull TypeSubstitution typeSubstitution) {
-        JetScope memberScope = original.getMemberScope(typeSubstitution);
+    public KtScope getMemberScope(@NotNull TypeSubstitution typeSubstitution) {
+        KtScope memberScope = original.getMemberScope(typeSubstitution);
         if (originalSubstitutor.isEmpty()) {
             return memberScope;
         }
@@ -109,8 +109,8 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
 
     @NotNull
     @Override
-    public JetScope getUnsubstitutedMemberScope() {
-        JetScope memberScope = original.getUnsubstitutedMemberScope();
+    public KtScope getUnsubstitutedMemberScope() {
+        KtScope memberScope = original.getUnsubstitutedMemberScope();
         if (originalSubstitutor.isEmpty()) {
             return memberScope;
         }
@@ -119,15 +119,15 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
 
     @NotNull
     @Override
-    public JetScope getStaticScope() {
+    public KtScope getStaticScope() {
         return original.getStaticScope();
     }
 
     @NotNull
     @Override
-    public JetType getDefaultType() {
+    public KtType getDefaultType() {
         List<TypeProjection> typeProjections = TypeUtils.getDefaultTypeProjections(getTypeConstructor().getParameters());
-        return JetTypeImpl.create(
+        return KtTypeImpl.create(
                 getAnnotations(),
                 this,
                 false,
@@ -233,7 +233,7 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
 
     @NotNull
     @Override
-    public JetScope getUnsubstitutedInnerClassesScope() {
+    public KtScope getUnsubstitutedInnerClassesScope() {
         return original.getUnsubstitutedInnerClassesScope();
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java
index 3283bc98408..375f0fc9d58 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.DescriptorFactory;
 import org.jetbrains.kotlin.types.DescriptorSubstitutor;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 import org.jetbrains.kotlin.types.Variance;
 import org.jetbrains.kotlin.utils.SmartSet;
@@ -89,17 +89,17 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
     }
 
     public void setType(
-            @NotNull JetType outType,
+            @NotNull KtType outType,
             @ReadOnly @NotNull List<? extends TypeParameterDescriptor> typeParameters,
             @Nullable ReceiverParameterDescriptor dispatchReceiverParameter,
-            @Nullable JetType receiverType
+            @Nullable KtType receiverType
     ) {
         ReceiverParameterDescriptor extensionReceiverParameter = DescriptorFactory.createExtensionReceiverParameterForCallable(this, receiverType);
         setType(outType, typeParameters, dispatchReceiverParameter, extensionReceiverParameter);
     }
 
     public void setType(
-            @NotNull JetType outType,
+            @NotNull KtType outType,
             @ReadOnly @NotNull List<? extends TypeParameterDescriptor> typeParameters,
             @Nullable ReceiverParameterDescriptor dispatchReceiverParameter,
             @Nullable ReceiverParameterDescriptor extensionReceiverParameter
@@ -145,7 +145,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
 
     @NotNull
     @Override
-    public JetType getReturnType() {
+    public KtType getReturnType() {
         return getType();
     }
 
@@ -227,8 +227,8 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
                 originalTypeParameters, originalSubstitutor.getSubstitution(), substitutedDescriptor, substitutedTypeParameters
         );
 
-        JetType originalOutType = getType();
-        JetType outType = substitutor.substitute(originalOutType, Variance.OUT_VARIANCE);
+        KtType originalOutType = getType();
+        KtType outType = substitutor.substitute(originalOutType, Variance.OUT_VARIANCE);
         if (outType == null) {
             return null; // TODO : tell the user that the property was projected out
         }
@@ -244,7 +244,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
             substitutedDispatchReceiver = null;
         }
 
-        JetType substitutedReceiverType;
+        KtType substitutedReceiverType;
         if (extensionReceiverParameter != null) {
             substitutedReceiverType = substitutor.substitute(extensionReceiverParameter.getType(), Variance.IN_VARIANCE);
             if (substitutedReceiverType == null) return null;
@@ -260,7 +260,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
                 getter.hasBody(), getter.isDefault(), getter.isExternal(), kind, original == null ? null : original.getGetter(), SourceElement.NO_SOURCE
         );
         if (newGetter != null) {
-            JetType returnType = getter.getReturnType();
+            KtType returnType = getter.getReturnType();
             newGetter.initialize(returnType != null ? substitutor.substitute(returnType, Variance.OUT_VARIANCE) : null);
         }
         PropertySetterDescriptorImpl newSetter = setter == null ? null : new PropertySetterDescriptorImpl(
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyGetterDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyGetterDescriptorImpl.java
index b223def6c00..59216d6b506 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyGetterDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyGetterDescriptorImpl.java
@@ -21,14 +21,14 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
 public class PropertyGetterDescriptorImpl extends PropertyAccessorDescriptorImpl implements PropertyGetterDescriptor {
-    private JetType returnType;
+    private KtType returnType;
 
     @NotNull
     private final PropertyGetterDescriptor original;
@@ -51,7 +51,7 @@ public class PropertyGetterDescriptorImpl extends PropertyAccessorDescriptorImpl
         this.original = original != null ? original : this;
     }
     
-    public void initialize(JetType returnType) {
+    public void initialize(KtType returnType) {
         this.returnType = returnType == null ? getCorrespondingProperty().getType() : returnType;
     }
 
@@ -69,7 +69,7 @@ public class PropertyGetterDescriptorImpl extends PropertyAccessorDescriptorImpl
     }
 
     @Override
-    public JetType getReturnType() {
+    public KtType getReturnType() {
         return returnType;
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertySetterDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertySetterDescriptorImpl.java
index 7db7265cf03..82dfc2bc9e8 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertySetterDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertySetterDescriptorImpl.java
@@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -64,7 +64,7 @@ public class PropertySetterDescriptorImpl extends PropertyAccessorDescriptorImpl
 
     public static ValueParameterDescriptorImpl createSetterParameter(
             @NotNull PropertySetterDescriptor setterDescriptor,
-            @NotNull JetType type
+            @NotNull KtType type
     ) {
         return new ValueParameterDescriptorImpl(
                 setterDescriptor, null, 0, Annotations.Companion.getEMPTY(), Name.special("<set-?>"), type,
@@ -93,7 +93,7 @@ public class PropertySetterDescriptorImpl extends PropertyAccessorDescriptorImpl
 
     @NotNull
     @Override
-    public JetType getReturnType() {
+    public KtType getReturnType() {
         return getBuiltIns(this).getUnitType();
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ScriptCodeDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ScriptCodeDescriptor.java
index 1ed6cbaebab..a0a3452c9b0 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ScriptCodeDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ScriptCodeDescriptor.java
@@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collections;
 import java.util.List;
@@ -35,7 +35,7 @@ public class ScriptCodeDescriptor extends FunctionDescriptorImpl {
     public void initialize(
             @NotNull ReceiverParameterDescriptor dispatchReceiverParameter,
             @NotNull List<ValueParameterDescriptor> valueParameters,
-            @NotNull JetType returnType) {
+            @NotNull KtType returnType) {
         super.initialize(null, dispatchReceiverParameter, Collections.<TypeParameterDescriptor>emptyList(), valueParameters, returnType,
                          Modality.FINAL, Visibilities.INTERNAL);
     }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SimpleFunctionDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SimpleFunctionDescriptorImpl.java
index c54877d57aa..1f36e973fc0 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SimpleFunctionDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SimpleFunctionDescriptorImpl.java
@@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 
 import java.util.List;
@@ -52,11 +52,11 @@ public class SimpleFunctionDescriptorImpl extends FunctionDescriptorImpl impleme
     @NotNull
     @Override
     public SimpleFunctionDescriptorImpl initialize(
-            @Nullable JetType receiverParameterType,
+            @Nullable KtType receiverParameterType,
             @Nullable ReceiverParameterDescriptor dispatchReceiverParameter,
             @NotNull List<? extends TypeParameterDescriptor> typeParameters,
             @NotNull List<ValueParameterDescriptor> unsubstitutedValueParameters,
-            @Nullable JetType unsubstitutedReturnType,
+            @Nullable KtType unsubstitutedReturnType,
             @Nullable Modality modality,
             @NotNull Visibility visibility
     ) {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SubpackagesScope.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SubpackagesScope.kt
index 74faea608d2..6948f55ef9d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SubpackagesScope.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SubpackagesScope.kt
@@ -23,13 +23,13 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindExclude
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
+import org.jetbrains.kotlin.resolve.scopes.KtScopeImpl
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.sure
 import java.util.ArrayList
 
-public class SubpackagesScope(private val moduleDescriptor: ModuleDescriptor, private val fqName: FqName) : JetScopeImpl() {
+public class SubpackagesScope(private val moduleDescriptor: ModuleDescriptor, private val fqName: FqName) : KtScopeImpl() {
     override fun getContainingDeclaration(): DeclarationDescriptor {
         return moduleDescriptor.getPackage(fqName)
     }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/TypeParameterDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/TypeParameterDescriptorImpl.java
index c5c2e0b1bfc..af310a90ce3 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/TypeParameterDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/TypeParameterDescriptorImpl.java
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeConstructor;
 import org.jetbrains.kotlin.types.TypeConstructorImpl;
 import org.jetbrains.kotlin.types.Variance;
@@ -63,7 +63,7 @@ public class TypeParameterDescriptorImpl extends AbstractTypeParameterDescriptor
         return new TypeParameterDescriptorImpl(containingDeclaration, annotations, reified, variance, name, index, source);
     }
 
-    private final Set<JetType> upperBounds = SmartSet.create();
+    private final Set<KtType> upperBounds = SmartSet.create();
     private boolean initialized = false;
 
     private TypeParameterDescriptorImpl(
@@ -113,12 +113,12 @@ public class TypeParameterDescriptorImpl extends AbstractTypeParameterDescriptor
         initialized = true;
     }
 
-    public void addUpperBound(@NotNull JetType bound) {
+    public void addUpperBound(@NotNull KtType bound) {
         checkUninitialized();
         doAddUpperBound(bound);
     }
 
-    private void doAddUpperBound(JetType bound) {
+    private void doAddUpperBound(KtType bound) {
         upperBounds.add(bound); // TODO : Duplicates?
     }
 
@@ -132,7 +132,7 @@ public class TypeParameterDescriptorImpl extends AbstractTypeParameterDescriptor
 
     @NotNull
     @Override
-    protected Set<JetType> resolveUpperBounds() {
+    protected Set<KtType> resolveUpperBounds() {
         checkInitialized();
         return upperBounds;
     }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.java
index a3cbc8d4162..92c9d585a41 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.java
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 
 import java.util.Collection;
@@ -33,7 +33,7 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
     private final boolean declaresDefaultValue;
     private final boolean isCrossinline;
     private final boolean isNoinline;
-    private final JetType varargElementType;
+    private final KtType varargElementType;
     private final int index;
     private final ValueParameterDescriptor original;
 
@@ -43,11 +43,11 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
             int index,
             @NotNull Annotations annotations,
             @NotNull Name name,
-            @NotNull JetType outType,
+            @NotNull KtType outType,
             boolean declaresDefaultValue,
             boolean isCrossinline,
             boolean isNoinline,
-            @Nullable JetType varargElementType,
+            @Nullable KtType varargElementType,
             @NotNull SourceElement source
     ) {
         super(containingDeclaration, annotations, name, outType, source);
@@ -87,7 +87,7 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
 
     @Nullable
     @Override
-    public JetType getVarargElementType() {
+    public KtType getVarargElementType() {
         return varargElementType;
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/VariableDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/VariableDescriptorImpl.java
index afdc97e96f1..5963ade905d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/VariableDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/VariableDescriptorImpl.java
@@ -21,20 +21,20 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
 public abstract class VariableDescriptorImpl extends DeclarationDescriptorNonRootImpl implements VariableDescriptor {
-    protected JetType outType;
+    protected KtType outType;
 
     public VariableDescriptorImpl(
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull Annotations annotations,
             @NotNull Name name,
-            @Nullable JetType outType,
+            @Nullable KtType outType,
             @NotNull SourceElement source
     ) {
         super(containingDeclaration, annotations, name, source);
@@ -44,11 +44,11 @@ public abstract class VariableDescriptorImpl extends DeclarationDescriptorNonRoo
 
     @NotNull
     @Override
-    public JetType getType() {
+    public KtType getType() {
         return outType;
     }
 
-    public void setOutType(JetType outType) {
+    public void setOutType(KtType outType) {
         assert this.outType == null;
         this.outType = outType;
     }
@@ -99,7 +99,7 @@ public abstract class VariableDescriptorImpl extends DeclarationDescriptorNonRoo
 
     @NotNull
     @Override
-    public JetType getReturnType() {
+    public KtType getReturnType() {
         return getType();
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/VariableDescriptorWithInitializerImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/VariableDescriptorWithInitializerImpl.java
index 8020d7d9eb7..2fc71c19c7e 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/VariableDescriptorWithInitializerImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/VariableDescriptorWithInitializerImpl.java
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.storage.NullableLazyValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.LazyType;
 
 public abstract class VariableDescriptorWithInitializerImpl extends VariableDescriptorImpl {
@@ -36,7 +36,7 @@ public abstract class VariableDescriptorWithInitializerImpl extends VariableDesc
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull Annotations annotations,
             @NotNull Name name,
-            @Nullable JetType outType,
+            @Nullable KtType outType,
             boolean isVar,
             @NotNull SourceElement source
     ) {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/CustomRendering.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/CustomRendering.kt
index 5533f03cd76..013e07aa2e2 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/renderer/CustomRendering.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/CustomRendering.kt
@@ -17,10 +17,10 @@
 package org.jetbrains.kotlin.renderer
 
 import org.jetbrains.kotlin.types.Flexibility
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeCapability
 
 public interface CustomFlexibleRendering : TypeCapability {
-    public fun renderInflexible(type: JetType, renderer: DescriptorRenderer): String?
+    public fun renderInflexible(type: KtType, renderer: DescriptorRenderer): String?
     public fun renderBounds(flexibility: Flexibility, renderer: DescriptorRenderer): Pair<String, String>?
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt
index 084d9955983..2b84bfbd96b 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.FqNameBase
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeConstructor
 import org.jetbrains.kotlin.types.TypeProjection
 
@@ -34,7 +34,7 @@ public abstract class DescriptorRenderer : Renderer<DeclarationDescriptor> {
         return DescriptorRendererImpl(options)
     }
 
-    public abstract fun renderType(type: JetType): String
+    public abstract fun renderType(type: KtType): String
 
     public abstract fun renderTypeArguments(typeArguments: List<TypeProjection>): String
 
@@ -184,7 +184,7 @@ public interface DescriptorRendererOptions {
     public var receiverAfterName: Boolean
     public var renderCompanionObjectName: Boolean
     public var withoutSuperTypes: Boolean
-    public var typeNormalizer: (JetType) -> JetType
+    public var typeNormalizer: (KtType) -> KtType
     public var renderDefaultValues: Boolean
     public var flexibleTypesForCode: Boolean
     public var secondaryConstructorsAsPrimary: Boolean
diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt
index 29a2a2d6711..b63460dcca5 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt
@@ -146,11 +146,11 @@ internal class DescriptorRendererImpl(
     }
 
     /* TYPES RENDERING */
-    override fun renderType(type: JetType): String {
+    override fun renderType(type: KtType): String {
         return renderNormalizedType(typeNormalizer(type))
     }
 
-    private fun renderNormalizedType(type: JetType): String {
+    private fun renderNormalizedType(type: KtType): String {
         if (type is LazyType && debugMode) {
             return type.toString()
         }
@@ -172,13 +172,13 @@ internal class DescriptorRendererImpl(
         return renderInflexibleType(type)
     }
 
-    private fun renderFlexibleTypeWithBothBounds(lower: JetType, upper: JetType): String {
+    private fun renderFlexibleTypeWithBothBounds(lower: KtType, upper: KtType): String {
         return renderFlexibleTypeWithBothBounds(renderNormalizedType(lower), renderNormalizedType(upper))
     }
 
     private fun renderFlexibleTypeWithBothBounds(lower: String, upper: String) = "($lower..$upper)"
 
-    private fun renderInflexibleType(type: JetType): String {
+    private fun renderInflexibleType(type: KtType): String {
         assert(!type.isFlexible()) { "Flexible types not allowed here: " + renderNormalizedType(type) }
 
         val customResult = type.getCapability<CustomFlexibleRendering>()?.renderInflexible(type, this)
@@ -202,12 +202,12 @@ internal class DescriptorRendererImpl(
         return renderDefaultType(type)
     }
 
-    private fun shouldRenderAsPrettyFunctionType(type: JetType): Boolean {
+    private fun shouldRenderAsPrettyFunctionType(type: KtType): Boolean {
         return prettyFunctionTypes && KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(type)
                && type.getArguments().none { it.isStarProjection() }
     }
 
-    private fun renderFlexibleType(type: JetType): String {
+    private fun renderFlexibleType(type: KtType): String {
         val lower = type.flexibility().lowerBound
         val upper = type.flexibility().upperBound
 
@@ -246,7 +246,7 @@ internal class DescriptorRendererImpl(
         }.toString()
     }
 
-    private fun renderDefaultType(type: JetType): String {
+    private fun renderDefaultType(type: KtType): String {
         val sb = StringBuilder()
 
         renderAnnotations(type, sb, /* needBrackets = */ true)
@@ -290,7 +290,7 @@ internal class DescriptorRendererImpl(
         }.joinTo(builder, ", ")
     }
 
-    private fun renderFunctionType(type: JetType): String {
+    private fun renderFunctionType(type: KtType): String {
         return StringBuilder {
             val isNullable = type.isMarkedNullable()
             if (isNullable) append("(")
@@ -338,7 +338,7 @@ internal class DescriptorRendererImpl(
     private fun renderAnnotations(annotated: Annotated, builder: StringBuilder, needBrackets: Boolean = false) {
         if (DescriptorRendererModifier.ANNOTATIONS !in modifiers) return
 
-        val excluded = if (annotated is JetType) excludedTypeAnnotationClasses else excludedAnnotationClasses
+        val excluded = if (annotated is KtType) excludedTypeAnnotationClasses else excludedAnnotationClasses
 
         val annotationsBuilder = StringBuilder {
             // Sort is needed just to fix some order when annotations resolved from modifiers
diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererOptionsImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererOptionsImpl.kt
index 0c66f846c4a..332f47c2830 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererOptionsImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererOptionsImpl.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.renderer
 
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.lang.reflect.Modifier
 import kotlin.properties.Delegates
 import kotlin.properties.ObservableProperty
@@ -92,7 +92,7 @@ internal class DescriptorRendererOptionsImpl : DescriptorRendererOptions {
     override var includePropertyConstant by property(false)
     override var withoutTypeParameters by property(false)
     override var withoutSuperTypes by property(false)
-    override var typeNormalizer by property<(JetType) -> JetType>({ it })
+    override var typeNormalizer by property<(KtType) -> KtType>({ it })
     override var renderDefaultValues by property(true)
     override var flexibleTypesForCode by property(false)
     override var secondaryConstructorsAsPrimary by property(true)
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java
index ee921721db9..f9e0f049372 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationsImpl;
 import org.jetbrains.kotlin.descriptors.impl.*;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExtensionReceiver;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.Variance;
 
 import java.util.Collections;
@@ -141,13 +141,13 @@ public class DescriptorFactory {
                         /* lateInit = */ false, /* isConst = */ false
                 );
 
-        JetType type = getBuiltIns(enumClass).getArrayType(Variance.INVARIANT, enumClass.getDefaultType());
+        KtType type = getBuiltIns(enumClass).getArrayType(Variance.INVARIANT, enumClass.getDefaultType());
 
         PropertyGetterDescriptorImpl getter = createDefaultGetter(values, Annotations.Companion.getEMPTY());
 
         values.initialize(getter, null);
         getter.initialize(type);
-        values.setType(type, Collections.<TypeParameterDescriptor>emptyList(), null, (JetType) null);
+        values.setType(type, Collections.<TypeParameterDescriptor>emptyList(), null, (KtType) null);
 
         return values;
     }
@@ -173,7 +173,7 @@ public class DescriptorFactory {
     @Nullable
     public static ReceiverParameterDescriptor createExtensionReceiverParameterForCallable(
             @NotNull CallableDescriptor owner,
-            @Nullable JetType receiverParameterType
+            @Nullable KtType receiverParameterType
     ) {
         return receiverParameterType == null
                ? null
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java
index 44bf4db53cb..ea0d77b633d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java
@@ -36,12 +36,12 @@ import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.StringValue;
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.kotlin.resolve.scopes.FilteringScope;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.LazyType;
 import org.jetbrains.kotlin.types.TypeConstructor;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.*;
 
@@ -244,7 +244,7 @@ public class DescriptorUtils {
     }
 
     public static boolean isDirectSubclass(@NotNull ClassDescriptor subClass, @NotNull ClassDescriptor superClass) {
-        for (JetType superType : subClass.getTypeConstructor().getSupertypes()) {
+        for (KtType superType : subClass.getTypeConstructor().getSupertypes()) {
             if (isSameClass(superType, superClass.getOriginal())) {
                 return true;
             }
@@ -256,7 +256,7 @@ public class DescriptorUtils {
         return isSubtypeOfClass(subClass.getDefaultType(), superClass.getOriginal());
     }
 
-    private static boolean isSameClass(@NotNull JetType type, @NotNull DeclarationDescriptor other) {
+    private static boolean isSameClass(@NotNull KtType type, @NotNull DeclarationDescriptor other) {
         DeclarationDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
         if (descriptor != null) {
             DeclarationDescriptor originalDescriptor = descriptor.getOriginal();
@@ -270,9 +270,9 @@ public class DescriptorUtils {
         return false;
     }
 
-    private static boolean isSubtypeOfClass(@NotNull JetType type, @NotNull DeclarationDescriptor superClass) {
+    private static boolean isSubtypeOfClass(@NotNull KtType type, @NotNull DeclarationDescriptor superClass) {
         if (isSameClass(type, superClass)) return true;
-        for (JetType superType : type.getConstructor().getSupertypes()) {
+        for (KtType superType : type.getConstructor().getSupertypes()) {
             if (isSubtypeOfClass(superType, superClass)) {
                 return true;
             }
@@ -349,9 +349,9 @@ public class DescriptorUtils {
 
     @NotNull
     public static List<ClassDescriptor> getSuperclassDescriptors(@NotNull ClassDescriptor classDescriptor) {
-        Collection<JetType> superclassTypes = classDescriptor.getTypeConstructor().getSupertypes();
+        Collection<KtType> superclassTypes = classDescriptor.getTypeConstructor().getSupertypes();
         List<ClassDescriptor> superClassDescriptors = new ArrayList<ClassDescriptor>();
-        for (JetType type : superclassTypes) {
+        for (KtType type : superclassTypes) {
             ClassDescriptor result = getClassDescriptorForType(type);
             if (!isAny(result)) {
                 superClassDescriptors.add(result);
@@ -361,9 +361,9 @@ public class DescriptorUtils {
     }
 
     @NotNull
-    public static JetType getSuperClassType(@NotNull ClassDescriptor classDescriptor) {
-        Collection<JetType> superclassTypes = classDescriptor.getTypeConstructor().getSupertypes();
-        for (JetType type : superclassTypes) {
+    public static KtType getSuperClassType(@NotNull ClassDescriptor classDescriptor) {
+        Collection<KtType> superclassTypes = classDescriptor.getTypeConstructor().getSupertypes();
+        for (KtType type : superclassTypes) {
             ClassDescriptor superClassDescriptor = getClassDescriptorForType(type);
             if (superClassDescriptor.getKind() != ClassKind.INTERFACE) {
                 return type;
@@ -374,8 +374,8 @@ public class DescriptorUtils {
 
     @Nullable
     public static ClassDescriptor getSuperClassDescriptor(@NotNull ClassDescriptor classDescriptor) {
-        Collection<JetType> superclassTypes = classDescriptor.getTypeConstructor().getSupertypes();
-        for (JetType type : superclassTypes) {
+        Collection<KtType> superclassTypes = classDescriptor.getTypeConstructor().getSupertypes();
+        for (KtType type : superclassTypes) {
             ClassDescriptor superClassDescriptor = getClassDescriptorForType(type);
             if (superClassDescriptor.getKind() != ClassKind.INTERFACE) {
                 return superClassDescriptor;
@@ -385,7 +385,7 @@ public class DescriptorUtils {
     }
 
     @NotNull
-    public static ClassDescriptor getClassDescriptorForType(@NotNull JetType type) {
+    public static ClassDescriptor getClassDescriptorForType(@NotNull KtType type) {
         return getClassDescriptorForTypeConstructor(type.getConstructor());
     }
 
@@ -422,7 +422,7 @@ public class DescriptorUtils {
     }
 
     @Nullable
-    public static JetType getReceiverParameterType(@Nullable ReceiverParameterDescriptor receiverParameterDescriptor) {
+    public static KtType getReceiverParameterType(@Nullable ReceiverParameterDescriptor receiverParameterDescriptor) {
         return receiverParameterDescriptor == null ? null : receiverParameterDescriptor.getType();
     }
 
@@ -437,8 +437,8 @@ public class DescriptorUtils {
     }
 
     @NotNull
-    public static JetScope getStaticNestedClassesScope(@NotNull ClassDescriptor descriptor) {
-        JetScope innerClassesScope = descriptor.getUnsubstitutedInnerClassesScope();
+    public static KtScope getStaticNestedClassesScope(@NotNull ClassDescriptor descriptor) {
+        KtScope innerClassesScope = descriptor.getUnsubstitutedInnerClassesScope();
         return new FilteringScope(innerClassesScope, new Function1<DeclarationDescriptor, Boolean>() {
             @Override
             public Boolean invoke(DeclarationDescriptor descriptor) {
@@ -474,16 +474,16 @@ public class DescriptorUtils {
         return descriptor;
     }
 
-    public static boolean shouldRecordInitializerForProperty(@NotNull VariableDescriptor variable, @NotNull JetType type) {
+    public static boolean shouldRecordInitializerForProperty(@NotNull VariableDescriptor variable, @NotNull KtType type) {
         if (variable.isVar() || type.isError()) return false;
 
         if (type instanceof LazyType || type.isMarkedNullable()) return true;
 
         KotlinBuiltIns builtIns = getBuiltIns(variable);
         return KotlinBuiltIns.isPrimitiveType(type) ||
-               JetTypeChecker.DEFAULT.equalTypes(builtIns.getStringType(), type) ||
-               JetTypeChecker.DEFAULT.equalTypes(builtIns.getNumber().getDefaultType(), type) ||
-               JetTypeChecker.DEFAULT.equalTypes(builtIns.getAnyType(), type);
+               KotlinTypeChecker.DEFAULT.equalTypes(builtIns.getStringType(), type) ||
+               KotlinTypeChecker.DEFAULT.equalTypes(builtIns.getNumber().getDefaultType(), type) ||
+               KotlinTypeChecker.DEFAULT.equalTypes(builtIns.getAnyType(), type);
     }
 
     public static boolean classCanHaveAbstractMembers(@NotNull ClassDescriptor classDescriptor) {
@@ -636,7 +636,7 @@ public class DescriptorUtils {
             result.add(fqName);
         }
 
-        for (DeclarationDescriptor descriptor : packageView.getMemberScope().getDescriptors(DescriptorKindFilter.PACKAGES, JetScope.Companion.getALL_NAME_FILTER())) {
+        for (DeclarationDescriptor descriptor : packageView.getMemberScope().getDescriptors(DescriptorKindFilter.PACKAGES, KtScope.Companion.getALL_NAME_FILTER())) {
             if (descriptor instanceof PackageViewDescriptor) {
                 getSubPackagesFqNames((PackageViewDescriptor) descriptor, result);
             }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt
index 5f31e67ea76..cc972d9197c 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.constants.EnumValue
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.DFS
 
 public fun ClassDescriptor.getClassObjectReferenceTarget(): ClassDescriptor = getCompanionObjectDescriptor() ?: this
@@ -74,7 +74,7 @@ public val ClassDescriptor.classId: ClassId
 public val ClassDescriptor.hasClassObjectType: Boolean get() = classObjectType != null
 
 /** If a literal of this class can be used as a value, returns the type of this value */
-public val ClassDescriptor.classObjectType: JetType?
+public val ClassDescriptor.classObjectType: KtType?
     get() {
         val correspondingDescriptor = when (this.getKind()) {
             OBJECT -> this
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java
index 140247347d5..aab13518a0e 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java
@@ -27,9 +27,9 @@ import org.jetbrains.kotlin.descriptors.impl.PropertyAccessorDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeConstructor;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.utils.DFS;
 
 import java.util.*;
@@ -44,7 +44,7 @@ public class OverridingUtil {
                     ExternalOverridabilityCondition.class.getClassLoader()
             ));
 
-    public static final OverridingUtil DEFAULT = new OverridingUtil(new JetTypeChecker.TypeConstructorEquality() {
+    public static final OverridingUtil DEFAULT = new OverridingUtil(new KotlinTypeChecker.TypeConstructorEquality() {
         @Override
         public boolean equals(@NotNull TypeConstructor a, @NotNull TypeConstructor b) {
             return a.equals(b);
@@ -52,13 +52,13 @@ public class OverridingUtil {
     });
 
     @NotNull
-    public static OverridingUtil createWithEqualityAxioms(@NotNull JetTypeChecker.TypeConstructorEquality equalityAxioms) {
+    public static OverridingUtil createWithEqualityAxioms(@NotNull KotlinTypeChecker.TypeConstructorEquality equalityAxioms) {
         return new OverridingUtil(equalityAxioms);
     }
 
-    private final JetTypeChecker.TypeConstructorEquality equalityAxioms;
+    private final KotlinTypeChecker.TypeConstructorEquality equalityAxioms;
 
-    private OverridingUtil(JetTypeChecker.TypeConstructorEquality axioms) {
+    private OverridingUtil(KotlinTypeChecker.TypeConstructorEquality axioms) {
         equalityAxioms = axioms;
     }
 
@@ -98,18 +98,18 @@ public class OverridingUtil {
             return receiverAndParameterResult;
         }
 
-        List<JetType> superValueParameters = compiledValueParameters(superDescriptor);
-        List<JetType> subValueParameters = compiledValueParameters(subDescriptor);
+        List<KtType> superValueParameters = compiledValueParameters(superDescriptor);
+        List<KtType> subValueParameters = compiledValueParameters(subDescriptor);
 
         List<TypeParameterDescriptor> superTypeParameters = superDescriptor.getTypeParameters();
         List<TypeParameterDescriptor> subTypeParameters = subDescriptor.getTypeParameters();
 
         if (superTypeParameters.size() != subTypeParameters.size()) {
             for (int i = 0; i < superValueParameters.size(); ++i) {
-                JetType superValueParameterType = getUpperBound(superValueParameters.get(i));
-                JetType subValueParameterType = getUpperBound(subValueParameters.get(i));
+                KtType superValueParameterType = getUpperBound(superValueParameters.get(i));
+                KtType subValueParameterType = getUpperBound(subValueParameters.get(i));
                 // TODO: compare erasure
-                if (!JetTypeChecker.DEFAULT.equalTypes(superValueParameterType, subValueParameterType)) {
+                if (!KotlinTypeChecker.DEFAULT.equalTypes(superValueParameterType, subValueParameterType)) {
                     return OverrideCompatibilityInfo.typeParameterNumberMismatch();
                 }
             }
@@ -123,7 +123,7 @@ public class OverridingUtil {
             matchingTypeConstructors.put(superTypeParameter.getTypeConstructor(), subTypeParameter.getTypeConstructor());
         }
 
-        JetTypeChecker.TypeConstructorEquality localEqualityAxioms = new JetTypeChecker.TypeConstructorEquality() {
+        KotlinTypeChecker.TypeConstructorEquality localEqualityAxioms = new KotlinTypeChecker.TypeConstructorEquality() {
             @Override
             public boolean equals(@NotNull TypeConstructor a, @NotNull TypeConstructor b) {
                 if (equalityAxioms.equals(a, b)) return true;
@@ -147,8 +147,8 @@ public class OverridingUtil {
         }
 
         for (int i = 0, unsubstitutedValueParametersSize = superValueParameters.size(); i < unsubstitutedValueParametersSize; i++) {
-            JetType superValueParameter = superValueParameters.get(i);
-            JetType subValueParameter = subValueParameters.get(i);
+            KtType superValueParameter = superValueParameters.get(i);
+            KtType subValueParameter = subValueParameters.get(i);
 
             if (!areTypesEquivalent(superValueParameter, subValueParameter, localEqualityAxioms)) {
                 return OverrideCompatibilityInfo.valueParameterTypeMismatch(superValueParameter, subValueParameter, INCOMPATIBLE);
@@ -156,12 +156,12 @@ public class OverridingUtil {
         }
 
         if (checkReturnType) {
-            JetType superReturnType = superDescriptor.getReturnType();
-            JetType subReturnType = subDescriptor.getReturnType();
+            KtType superReturnType = superDescriptor.getReturnType();
+            KtType subReturnType = subDescriptor.getReturnType();
 
             if (superReturnType != null && subReturnType != null) {
                 boolean bothErrors = subReturnType.isError() && superReturnType.isError();
-                if (!bothErrors && !JetTypeChecker.withAxioms(localEqualityAxioms).isSubtypeOf(subReturnType, superReturnType)) {
+                if (!bothErrors && !KotlinTypeChecker.withAxioms(localEqualityAxioms).isSubtypeOf(subReturnType, superReturnType)) {
                     return OverrideCompatibilityInfo.returnTypeMismatch(superReturnType, subReturnType);
                 }
             }
@@ -194,20 +194,20 @@ public class OverridingUtil {
     }
 
     private static boolean areTypesEquivalent(
-            @NotNull JetType typeInSuper,
-            @NotNull JetType typeInSub,
-            @NotNull JetTypeChecker.TypeConstructorEquality axioms
+            @NotNull KtType typeInSuper,
+            @NotNull KtType typeInSub,
+            @NotNull KotlinTypeChecker.TypeConstructorEquality axioms
     ) {
         boolean bothErrors = typeInSuper.isError() && typeInSub.isError();
-        if (!bothErrors && !JetTypeChecker.withAxioms(axioms).equalTypes(typeInSuper, typeInSub)) {
+        if (!bothErrors && !KotlinTypeChecker.withAxioms(axioms).equalTypes(typeInSuper, typeInSub)) {
             return false;
         }
         return true;
     }
 
-    static List<JetType> compiledValueParameters(CallableDescriptor callableDescriptor) {
+    static List<KtType> compiledValueParameters(CallableDescriptor callableDescriptor) {
         ReceiverParameterDescriptor receiverParameter = callableDescriptor.getExtensionReceiverParameter();
-        ArrayList<JetType> parameters = new ArrayList<JetType>();
+        ArrayList<KtType> parameters = new ArrayList<KtType>();
         if (receiverParameter != null) {
             parameters.add(receiverParameter.getType());
         }
@@ -217,7 +217,7 @@ public class OverridingUtil {
         return parameters;
     }
 
-    static JetType getUpperBound(JetType type) {
+    static KtType getUpperBound(KtType type) {
         if (type.getConstructor().getDeclarationDescriptor() instanceof ClassDescriptor) {
             return type;
         }
@@ -297,12 +297,12 @@ public class OverridingUtil {
         if (a instanceof SimpleFunctionDescriptor) {
             assert b instanceof SimpleFunctionDescriptor : "b is " + b.getClass();
 
-            JetType aReturnType = a.getReturnType();
+            KtType aReturnType = a.getReturnType();
             assert aReturnType != null;
-            JetType bReturnType = b.getReturnType();
+            KtType bReturnType = b.getReturnType();
             assert bReturnType != null;
 
-            return JetTypeChecker.DEFAULT.isSubtypeOf(aReturnType, bReturnType);
+            return KotlinTypeChecker.DEFAULT.isSubtypeOf(aReturnType, bReturnType);
         }
         if (a instanceof PropertyDescriptor) {
             assert b instanceof PropertyDescriptor : "b is " + b.getClass();
@@ -312,7 +312,7 @@ public class OverridingUtil {
             }
 
             // both vals
-            return JetTypeChecker.DEFAULT.isSubtypeOf(((PropertyDescriptor) a).getType(), ((PropertyDescriptor) b).getType());
+            return KotlinTypeChecker.DEFAULT.isSubtypeOf(((PropertyDescriptor) a).getType(), ((PropertyDescriptor) b).getType());
         }
         throw new IllegalArgumentException("Unexpected callable: " + a.getClass());
     }
@@ -569,7 +569,7 @@ public class OverridingUtil {
         }
 
         @NotNull
-        public static OverrideCompatibilityInfo valueParameterTypeMismatch(JetType superValueParameter, JetType subValueParameter, Result result) {
+        public static OverrideCompatibilityInfo valueParameterTypeMismatch(KtType superValueParameter, KtType subValueParameter, Result result) {
             return new OverrideCompatibilityInfo(result, "valueParameterTypeMismatch"); // TODO
         }
 
@@ -579,7 +579,7 @@ public class OverridingUtil {
         }
 
         @NotNull
-        public static OverrideCompatibilityInfo returnTypeMismatch(JetType substitutedSuperReturnType, JetType unsubstitutedSubReturnType) {
+        public static OverrideCompatibilityInfo returnTypeMismatch(KtType substitutedSuperReturnType, KtType unsubstitutedSubReturnType) {
             return new OverrideCompatibilityInfo(Result.CONFLICT, "returnTypeMismatch: " + unsubstitutedSubReturnType + " >< " + substitutedSuperReturnType); // TODO
         }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/annotationsForResolve.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/annotationsForResolve.kt
index 6cb14f27dc8..b8948cec71b 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/annotationsForResolve.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/annotationsForResolve.kt
@@ -19,15 +19,15 @@ package org.jetbrains.kotlin.resolve.descriptorUtil
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 private val NO_INFER_ANNOTATION_FQ_NAME = FqName("kotlin.internal.NoInfer")
 
-public fun JetType.hasNoInferAnnotation(): Boolean = annotations.hasAnnotation(NO_INFER_ANNOTATION_FQ_NAME)
+public fun KtType.hasNoInferAnnotation(): Boolean = annotations.hasAnnotation(NO_INFER_ANNOTATION_FQ_NAME)
 
 private val EXACT_ANNOTATION_FQ_NAME = FqName("kotlin.internal.Exact")
 
-public fun JetType.hasExactAnnotation(): Boolean = annotations.hasAnnotation(EXACT_ANNOTATION_FQ_NAME)
+public fun KtType.hasExactAnnotation(): Boolean = annotations.hasAnnotation(EXACT_ANNOTATION_FQ_NAME)
 
 private val LOW_PRIORITY_IN_OVERLOAD_RESOLUTION_FQ_NAME = FqName("kotlin.internal.LowPriorityInOverloadResolution")
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/CapturedTypeConstructor.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/CapturedTypeConstructor.kt
index d1360c40b05..c8e0d8fc1d7 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/CapturedTypeConstructor.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/CapturedTypeConstructor.kt
@@ -35,7 +35,7 @@ public class CapturedTypeConstructor(
 
     override fun getParameters(): List<TypeParameterDescriptor> = listOf()
 
-    override fun getSupertypes(): Collection<JetType> {
+    override fun getSupertypes(): Collection<KtType> {
         val superType = if (typeProjection.getProjectionKind() == Variance.OUT_VARIANCE)
             typeProjection.getType()
         else
@@ -63,10 +63,10 @@ public class CapturedType(
     private val delegateType = run {
         val scope = ErrorUtils.createErrorScope(
                 "No member resolution should be done on captured type, it used only during constraint system resolution", true)
-        JetTypeImpl.create(Annotations.EMPTY, CapturedTypeConstructor(typeProjection), false, listOf(), scope)
+        KtTypeImpl.create(Annotations.EMPTY, CapturedTypeConstructor(typeProjection), false, listOf(), scope)
     }
 
-    override fun getDelegate(): JetType = delegateType
+    override fun getDelegate(): KtType = delegateType
 
     override fun <T : TypeCapability> getCapability(capabilityClass: Class<T>): T? {
         @Suppress("UNCHECKED_CAST")
@@ -74,20 +74,20 @@ public class CapturedType(
         else super<DelegatingType>.getCapability(capabilityClass)
     }
 
-    override val subTypeRepresentative: JetType
+    override val subTypeRepresentative: KtType
         get() = representative(OUT_VARIANCE, builtIns.nullableAnyType)
 
-    override val superTypeRepresentative: JetType
+    override val superTypeRepresentative: KtType
         get() = representative(IN_VARIANCE, builtIns.nothingType)
 
-    private fun representative(variance: Variance, default: JetType) =
+    private fun representative(variance: Variance, default: KtType) =
         if (typeProjection.getProjectionKind() == variance) typeProjection.getType() else default
 
-    override fun sameTypeConstructor(type: JetType) = delegateType.getConstructor() === type.getConstructor()
+    override fun sameTypeConstructor(type: KtType) = delegateType.getConstructor() === type.getConstructor()
 
     override fun toString() = "Captured($typeProjection)"
 }
 
-public fun createCapturedType(typeProjection: TypeProjection): JetType = CapturedType(typeProjection)
+public fun createCapturedType(typeProjection: TypeProjection): KtType = CapturedType(typeProjection)
 
-public fun JetType.isCaptured(): Boolean = getConstructor() is CapturedTypeConstructor
+public fun KtType.isCaptured(): Boolean = getConstructor() is CapturedTypeConstructor
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystem.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystem.kt
index c0b917adf88..dea4ec15291 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystem.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystem.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve.calls.inference
 
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.types.Variance
 
@@ -47,7 +47,7 @@ public interface ConstraintSystem {
      * For example, for {@code "fun <T> id(t: T) {}"} to infer <tt>T</tt> in invocation <tt>"id(1)"</tt>
      * should be generated a constraint <tt>"Int is a subtype of T"</tt> where T is a subject type, and Int is a constraining type.
      */
-    public fun addSubtypeConstraint(constrainingType: JetType?, subjectType: JetType, constraintPosition: ConstraintPosition)
+    public fun addSubtypeConstraint(constrainingType: KtType?, subjectType: KtType, constraintPosition: ConstraintPosition)
 
     /**
      * Adds a constraint that the constraining type is a supertype of the subject type. <p/>
@@ -56,7 +56,7 @@ public interface ConstraintSystem {
      * For example, for {@code "fun <T> create() : T"} to infer <tt>T</tt> in invocation <tt>"val i: Int = create()"</tt>
      * should be generated a constraint <tt>"Int is a supertype of T"</tt> where T is a subject type, and Int is a constraining type.
      */
-    public fun addSupertypeConstraint(constrainingType: JetType?, subjectType: JetType, constraintPosition: ConstraintPosition)
+    public fun addSupertypeConstraint(constrainingType: KtType?, subjectType: KtType, constraintPosition: ConstraintPosition)
 
     public fun getStatus(): ConstraintSystemStatus
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt
index aeec7425cdb..a3ecc64d5c5 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt
@@ -32,10 +32,10 @@ import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.derivedFr
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasNoInferAnnotation
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasExactAnnotation
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasOnlyInputTypesAnnotation
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.TypeUtils.DONT_CARE
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure
 import org.jetbrains.kotlin.types.checker.TypeCheckingProcedureCallbacks
 import org.jetbrains.kotlin.types.typeUtil.builtIns
@@ -46,7 +46,7 @@ import java.util.*
 
 public class ConstraintSystemImpl : ConstraintSystem {
 
-    data class Constraint(val kind: ConstraintKind, val subtype: JetType, val superType: JetType, val position: ConstraintPosition)
+    data class Constraint(val kind: ConstraintKind, val subtype: KtType, val superType: KtType, val position: ConstraintPosition)
 
     public enum class ConstraintKind {
         SUB_TYPE,
@@ -61,7 +61,7 @@ public class ConstraintSystemImpl : ConstraintSystem {
         get() = if (externalTypeParameters.isEmpty()) allTypeParameterBounds
             else allTypeParameterBounds.filter { !externalTypeParameters.contains(it.key) }
 
-    private val cachedTypeForVariable = HashMap<TypeParameterDescriptor, JetType>()
+    private val cachedTypeForVariable = HashMap<TypeParameterDescriptor, KtType>()
 
     private val usedInBounds = HashMap<TypeParameterDescriptor, MutableList<TypeBounds.Bound>>()
 
@@ -165,16 +165,16 @@ public class ConstraintSystemImpl : ConstraintSystem {
         }
     }
 
-    val TypeParameterDescriptor.correspondingType: JetType
+    val TypeParameterDescriptor.correspondingType: KtType
         get() = cachedTypeForVariable.getOrPut(this) {
-            JetTypeImpl.create(Annotations.EMPTY, this.getTypeConstructor(), false, listOf(), JetScope.Empty)
+            KtTypeImpl.create(Annotations.EMPTY, this.getTypeConstructor(), false, listOf(), KtScope.Empty)
         }
 
-    fun JetType.isProper() = !TypeUtils.containsSpecialType(this) {
+    fun KtType.isProper() = !TypeUtils.containsSpecialType(this) {
         type -> type.getConstructor().getDeclarationDescriptor() in getAllTypeVariables()
     }
 
-    fun JetType.getNestedTypeVariables(original: Boolean = true): List<TypeParameterDescriptor> {
+    fun KtType.getNestedTypeVariables(original: Boolean = true): List<TypeParameterDescriptor> {
         return getNestedArguments().map { typeProjection ->
             typeProjection.getType().getConstructor().getDeclarationDescriptor() as? TypeParameterDescriptor
         }.filterNotNull().filter { if (original) it in originalToVariables.keySet() else it in getAllTypeVariables() }
@@ -206,22 +206,22 @@ public class ConstraintSystemImpl : ConstraintSystem {
         return newSystem
     }
 
-    override fun addSupertypeConstraint(constrainingType: JetType?, subjectType: JetType, constraintPosition: ConstraintPosition) {
+    override fun addSupertypeConstraint(constrainingType: KtType?, subjectType: KtType, constraintPosition: ConstraintPosition) {
         if (constrainingType != null && TypeUtils.noExpectedType(constrainingType)) return
 
         val newSubjectType = originalToVariablesSubstitutor.substitute(subjectType, Variance.INVARIANT)
         addConstraint(SUB_TYPE, newSubjectType, constrainingType, ConstraintContext(constraintPosition, initial = true))
     }
 
-    override fun addSubtypeConstraint(constrainingType: JetType?, subjectType: JetType, constraintPosition: ConstraintPosition) {
+    override fun addSubtypeConstraint(constrainingType: KtType?, subjectType: KtType, constraintPosition: ConstraintPosition) {
         val newSubjectType = originalToVariablesSubstitutor.substitute(subjectType, Variance.INVARIANT)
         addConstraint(SUB_TYPE, constrainingType, newSubjectType, ConstraintContext(constraintPosition, initial = true))
     }
 
     fun addConstraint(
             constraintKind: ConstraintKind,
-            subType: JetType?,
-            superType: JetType?,
+            subType: KtType?,
+            superType: KtType?,
             constraintContext: ConstraintContext
     ) {
         val constraintPosition = constraintContext.position
@@ -231,7 +231,7 @@ public class ConstraintSystemImpl : ConstraintSystem {
         val typeCheckingProcedure = TypeCheckingProcedure(object : TypeCheckingProcedureCallbacks {
             private var depth = 0
 
-            override fun assertEqualTypes(a: JetType, b: JetType, typeCheckingProcedure: TypeCheckingProcedure): Boolean {
+            override fun assertEqualTypes(a: KtType, b: KtType, typeCheckingProcedure: TypeCheckingProcedure): Boolean {
                 depth++
                 doAddConstraint(EQUAL, a, b, newConstraintContext, typeCheckingProcedure)
                 depth--
@@ -243,14 +243,14 @@ public class ConstraintSystemImpl : ConstraintSystem {
                 return a == b
             }
 
-            override fun assertSubtype(subtype: JetType, supertype: JetType, typeCheckingProcedure: TypeCheckingProcedure): Boolean {
+            override fun assertSubtype(subtype: KtType, supertype: KtType, typeCheckingProcedure: TypeCheckingProcedure): Boolean {
                 depth++
                 doAddConstraint(SUB_TYPE, subtype, supertype, newConstraintContext, typeCheckingProcedure)
                 depth--
                 return true
             }
 
-            override fun capture(typeVariable: JetType, typeProjection: TypeProjection): Boolean {
+            override fun capture(typeVariable: KtType, typeProjection: TypeProjection): Boolean {
                 if (isMyTypeVariable(typeProjection.getType())) return false
                 val myTypeVariable = getMyTypeVariable(typeVariable)
 
@@ -264,7 +264,7 @@ public class ConstraintSystemImpl : ConstraintSystem {
                 return false
             }
 
-            override fun noCorrespondingSupertype(subtype: JetType, supertype: JetType): Boolean {
+            override fun noCorrespondingSupertype(subtype: KtType, supertype: KtType): Boolean {
                 errors.add(newTypeInferenceOrParameterConstraintError(constraintPosition))
                 return true
             }
@@ -272,7 +272,7 @@ public class ConstraintSystemImpl : ConstraintSystem {
         doAddConstraint(constraintKind, subType, superType, constraintContext, typeCheckingProcedure)
     }
 
-    private fun isErrorOrSpecialType(type: JetType?, constraintPosition: ConstraintPosition): Boolean {
+    private fun isErrorOrSpecialType(type: KtType?, constraintPosition: ConstraintPosition): Boolean {
         if (TypeUtils.isDontCarePlaceholder(type) || ErrorUtils.isUninferredParameter(type)) {
             return true
         }
@@ -286,8 +286,8 @@ public class ConstraintSystemImpl : ConstraintSystem {
 
     private fun doAddConstraint(
             constraintKind: ConstraintKind,
-            subType: JetType?,
-            superType: JetType?,
+            subType: KtType?,
+            superType: KtType?,
             constraintContext: ConstraintContext,
             typeCheckingProcedure: TypeCheckingProcedure
     ) {
@@ -317,7 +317,7 @@ public class ConstraintSystemImpl : ConstraintSystem {
             subType
         }
 
-        fun simplifyConstraint(subType: JetType, superType: JetType) {
+        fun simplifyConstraint(subType: KtType, superType: KtType) {
             if (isMyTypeVariable(subType)) {
                 generateTypeParameterBound(subType, superType, constraintKind.toBound(), constraintContext)
                 return
@@ -348,7 +348,7 @@ public class ConstraintSystemImpl : ConstraintSystem {
 
     fun addBound(
             typeVariable: TypeParameterDescriptor,
-            constrainingType: JetType,
+            constrainingType: KtType,
             kind: TypeBounds.BoundKind,
             constraintContext: ConstraintContext
     ) {
@@ -370,8 +370,8 @@ public class ConstraintSystemImpl : ConstraintSystem {
     }
 
     private fun generateTypeParameterBound(
-            parameterType: JetType,
-            constrainingType: JetType,
+            parameterType: KtType,
+            constrainingType: KtType,
             boundKind: TypeBounds.BoundKind,
             constraintContext: ConstraintContext
     ) {
@@ -414,7 +414,7 @@ public class ConstraintSystemImpl : ConstraintSystem {
     }
 
     private fun generateTypeParameterCaptureConstraint(
-            parameterType: JetType,
+            parameterType: KtType,
             constrainingTypeProjection: TypeProjection,
             constraintContext: ConstraintContext
     ) {
@@ -452,9 +452,9 @@ public class ConstraintSystemImpl : ConstraintSystem {
 
     fun isMyTypeVariable(typeVariable: TypeParameterDescriptor) = allTypeParameterBounds.contains(typeVariable)
 
-    fun isMyTypeVariable(type: JetType): Boolean = getMyTypeVariable(type) != null
+    fun isMyTypeVariable(type: KtType): Boolean = getMyTypeVariable(type) != null
 
-    fun getMyTypeVariable(type: JetType): TypeParameterDescriptor? {
+    fun getMyTypeVariable(type: KtType): TypeParameterDescriptor? {
         val typeParameterDescriptor = type.getConstructor().getDeclarationDescriptor() as? TypeParameterDescriptor
         return if (typeParameterDescriptor != null && isMyTypeVariable(typeParameterDescriptor)) typeParameterDescriptor else null
     }
@@ -471,12 +471,12 @@ public class ConstraintSystemImpl : ConstraintSystem {
     private fun getSubstitutor(substituteOriginal: Boolean, getDefaultValue: (TypeParameterDescriptor) -> TypeProjection) =
             replaceUninferredBy(getDefaultValue, substituteOriginal).setApproximateCapturedTypes()
 
-    private fun storeInitialConstraint(constraintKind: ConstraintKind, subType: JetType, superType: JetType, position: ConstraintPosition) {
+    private fun storeInitialConstraint(constraintKind: ConstraintKind, subType: KtType, superType: KtType, position: ConstraintPosition) {
         initialConstraints.add(Constraint(constraintKind, subType, superType, position))
     }
 
     private fun satisfyInitialConstraints(): Boolean {
-        fun JetType.substitute(): JetType? {
+        fun KtType.substitute(): KtType? {
             val substitutor = getSubstitutor(substituteOriginal = false) { TypeProjectionImpl(ErrorUtils.createUninferredParameterType(it)) }
             return substitutor.substitute(this, Variance.INVARIANT) ?: return null
         }
@@ -489,8 +489,8 @@ public class ConstraintSystemImpl : ConstraintSystem {
             } ?: return false
             val resultSuperType = constraint.superType.substitute() ?: return false
             when (constraint.kind) {
-                SUB_TYPE -> JetTypeChecker.DEFAULT.isSubtypeOf(resultSubType, resultSuperType)
-                EQUAL -> JetTypeChecker.DEFAULT.equalTypes(resultSubType, resultSuperType)
+                SUB_TYPE -> KotlinTypeChecker.DEFAULT.isSubtypeOf(resultSubType, resultSuperType)
+                EQUAL -> KotlinTypeChecker.DEFAULT.equalTypes(resultSubType, resultSuperType)
             }
         }
     }
@@ -518,9 +518,9 @@ public class ConstraintSystemImpl : ConstraintSystem {
 }
 
 fun createTypeForFunctionPlaceholder(
-        functionPlaceholder: JetType,
-        expectedType: JetType
-): JetType {
+        functionPlaceholder: KtType,
+        expectedType: KtType
+): KtType {
     if (!functionPlaceholder.isFunctionPlaceholder) return functionPlaceholder
 
     val functionPlaceholderTypeConstructor = functionPlaceholder.getConstructor() as FunctionPlaceholderTypeConstructor
@@ -531,7 +531,7 @@ fun createTypeForFunctionPlaceholder(
         // the first parameter is receiver (if present), the last one is return type,
         // the remaining are function arguments
         val functionArgumentsSize = if (isExtension) typeParamSize - 2 else typeParamSize - 1
-        val result = arrayListOf<JetType>()
+        val result = arrayListOf<KtType>()
         (1..functionArgumentsSize).forEach { result.add(DONT_CARE) }
         result
     }
@@ -547,7 +547,7 @@ private fun TypeSubstitutor.setApproximateCapturedTypes(): TypeSubstitutor {
 }
 
 private class SubstitutionWithCapturedTypeApproximation(val substitution: TypeSubstitution) : TypeSubstitution() {
-    override fun get(key: JetType) = substitution[key]
+    override fun get(key: KtType) = substitution[key]
     override fun isEmpty() = substitution.isEmpty()
     override fun approximateCapturedTypes() = true
 }
@@ -570,7 +570,7 @@ public fun createTypeSubstitutor(conversion: (TypeParameterDescriptor) -> TypePa
             if (descriptor !is TypeParameterDescriptor) return null
             val typeParameterDescriptor = conversion(descriptor) ?: return null
 
-            val type = JetTypeImpl.create(Annotations.EMPTY, typeParameterDescriptor.getTypeConstructor(), false, listOf(), JetScope.Empty)
+            val type = KtTypeImpl.create(Annotations.EMPTY, typeParameterDescriptor.getTypeConstructor(), false, listOf(), KtScope.Empty)
             return TypeProjectionImpl(type)
         }
     })
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBounds.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBounds.kt
index 4b4963a6eb5..cb7b1bbcd00 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBounds.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBounds.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.EXACT_B
 import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.LOWER_BOUND
 import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.UPPER_BOUND
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.Variance
 
 public interface TypeBounds {
@@ -32,10 +32,10 @@ public interface TypeBounds {
 
     public val bounds: Collection<Bound>
 
-    public val value: JetType?
+    public val value: KtType?
         get() = if (values.size() == 1) values.first() else null
 
-    public val values: Collection<JetType>
+    public val values: Collection<KtType>
 
     public enum class BoundKind {
         LOWER_BOUND,
@@ -45,7 +45,7 @@ public interface TypeBounds {
 
     public class Bound(
             public val typeVariable: TypeParameterDescriptor,
-            public val constrainingType: JetType,
+            public val constrainingType: KtType,
             public val kind: BoundKind,
             public val position: ConstraintPosition,
             public val isProper: Boolean,
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBoundsImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBoundsImpl.kt
index 48331ae483b..f92f9075f7b 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBoundsImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBoundsImpl.kt
@@ -19,14 +19,12 @@ package org.jetbrains.kotlin.resolve.calls.inference
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.Bound
 import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind
-import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.EXACT_BOUND
-import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.LOWER_BOUND
-import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.UPPER_BOUND
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.*
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
 import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstructor
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasOnlyInputTypesAnnotation
 import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.*
 
@@ -36,7 +34,7 @@ public class TypeBoundsImpl(
 ) : TypeBounds {
     override val bounds = ArrayList<Bound>()
 
-    private var resultValues: Collection<JetType>? = null
+    private var resultValues: Collection<KtType>? = null
 
     var isFixed: Boolean = false
         private set
@@ -53,12 +51,12 @@ public class TypeBoundsImpl(
         bounds.add(bound)
     }
 
-    private fun filterBounds(bounds: Collection<Bound>, kind: BoundKind): Set<JetType> {
+    private fun filterBounds(bounds: Collection<Bound>, kind: BoundKind): Set<KtType> {
         return filterBounds(bounds, kind, null)
     }
 
-    private fun filterBounds(bounds: Collection<Bound>, kind: BoundKind, errorValues: MutableCollection<JetType>?): Set<JetType> {
-        val result = LinkedHashSet<JetType>()
+    private fun filterBounds(bounds: Collection<Bound>, kind: BoundKind, errorValues: MutableCollection<KtType>?): Set<KtType> {
+        val result = LinkedHashSet<KtType>()
         for (bound in bounds) {
             if (bound.kind == kind) {
                 if (!ErrorUtils.containsErrorType(bound.constrainingType)) {
@@ -78,7 +76,7 @@ public class TypeBoundsImpl(
         return result
     }
 
-    override val values: Collection<JetType>
+    override val values: Collection<KtType>
         get() {
             if (resultValues == null) {
                 resultValues = computeValues()
@@ -86,8 +84,8 @@ public class TypeBoundsImpl(
             return resultValues!!
         }
 
-    private fun computeValues(): Collection<JetType> {
-        val values = LinkedHashSet<JetType>()
+    private fun computeValues(): Collection<KtType> {
+        val values = LinkedHashSet<KtType>()
         val bounds = bounds.filter { it.isProper }
 
         if (bounds.isEmpty()) {
@@ -135,7 +133,7 @@ public class TypeBoundsImpl(
 
         val upperBounds = filterBounds(bounds, TypeBounds.BoundKind.UPPER_BOUND, values)
         if (upperBounds.isNotEmpty()) {
-            val intersectionOfUpperBounds = TypeIntersector.intersectTypes(JetTypeChecker.DEFAULT, upperBounds)
+            val intersectionOfUpperBounds = TypeIntersector.intersectTypes(KotlinTypeChecker.DEFAULT, upperBounds)
             if (intersectionOfUpperBounds != null && tryPossibleAnswer(bounds, intersectionOfUpperBounds)) {
                 return setOf(intersectionOfUpperBounds)
             }
@@ -148,7 +146,7 @@ public class TypeBoundsImpl(
         return values
     }
 
-    private fun tryPossibleAnswer(bounds: Collection<Bound>, possibleAnswer: JetType?): Boolean {
+    private fun tryPossibleAnswer(bounds: Collection<Bound>, possibleAnswer: KtType?): Boolean {
         if (possibleAnswer == null) return false
         // a captured type might be an answer
         if (!possibleAnswer.getConstructor().isDenotable() && !possibleAnswer.isCaptured()) return false
@@ -160,15 +158,15 @@ public class TypeBoundsImpl(
 
         for (bound in bounds) {
             when (bound.kind) {
-                LOWER_BOUND -> if (!JetTypeChecker.DEFAULT.isSubtypeOf(bound.constrainingType, possibleAnswer)) {
+                LOWER_BOUND -> if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(bound.constrainingType, possibleAnswer)) {
                     return false
                 }
 
-                UPPER_BOUND -> if (!JetTypeChecker.DEFAULT.isSubtypeOf(possibleAnswer, bound.constrainingType)) {
+                UPPER_BOUND -> if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(possibleAnswer, bound.constrainingType)) {
                     return false
                 }
 
-                EXACT_BOUND -> if (!JetTypeChecker.DEFAULT.equalTypes(bound.constrainingType, possibleAnswer)) {
+                EXACT_BOUND -> if (!KotlinTypeChecker.DEFAULT.equalTypes(bound.constrainingType, possibleAnswer)) {
                     return false
                 }
             }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/constraintIncorporation.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/constraintIncorporation.kt
index e03c1242f97..418dac7c815 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/constraintIncorporation.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/constraintIncorporation.kt
@@ -96,7 +96,7 @@ private fun ConstraintSystemImpl.generateNewBound(bound: Bound, substitution: Bo
 
     val position = CompoundConstraintPosition(bound.position, substitution.position)
 
-    fun addNewBound(newConstrainingType: JetType, newBoundKind: BoundKind) {
+    fun addNewBound(newConstrainingType: KtType, newBoundKind: BoundKind) {
         // We don't generate new recursive constraints
         val nestedTypeVariables = newConstrainingType.getNestedTypeVariables(original = false)
         if (nestedTypeVariables.contains(bound.typeVariable)) return
@@ -117,7 +117,7 @@ private fun ConstraintSystemImpl.generateNewBound(bound: Bound, substitution: Bo
     // todo
     // if we allow non-trivial type projections, we bump into errors like
     // "Empty intersection for types [MutableCollection<in ('Int'..'Int?')>, MutableCollection<out Any?>, MutableCollection<in Int>]"
-    fun JetType.containsConstrainingTypeWithoutProjection() = this.getNestedArguments().any {
+    fun KtType.containsConstrainingTypeWithoutProjection() = this.getNestedArguments().any {
         it.getType().getConstructor() == substitution.constrainingType.getConstructor() && it.getProjectionKind() == Variance.INVARIANT
     }
     if (approximationBounds.upper.containsConstrainingTypeWithoutProjection() && bound.kind != LOWER_BOUND) {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt
index eef3728ddda..605d641aaa7 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt
@@ -26,9 +26,9 @@ public interface CompileTimeConstant<out T> {
 
     public val parameters: CompileTimeConstant.Parameters
 
-    public fun toConstantValue(expectedType: JetType): ConstantValue<T>
+    public fun toConstantValue(expectedType: KtType): ConstantValue<T>
 
-    public fun getValue(expectedType: JetType): T = toConstantValue(expectedType).value
+    public fun getValue(expectedType: KtType): T = toConstantValue(expectedType).value
 
     public val canBeUsedInAnnotations: Boolean get() = parameters.canBeUsedInAnnotation
 
@@ -53,9 +53,9 @@ public class TypedCompileTimeConstant<out T>(
     override val isError: Boolean
         get() = constantValue is ErrorValue
 
-    public val type: JetType = constantValue.type
+    public val type: KtType = constantValue.type
 
-    override fun toConstantValue(expectedType: JetType): ConstantValue<T> = constantValue
+    override fun toConstantValue(expectedType: KtType): ConstantValue<T> = constantValue
 }
 
 public class IntegerValueTypeConstant(
@@ -65,7 +65,7 @@ public class IntegerValueTypeConstant(
 ) : CompileTimeConstant<Number> {
     private val typeConstructor = IntegerValueTypeConstructor(value.toLong(), builtIns)
 
-    override fun toConstantValue(expectedType: JetType): ConstantValue<Number> {
+    override fun toConstantValue(expectedType: KtType): ConstantValue<Number> {
         val factory = ConstantValueFactory(builtIns)
         val type = getType(expectedType)
         return when {
@@ -84,12 +84,12 @@ public class IntegerValueTypeConstant(
         }
     }
 
-    val unknownIntegerType = JetTypeImpl.create(
+    val unknownIntegerType = KtTypeImpl.create(
             Annotations.EMPTY, typeConstructor, false, emptyList<TypeProjection>(),
             ErrorUtils.createErrorScope("Scope for number value type (" + typeConstructor.toString() + ")", true)
     )
 
-    public fun getType(expectedType: JetType): JetType = TypeUtils.getPrimitiveNumberType(typeConstructor, expectedType)
+    public fun getType(expectedType: KtType): KtType = TypeUtils.getPrimitiveNumberType(typeConstructor, expectedType)
 
     override fun toString() = typeConstructor.toString()
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantValueFactory.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantValueFactory.kt
index 6fab30172fb..be7cb53e689 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantValueFactory.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantValueFactory.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve.constants
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 
 public class ConstantValueFactory(
@@ -51,12 +51,12 @@ public class ConstantValueFactory(
 
     fun createArrayValue(
             value: List<ConstantValue<*>>,
-            type: JetType
+            type: KtType
     ) = ArrayValue(value, type, builtins)
 
     fun createAnnotationValue(value: AnnotationDescriptor) = AnnotationValue(value)
 
-    fun createKClassValue(type: JetType) = KClassValue(type)
+    fun createKClassValue(type: KtType) = KClassValue(type)
 
     fun createConstantValue(
             value: Any?
@@ -79,7 +79,7 @@ public class ConstantValueFactory(
 
     public fun createIntegerConstantValue(
             value: Long,
-            expectedType: JetType
+            expectedType: KtType
     ): ConstantValue<*>? {
         val notNullExpected = TypeUtils.makeNotNullable(expectedType)
         return when {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstructor.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstructor.kt
index 56f58b81682..1454ce8ef49 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstructor.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstructor.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve.constants
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeConstructor
 import java.util.*
 
@@ -27,7 +27,7 @@ public class IntegerValueTypeConstructor(
         private val value: Long,
         private val builtIns: KotlinBuiltIns
 ) : TypeConstructor {
-    private val supertypes = ArrayList<JetType>(4)
+    private val supertypes = ArrayList<KtType>(4)
 
     init {
         // order of types matters
@@ -39,13 +39,13 @@ public class IntegerValueTypeConstructor(
         supertypes.add(builtIns.getLongType())
     }
 
-    private fun checkBoundsAndAddSuperType(value: Long, minValue: Long, maxValue: Long, kotlinType: JetType) {
+    private fun checkBoundsAndAddSuperType(value: Long, minValue: Long, maxValue: Long, kotlinType: KtType) {
         if (value >= minValue && value <= maxValue) {
             supertypes.add(kotlinType)
         }
     }
 
-    override fun getSupertypes(): Collection<JetType> = supertypes
+    override fun getSupertypes(): Collection<KtType> = supertypes
 
     override fun getParameters(): List<TypeParameterDescriptor> = emptyList()
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/constantValues.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/constantValues.kt
index c091697f707..cac4640e388 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/constantValues.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/constantValues.kt
@@ -22,11 +22,11 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.resolve.descriptorUtil.classObjectType
 import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.sure
 
 public abstract class ConstantValue<out T>(public open val value: T) {
-    public abstract val type: JetType
+    public abstract val type: KtType
 
     public abstract fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R
 
@@ -37,7 +37,7 @@ public abstract class IntegerValueConstant<T> protected constructor(value: T) :
 
 public class AnnotationValue(value: AnnotationDescriptor) : ConstantValue<AnnotationDescriptor>(value) {
 
-    override val type: JetType
+    override val type: KtType
         get() = value.getType()
 
     override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitAnnotationValue(this, data)
@@ -46,7 +46,7 @@ public class AnnotationValue(value: AnnotationDescriptor) : ConstantValue<Annota
 
 public class ArrayValue(
         value: List<ConstantValue<*>>,
-        override val type: JetType,
+        override val type: KtType,
         private val builtIns: KotlinBuiltIns
 ) : ConstantValue<List<ConstantValue<*>>>(value) {
 
@@ -56,7 +56,7 @@ public class ArrayValue(
 
     override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitArrayValue(this, data)
 
-    public val elementType: JetType
+    public val elementType: KtType
         get() = builtIns.getArrayElementType(type)
 
     override fun equals(other: Any?): Boolean {
@@ -140,7 +140,7 @@ public class EnumValue(
         value: ClassDescriptor
 ) : ConstantValue<ClassDescriptor>(value) {
 
-    override val type: JetType
+    override val type: KtType
         get() = value.classObjectType.sure { "Enum entry must have a class object type: " + value }
 
     override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitEnumValue(this, data)
@@ -211,9 +211,9 @@ public class IntValue(
     override fun hashCode() = value
 }
 
-public class KClassValue(override val type: JetType) :
-        ConstantValue<JetType>(type) {
-    override val value: JetType
+public class KClassValue(override val type: KtType) :
+        ConstantValue<KtType>(type) {
+    override val value: KtType
         get() = type.getArguments().single().getType()
 
     override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitKClassValue(this, data)
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/AbstractScopeAdapter.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/AbstractScopeAdapter.kt
index c85c9dbd80c..180a7dc98ec 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/AbstractScopeAdapter.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/AbstractScopeAdapter.kt
@@ -19,16 +19,16 @@ package org.jetbrains.kotlin.resolve.scopes
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.Printer
 
 /**
  * Introduces a simple wrapper for internal scope.
  */
-public abstract class AbstractScopeAdapter : JetScope {
-    protected abstract val workerScope: JetScope
+public abstract class AbstractScopeAdapter : KtScope {
+    protected abstract val workerScope: KtScope
 
-    public fun getActualScope(): JetScope =
+    public fun getActualScope(): KtScope =
             if (workerScope is AbstractScopeAdapter)
                 (workerScope as AbstractScopeAdapter).getActualScope()
             else
@@ -54,19 +54,19 @@ public abstract class AbstractScopeAdapter : JetScope {
         return workerScope.getProperties(name, location)
     }
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor> {
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor> {
         return workerScope.getSyntheticExtensionProperties(receiverTypes, name, location)
     }
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
         return workerScope.getSyntheticExtensionFunctions(receiverTypes, name, location)
     }
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor> {
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>): Collection<PropertyDescriptor> {
         return workerScope.getSyntheticExtensionProperties(receiverTypes)
     }
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>): Collection<FunctionDescriptor> {
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>): Collection<FunctionDescriptor> {
         return workerScope.getSyntheticExtensionFunctions(receiverTypes)
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ChainedScope.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ChainedScope.kt
index 7c87d7ed96a..8ff84d62d7d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ChainedScope.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ChainedScope.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve.scopes
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.util.collectionUtils.getFirstMatch
 import org.jetbrains.kotlin.util.collectionUtils.getFromAllScopes
 import org.jetbrains.kotlin.utils.Printer
@@ -28,8 +28,8 @@ import java.util.ArrayList
 public open class ChainedScope(
         private val containingDeclaration: DeclarationDescriptor?/* it's nullable as a hack for TypeUtils.intersect() */,
         private val debugName: String,
-        vararg scopes: JetScope
-) : JetScope {
+        vararg scopes: KtScope
+) : KtScope {
     private val scopeChain = scopes.clone()
     private var implicitReceiverHierarchy: List<ReceiverParameterDescriptor>? = null
 
@@ -48,16 +48,16 @@ public open class ChainedScope(
     override fun getFunctions(name: Name, location: LookupLocation): Collection<FunctionDescriptor>
             = getFromAllScopes(scopeChain) { it.getFunctions(name, location) }
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor>
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor>
             = getFromAllScopes(scopeChain) { it.getSyntheticExtensionProperties(receiverTypes, name, location) }
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor>
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor>
             = getFromAllScopes(scopeChain) { it.getSyntheticExtensionFunctions(receiverTypes, name, location) }
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor>
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>): Collection<PropertyDescriptor>
             = getFromAllScopes(scopeChain) { it.getSyntheticExtensionProperties(receiverTypes) }
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>): Collection<FunctionDescriptor>
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>): Collection<FunctionDescriptor>
             = getFromAllScopes(scopeChain) { it.getSyntheticExtensionFunctions(receiverTypes) }
 
     override fun getImplicitReceiversHierarchy(): List<ReceiverParameterDescriptor> {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ExplicitImportsScope.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ExplicitImportsScope.kt
index b7c38a4af8f..2181982e84d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ExplicitImportsScope.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ExplicitImportsScope.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 
-public class ExplicitImportsScope(private val descriptors: Collection<DeclarationDescriptor>) : JetScopeImpl() {
+public class ExplicitImportsScope(private val descriptors: Collection<DeclarationDescriptor>) : KtScopeImpl() {
     override fun getClassifier(name: Name, location: LookupLocation) = descriptors.filter { it.getName() == name }.firstIsInstanceOrNull<ClassifierDescriptor>()
 
     override fun getPackage(name: Name)= descriptors.filter { it.getName() == name }.firstIsInstanceOrNull<PackageViewDescriptor>()
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/FilteringScope.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/FilteringScope.kt
index b7573aac4d7..36140675d05 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/FilteringScope.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/FilteringScope.kt
@@ -21,10 +21,10 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.Printer
 
-public class FilteringScope(private val workerScope: JetScope, private val predicate: (DeclarationDescriptor) -> Boolean) : JetScope {
+public class FilteringScope(private val workerScope: KtScope, private val predicate: (DeclarationDescriptor) -> Boolean) : KtScope {
 
     override fun getFunctions(name: Name, location: LookupLocation) = workerScope.getFunctions(name, location).filter(predicate)
 
@@ -39,16 +39,16 @@ public class FilteringScope(private val workerScope: JetScope, private val predi
 
     override fun getProperties(name: Name, location: LookupLocation) = workerScope.getProperties(name, location).filter(predicate)
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor>
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor>
             = workerScope.getSyntheticExtensionProperties(receiverTypes, name, location).filter(predicate)
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor>
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor>
             = workerScope.getSyntheticExtensionFunctions(receiverTypes, name, location).filter(predicate)
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor>
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>): Collection<PropertyDescriptor>
             = workerScope.getSyntheticExtensionProperties(receiverTypes).filter(predicate)
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>): Collection<FunctionDescriptor>
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>): Collection<FunctionDescriptor>
             = workerScope.getSyntheticExtensionFunctions(receiverTypes).filter(predicate)
 
     override fun getLocalVariable(name: Name) = filterDescriptor(workerScope.getLocalVariable(name))
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/InnerClassesScopeWrapper.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/InnerClassesScopeWrapper.kt
index ca4656c7e0c..3c97d1af59e 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/InnerClassesScopeWrapper.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/InnerClassesScopeWrapper.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.Printer
 
-public class InnerClassesScopeWrapper(val workerScope: JetScope) : JetScopeImpl() {
+public class InnerClassesScopeWrapper(val workerScope: KtScope) : KtScopeImpl() {
     override fun getContainingDeclaration(): DeclarationDescriptor {
         return workerScope.getContainingDeclaration()
     }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScope.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/KtScope.kt
similarity index 96%
rename from core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScope.kt
rename to core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/KtScope.kt
index 218fd3c9061..619f4253024 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScope.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/KtScope.kt
@@ -20,12 +20,12 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.toReadOnlyList
 import java.lang.reflect.Modifier
 
-public interface JetScope {
+public interface KtScope {
 
     public fun getClassifier(name: Name, location: LookupLocation): ClassifierDescriptor?
 
@@ -37,11 +37,11 @@ public interface JetScope {
 
     public fun getFunctions(name: Name, location: LookupLocation): Collection<FunctionDescriptor>
 
-    public fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor>
-    public fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor>
+    public fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor>
+    public fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor>
 
-    public fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor>
-    public fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>): Collection<FunctionDescriptor>
+    public fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>): Collection<PropertyDescriptor>
+    public fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>): Collection<FunctionDescriptor>
 
     public fun getContainingDeclaration(): DeclarationDescriptor
 
@@ -79,7 +79,7 @@ public interface JetScope {
      */
     public fun printScopeStructure(p: Printer)
 
-    public object Empty : JetScopeImpl() {
+    public object Empty : KtScopeImpl() {
         override fun getContainingDeclaration(): DeclarationDescriptor {
             throw UnsupportedOperationException("Don't take containing declaration of the Empty scope")
         }
@@ -99,7 +99,7 @@ public interface JetScope {
 /**
  * The same as getDescriptors(kindFilter, nameFilter) but the result is guaranteed to be filtered by kind and name.
  */
-public fun JetScope.getDescriptorsFiltered(
+public fun KtScope.getDescriptorsFiltered(
         kindFilter: DescriptorKindFilter = DescriptorKindFilter.ALL,
         nameFilter: (Name) -> Boolean = { true }
 ): Collection<DeclarationDescriptor> {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScopeImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/KtScopeImpl.kt
similarity index 83%
rename from core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScopeImpl.kt
rename to core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/KtScopeImpl.kt
index f967cab5b37..f30247eaa4d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScopeImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/KtScopeImpl.kt
@@ -19,10 +19,10 @@ package org.jetbrains.kotlin.resolve.scopes
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.Printer
 
-public abstract class JetScopeImpl : JetScope {
+public abstract class KtScopeImpl : KtScope {
     override fun getClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? = null
 
     override fun getProperties(name: Name, location: LookupLocation): Collection<VariableDescriptor> = emptyList()
@@ -33,11 +33,11 @@ public abstract class JetScopeImpl : JetScope {
 
     override fun getFunctions(name: Name, location: LookupLocation): Collection<FunctionDescriptor> = emptyList()
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor> = emptyList()
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor> = emptyList()
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor> = emptyList()
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor> = emptyList()
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor> = emptyList()
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>): Collection<FunctionDescriptor> = emptyList()
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>): Collection<PropertyDescriptor> = emptyList()
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>): Collection<FunctionDescriptor> = emptyList()
 
     override fun getDeclarationsByLabel(labelName: Name): Collection<DeclarationDescriptor> = emptyList()
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/LazyScopeAdapter.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/LazyScopeAdapter.kt
index 0649317ff9e..ee75d989943 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/LazyScopeAdapter.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/LazyScopeAdapter.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve.scopes
 
 import org.jetbrains.kotlin.storage.NotNullLazyValue
 
-public class LazyScopeAdapter(private val scope: NotNullLazyValue<JetScope>) : AbstractScopeAdapter() {
-    override val workerScope: JetScope
+public class LazyScopeAdapter(private val scope: NotNullLazyValue<KtScope>) : AbstractScopeAdapter() {
+    override val workerScope: KtScope
         get() = scope()
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/Scopes.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/Scopes.kt
index b10e34ce278..ef14db14c3e 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/Scopes.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/Scopes.kt
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.Printer
 
 // see ScopeUtils.kt in the frontend module
@@ -58,14 +58,14 @@ public interface FileScope: LexicalScope {
 
     fun getPackage(name: Name): PackageViewDescriptor?
 
-    public fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor>
-    public fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor>
+    public fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor>
+    public fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor>
 
-    public fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor>
-    public fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>): Collection<FunctionDescriptor>
+    public fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>): Collection<PropertyDescriptor>
+    public fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>): Collection<FunctionDescriptor>
 
     public fun getDescriptors(
             kindFilter: DescriptorKindFilter = DescriptorKindFilter.ALL,
-            nameFilter: (Name) -> Boolean = JetScope.ALL_NAME_FILTER
+            nameFilter: (Name) -> Boolean = KtScope.ALL_NAME_FILTER
     ): Collection<DeclarationDescriptor>
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/StaticScopeForKotlinClass.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/StaticScopeForKotlinClass.kt
index 9af681d12bb..74e0b30dbec 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/StaticScopeForKotlinClass.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/StaticScopeForKotlinClass.kt
@@ -27,7 +27,7 @@ import java.util.ArrayList
 
 public class StaticScopeForKotlinClass(
         private val containingClass: ClassDescriptor
-) : JetScopeImpl() {
+) : KtScopeImpl() {
     override fun getClassifier(name: Name, location: LookupLocation) = null // TODO
 
     private val functions: List<FunctionDescriptor> by lazy {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/SubstitutingScope.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/SubstitutingScope.kt
index ccbbc41a296..26c8958c1f1 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/SubstitutingScope.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/SubstitutingScope.kt
@@ -22,13 +22,13 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.newHashSetWithExpectedSize
 import java.util.HashMap
 
-public class SubstitutingScope(private val workerScope: JetScope, private val substitutor: TypeSubstitutor) : JetScope {
+public class SubstitutingScope(private val workerScope: KtScope, private val substitutor: TypeSubstitutor) : KtScope {
 
     private var substitutedDescriptors: MutableMap<DeclarationDescriptor, DeclarationDescriptor?>? = null
 
@@ -71,16 +71,16 @@ public class SubstitutingScope(private val workerScope: JetScope, private val su
 
     override fun getFunctions(name: Name, location: LookupLocation) = substitute(workerScope.getFunctions(name, location))
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor>
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor>
             = substitute(workerScope.getSyntheticExtensionProperties(receiverTypes, name, location))
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor>
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>, name: Name, location: LookupLocation): Collection<FunctionDescriptor>
             = substitute(workerScope.getSyntheticExtensionFunctions(receiverTypes, name, location))
 
-    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor>
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<KtType>): Collection<PropertyDescriptor>
             = substitute(workerScope.getSyntheticExtensionProperties(receiverTypes))
 
-    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<JetType>): Collection<FunctionDescriptor>
+    override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KtType>): Collection<FunctionDescriptor>
             = substitute(workerScope.getSyntheticExtensionFunctions(receiverTypes))
 
     override fun getPackage(name: Name) = workerScope.getPackage(name)
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/AbstractReceiverValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/AbstractReceiverValue.java
index 8e5538cb748..0dca93ba7c7 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/AbstractReceiverValue.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/AbstractReceiverValue.java
@@ -17,18 +17,18 @@
 package org.jetbrains.kotlin.resolve.scopes.receivers;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public abstract class AbstractReceiverValue implements ReceiverValue {
-    protected final JetType receiverType;
+    protected final KtType receiverType;
 
-    public AbstractReceiverValue(@NotNull JetType receiverType) {
+    public AbstractReceiverValue(@NotNull KtType receiverType) {
         this.receiverType = receiverType;
     }
 
     @Override
     @NotNull
-    public JetType getType() {
+    public KtType getType() {
         return receiverType;
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/ClassReceiver.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/ClassReceiver.java
index bec4585fed2..6004aba686b 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/ClassReceiver.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/ClassReceiver.java
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve.scopes.receivers;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public class ClassReceiver implements ThisReceiver {
 
@@ -35,7 +35,7 @@ public class ClassReceiver implements ThisReceiver {
 
     @NotNull
     @Override
-    public JetType getType() {
+    public KtType getType() {
         return classDescriptor.getDefaultType();
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExtensionReceiver.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExtensionReceiver.java
index 02bccf0a901..c91268d5a86 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExtensionReceiver.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExtensionReceiver.java
@@ -18,13 +18,13 @@ package org.jetbrains.kotlin.resolve.scopes.receivers;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public class ExtensionReceiver extends AbstractReceiverValue implements ThisReceiver {
 
     private final CallableDescriptor descriptor;
 
-    public ExtensionReceiver(@NotNull CallableDescriptor callableDescriptor, @NotNull JetType receiverType) {
+    public ExtensionReceiver(@NotNull CallableDescriptor callableDescriptor, @NotNull KtType receiverType) {
         super(receiverType);
         this.descriptor = callableDescriptor;
     }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/ReceiverValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/ReceiverValue.java
index b585f38f1fe..cbfcbfb8729 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/ReceiverValue.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/ReceiverValue.java
@@ -17,13 +17,13 @@
 package org.jetbrains.kotlin.resolve.scopes.receivers;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public interface ReceiverValue {
     ReceiverValue NO_RECEIVER = new ReceiverValue() {
         @NotNull
         @Override
-        public JetType getType() {
+        public KtType getType() {
             throw new UnsupportedOperationException("NO_RECEIVER.getType()");
         }
 
@@ -41,7 +41,7 @@ public interface ReceiverValue {
     ReceiverValue IRRELEVANT_RECEIVER = new ReceiverValue() {
         @NotNull
         @Override
-        public JetType getType() {
+        public KtType getType() {
             throw new UnsupportedOperationException("IRRELEVANT_RECEIVER.getType()");
         }
 
@@ -57,7 +57,7 @@ public interface ReceiverValue {
     };
 
     @NotNull
-    JetType getType();
+    KtType getType();
 
     boolean exists();
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/TransientReceiver.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/TransientReceiver.java
index 7db981f0e19..0130db4d4a1 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/TransientReceiver.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/TransientReceiver.java
@@ -17,14 +17,14 @@
 package org.jetbrains.kotlin.resolve.scopes.receivers;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 /**
  * This represents the receiver of hasNext and next() in for-loops
  * Cannot be an expression receiver because there is no expression for the iterator() call
  */
 public class TransientReceiver extends AbstractReceiverValue {
-    public TransientReceiver(@NotNull JetType type) {
+    public TransientReceiver(@NotNull KtType type) {
         super(type);
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/AbstractJetType.java b/core/descriptors/src/org/jetbrains/kotlin/types/AbstractKtType.java
similarity index 88%
rename from core/descriptors/src/org/jetbrains/kotlin/types/AbstractJetType.java
rename to core/descriptors/src/org/jetbrains/kotlin/types/AbstractKtType.java
index 579330efb70..f632a34e90e 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/AbstractJetType.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/AbstractKtType.java
@@ -18,15 +18,14 @@ package org.jetbrains.kotlin.types;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.Iterator;
 import java.util.List;
 
-public abstract class AbstractJetType implements JetType {
+public abstract class AbstractKtType implements KtType {
     @Nullable
     @Override
     public <T extends TypeCapability> T getCapability(@NotNull Class<T> capabilityClass) {
@@ -50,11 +49,11 @@ public abstract class AbstractJetType implements JetType {
     @Override
     public final boolean equals(Object obj) {
         if (this == obj) return true;
-        if (!(obj instanceof JetType)) return false;
+        if (!(obj instanceof KtType)) return false;
 
-        JetType type = (JetType) obj;
+        KtType type = (KtType) obj;
 
-        return isMarkedNullable() == type.isMarkedNullable() && JetTypeChecker.FLEXIBLE_UNEQUAL_TO_INFLEXIBLE.equalTypes(this, type);
+        return isMarkedNullable() == type.isMarkedNullable() && KotlinTypeChecker.FLEXIBLE_UNEQUAL_TO_INFLEXIBLE.equalTypes(this, type);
     }
 
     @Override
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/AbstractLazyType.kt b/core/descriptors/src/org/jetbrains/kotlin/types/AbstractLazyType.kt
index 17ba186ac9f..0973fbe5944 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/AbstractLazyType.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/AbstractLazyType.kt
@@ -19,10 +19,10 @@ package org.jetbrains.kotlin.types
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 
-public abstract class AbstractLazyType(storageManager: StorageManager) : AbstractJetType(), LazyType {
+public abstract class AbstractLazyType(storageManager: StorageManager) : AbstractKtType(), LazyType {
 
     private val typeConstructor = storageManager.createLazyValue { computeTypeConstructor() }
     override fun getConstructor(): TypeConstructor = typeConstructor()
@@ -41,7 +41,7 @@ public abstract class AbstractLazyType(storageManager: StorageManager) : Abstrac
     private val memberScope = storageManager.createLazyValue { computeMemberScope() }
     override fun getMemberScope() = memberScope()
 
-    protected open fun computeMemberScope(): JetScope {
+    protected open fun computeMemberScope(): KtScope {
         val descriptor = constructor.getDeclarationDescriptor()
         return when (descriptor) {
             is TypeParameterDescriptor -> descriptor.getDefaultType().getMemberScope()
@@ -63,6 +63,6 @@ public abstract class AbstractLazyType(storageManager: StorageManager) : Abstrac
         if (!arguments.isComputed()) {
             return "" + getConstructor() + "<arguments are not computed>"
         }
-        return super<AbstractJetType>.toString()
+        return super<AbstractKtType>.toString()
     }
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/CapturedTypeApproximation.kt b/core/descriptors/src/org/jetbrains/kotlin/types/CapturedTypeApproximation.kt
index f56892acd90..90aea4b20ac 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/CapturedTypeApproximation.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/CapturedTypeApproximation.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.resolve.calls.inference.CapturedTypeConstructor
 import org.jetbrains.kotlin.resolve.calls.inference.isCaptured
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.typeUtil.builtIns
 import java.util.*
 
@@ -33,11 +33,11 @@ public data class ApproximationBounds<T>(
 
 private class TypeArgument(
         val typeParameter: TypeParameterDescriptor,
-        val inProjection: JetType,
-        val outProjection: JetType
+        val inProjection: KtType,
+        val outProjection: KtType
 ) {
     val isConsistent: Boolean
-        get() = JetTypeChecker.DEFAULT.isSubtypeOf(inProjection, outProjection)
+        get() = KotlinTypeChecker.DEFAULT.isSubtypeOf(inProjection, outProjection)
 }
 
 private fun TypeArgument.toTypeProjection(): TypeProjection {
@@ -85,12 +85,12 @@ private fun substituteCapturedTypes(typeProjection: TypeProjection): TypeProject
     return typeSubstitutor.substituteWithoutApproximation(typeProjection)
 }
 
-public fun approximateCapturedTypes(type: JetType): ApproximationBounds<JetType> {
+public fun approximateCapturedTypes(type: KtType): ApproximationBounds<KtType> {
     val typeConstructor = type.getConstructor()
     if (type.isCaptured()) {
         val typeProjection = (typeConstructor as CapturedTypeConstructor).typeProjection
         // todo: preserve flexibility as well
-        fun JetType.makeNullableIfNeeded() = TypeUtils.makeNullableIfNeeded(this, type.isMarkedNullable())
+        fun KtType.makeNullableIfNeeded() = TypeUtils.makeNullableIfNeeded(this, type.isMarkedNullable())
         val bound = typeProjection.getType().makeNullableIfNeeded()
 
         return when (typeProjection.getProjectionKind()) {
@@ -115,9 +115,9 @@ public fun approximateCapturedTypes(type: JetType): ApproximationBounds<JetType>
             type.replaceTypeArguments(upperBoundArguments))
 }
 
-private fun JetType.replaceTypeArguments(newTypeArguments: List<TypeArgument>): JetType {
+private fun KtType.replaceTypeArguments(newTypeArguments: List<TypeArgument>): KtType {
     assert(getArguments().size() == newTypeArguments.size()) { "Incorrect type arguments $newTypeArguments" }
-    return JetTypeImpl.create(
+    return KtTypeImpl.create(
             getAnnotations(), getConstructor(), isMarkedNullable(), newTypeArguments.map { it.toTypeProjection() }, getMemberScope()
     )
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/CommonSupertypes.java b/core/descriptors/src/org/jetbrains/kotlin/types/CommonSupertypes.java
index a6fd77b52eb..0d46162ce3a 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/CommonSupertypes.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/CommonSupertypes.java
@@ -26,8 +26,8 @@ import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.typeUtil.TypeUtilsKt;
 
 import java.util.*;
@@ -38,10 +38,10 @@ import static org.jetbrains.kotlin.types.Variance.OUT_VARIANCE;
 
 public class CommonSupertypes {
     @Nullable
-    public static JetType commonSupertypeForNonDenotableTypes(@NotNull Collection<JetType> types) {
+    public static KtType commonSupertypeForNonDenotableTypes(@NotNull Collection<KtType> types) {
         if (types.isEmpty()) return null;
         if (types.size() == 1) {
-            JetType type = types.iterator().next();
+            KtType type = types.iterator().next();
             if (type.getConstructor() instanceof IntersectionTypeConstructor) {
                 return commonSupertypeForNonDenotableTypes(type.getConstructor().getSupertypes());
             }
@@ -50,15 +50,15 @@ public class CommonSupertypes {
     }
 
     @NotNull
-    public static JetType commonSupertype(@NotNull Collection<JetType> types) {
+    public static KtType commonSupertype(@NotNull Collection<KtType> types) {
         // Recursion should not be significantly deeper than the deepest type in question
         // It can be slightly deeper, though: e.g. when initial types are simple, but their supertypes are complex
         return findCommonSupertype(types, 0, maxDepth(types) + 3);
     }
 
-    private static int maxDepth(@NotNull Collection<JetType> types) {
+    private static int maxDepth(@NotNull Collection<KtType> types) {
         int max = 0;
-        for (JetType type : types) {
+        for (KtType type : types) {
             int depth = depth(type);
             if (max < depth) {
                 max = depth;
@@ -67,10 +67,10 @@ public class CommonSupertypes {
         return max;
     }
 
-    private static int depth(@NotNull final JetType type) {
-        return 1 + maxDepth(CollectionsKt.map(type.getArguments(), new Function1<TypeProjection, JetType>() {
+    private static int depth(@NotNull final KtType type) {
+        return 1 + maxDepth(CollectionsKt.map(type.getArguments(), new Function1<TypeProjection, KtType>() {
             @Override
-            public JetType invoke(TypeProjection projection) {
+            public KtType invoke(TypeProjection projection) {
                 if (projection.isStarProjection()) {
                     // any type is good enough for depth here
                     return type.getConstructor().getBuiltIns().getAnyType();
@@ -81,13 +81,13 @@ public class CommonSupertypes {
     }
 
     @NotNull
-    private static JetType findCommonSupertype(@NotNull Collection<JetType> types, int recursionDepth, int maxDepth) {
+    private static KtType findCommonSupertype(@NotNull Collection<KtType> types, int recursionDepth, int maxDepth) {
         assert recursionDepth <= maxDepth : "Recursion depth exceeded: " + recursionDepth + " > " + maxDepth + " for types " + types;
         boolean hasFlexible = false;
-        List<JetType> upper = new ArrayList<JetType>(types.size());
-        List<JetType> lower = new ArrayList<JetType>(types.size());
+        List<KtType> upper = new ArrayList<KtType>(types.size());
+        List<KtType> lower = new ArrayList<KtType>(types.size());
         Set<FlexibleTypeCapabilities> capabilities = new LinkedHashSet<FlexibleTypeCapabilities>();
-        for (JetType type : types) {
+        for (KtType type : types) {
             if (FlexibleTypesKt.isFlexible(type)) {
                 hasFlexible = true;
                 Flexibility flexibility = FlexibleTypesKt.flexibility(type);
@@ -110,18 +110,18 @@ public class CommonSupertypes {
     }
 
     @NotNull
-    private static JetType commonSuperTypeForInflexible(@NotNull Collection<JetType> types, int recursionDepth, int maxDepth) {
+    private static KtType commonSuperTypeForInflexible(@NotNull Collection<KtType> types, int recursionDepth, int maxDepth) {
         assert !types.isEmpty();
-        Collection<JetType> typeSet = new HashSet<JetType>(types);
+        Collection<KtType> typeSet = new HashSet<KtType>(types);
 
-        JetType bestFit = FlexibleTypesKt.singleBestRepresentative(typeSet);
+        KtType bestFit = FlexibleTypesKt.singleBestRepresentative(typeSet);
         if (bestFit != null) return bestFit;
 
         // If any of the types is nullable, the result must be nullable
         // This also removed Nothing and Nothing? because they are subtypes of everything else
         boolean nullable = false;
-        for (Iterator<JetType> iterator = typeSet.iterator(); iterator.hasNext();) {
-            JetType type = iterator.next();
+        for (Iterator<KtType> iterator = typeSet.iterator(); iterator.hasNext();) {
+            KtType type = iterator.next();
             assert type != null;
             assert !FlexibleTypesKt.isFlexible(type) : "Flexible type " + type + " passed to commonSuperTypeForInflexible";
             if (KotlinBuiltIns.isNothingOrNullableNothing(type)) {
@@ -145,10 +145,10 @@ public class CommonSupertypes {
         }
 
         // constructor of the supertype -> all of its instantiations occurring as supertypes
-        Map<TypeConstructor, Set<JetType>> commonSupertypes = computeCommonRawSupertypes(typeSet);
+        Map<TypeConstructor, Set<KtType>> commonSupertypes = computeCommonRawSupertypes(typeSet);
         while (commonSupertypes.size() > 1) {
-            Set<JetType> merge = new HashSet<JetType>();
-            for (Set<JetType> supertypes : commonSupertypes.values()) {
+            Set<KtType> merge = new HashSet<KtType>();
+            for (Set<KtType> supertypes : commonSupertypes.values()) {
                 merge.addAll(supertypes);
             }
             commonSupertypes = computeCommonRawSupertypes(merge);
@@ -156,24 +156,24 @@ public class CommonSupertypes {
         assert !commonSupertypes.isEmpty() : commonSupertypes + " <- " + types;
 
         // constructor of the supertype -> all of its instantiations occurring as supertypes
-        Map.Entry<TypeConstructor, Set<JetType>> entry = commonSupertypes.entrySet().iterator().next();
+        Map.Entry<TypeConstructor, Set<KtType>> entry = commonSupertypes.entrySet().iterator().next();
 
         // Reconstructing type arguments if possible
-        JetType result = computeSupertypeProjections(entry.getKey(), entry.getValue(), recursionDepth, maxDepth);
+        KtType result = computeSupertypeProjections(entry.getKey(), entry.getValue(), recursionDepth, maxDepth);
         return TypeUtils.makeNullableIfNeeded(result, nullable);
     }
 
     // Raw supertypes are superclasses w/o type arguments
     // @return TypeConstructor -> all instantiations of this constructor occurring as supertypes
     @NotNull
-    private static Map<TypeConstructor, Set<JetType>> computeCommonRawSupertypes(@NotNull Collection<JetType> types) {
+    private static Map<TypeConstructor, Set<KtType>> computeCommonRawSupertypes(@NotNull Collection<KtType> types) {
         assert !types.isEmpty();
 
-        Map<TypeConstructor, Set<JetType>> constructorToAllInstances = new HashMap<TypeConstructor, Set<JetType>>();
+        Map<TypeConstructor, Set<KtType>> constructorToAllInstances = new HashMap<TypeConstructor, Set<KtType>>();
         Set<TypeConstructor> commonSuperclasses = null;
 
         List<TypeConstructor> order = null;
-        for (JetType type : types) {
+        for (KtType type : types) {
             Set<TypeConstructor> visited = new HashSet<TypeConstructor>();
             order = topologicallySortSuperclassesAndRecordAllInstances(type, constructorToAllInstances, visited);
 
@@ -187,7 +187,7 @@ public class CommonSupertypes {
         assert order != null;
 
         Set<TypeConstructor> notSource = new HashSet<TypeConstructor>();
-        Map<TypeConstructor, Set<JetType>> result = new HashMap<TypeConstructor, Set<JetType>>();
+        Map<TypeConstructor, Set<KtType>> result = new HashMap<TypeConstructor, Set<KtType>>();
         for (TypeConstructor superConstructor : order) {
             if (!commonSuperclasses.contains(superConstructor)) {
                 continue;
@@ -205,7 +205,7 @@ public class CommonSupertypes {
     // constructor - type constructor of a supertype to be instantiated
     // types - instantiations of constructor occurring as supertypes of classes we are trying to intersect
     @NotNull
-    private static JetType computeSupertypeProjections(@NotNull TypeConstructor constructor, @NotNull Set<JetType> types, int recursionDepth, int maxDepth) {
+    private static KtType computeSupertypeProjections(@NotNull TypeConstructor constructor, @NotNull Set<KtType> types, int recursionDepth, int maxDepth) {
         // we assume that all the given types are applications of the same type constructor
 
         assert !types.isEmpty();
@@ -218,19 +218,19 @@ public class CommonSupertypes {
         List<TypeProjection> newProjections = new ArrayList<TypeProjection>(parameters.size());
         for (TypeParameterDescriptor parameterDescriptor : parameters) {
             Set<TypeProjection> typeProjections = new HashSet<TypeProjection>();
-            for (JetType type : types) {
+            for (KtType type : types) {
                 typeProjections.add(type.getArguments().get(parameterDescriptor.getIndex()));
             }
             newProjections.add(computeSupertypeProjection(parameterDescriptor, typeProjections, recursionDepth, maxDepth));
         }
 
         boolean nullable = false;
-        for (JetType type : types) {
+        for (KtType type : types) {
             nullable |= type.isMarkedNullable();
         }
 
         ClassifierDescriptor declarationDescriptor = constructor.getDeclarationDescriptor();
-        JetScope newScope;
+        KtScope newScope;
         if (declarationDescriptor instanceof ClassDescriptor) {
             newScope = ((ClassDescriptor) declarationDescriptor).getMemberScope(newProjections);
         }
@@ -240,7 +240,7 @@ public class CommonSupertypes {
         else {
             newScope = ErrorUtils.createErrorScope("A scope for common supertype which is not a normal classifier", true);
         }
-        return JetTypeImpl.create(Annotations.Companion.getEMPTY(), constructor, nullable, newProjections, newScope);
+        return KtTypeImpl.create(Annotations.Companion.getEMPTY(), constructor, nullable, newProjections, newScope);
     }
 
     @NotNull
@@ -260,8 +260,8 @@ public class CommonSupertypes {
             return new TypeProjectionImpl(OUT_VARIANCE, DescriptorUtilsKt.getBuiltIns(parameterDescriptor).getNullableAnyType());
         }
 
-        Set<JetType> ins = new HashSet<JetType>();
-        Set<JetType> outs = new HashSet<JetType>();
+        Set<KtType> ins = new HashSet<KtType>();
+        Set<KtType> outs = new HashSet<KtType>();
 
         Variance variance = parameterDescriptor.getVariance();
         switch (variance) {
@@ -300,8 +300,8 @@ public class CommonSupertypes {
         if (outs != null) {
             assert !outs.isEmpty() : "Out projections is empty for parameter " + parameterDescriptor + ", type projections " + typeProjections;
             Variance projectionKind = variance == OUT_VARIANCE ? Variance.INVARIANT : OUT_VARIANCE;
-            JetType superType = findCommonSupertype(outs, recursionDepth + 1, maxDepth);
-            for (JetType upperBound: parameterDescriptor.getUpperBounds()) {
+            KtType superType = findCommonSupertype(outs, recursionDepth + 1, maxDepth);
+            for (KtType upperBound: parameterDescriptor.getUpperBounds()) {
                 if (!TypeUtilsKt.isSubtypeOf(superType, upperBound)) {
                     return new StarProjectionImpl(parameterDescriptor);
                 }
@@ -310,7 +310,7 @@ public class CommonSupertypes {
         }
         if (ins != null) {
             assert !ins.isEmpty() : "In projections is empty for parameter " + parameterDescriptor + ", type projections " + typeProjections;
-            JetType intersection = TypeIntersector.intersectTypes(JetTypeChecker.DEFAULT, ins);
+            KtType intersection = TypeIntersector.intersectTypes(KotlinTypeChecker.DEFAULT, ins);
             if (intersection == null) {
                 return new TypeProjectionImpl(OUT_VARIANCE, findCommonSupertype(parameterDescriptor.getUpperBounds(), recursionDepth + 1, maxDepth));
             }
@@ -325,7 +325,7 @@ public class CommonSupertypes {
 
     private static void markAll(@NotNull TypeConstructor typeConstructor, @NotNull Set<TypeConstructor> markerSet) {
         markerSet.add(typeConstructor);
-        for (JetType type : typeConstructor.getSupertypes()) {
+        for (KtType type : typeConstructor.getSupertypes()) {
             markAll(type.getConstructor(), markerSet);
         }
     }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/DelegatingType.java b/core/descriptors/src/org/jetbrains/kotlin/types/DelegatingType.java
index 9a5db02f04c..d87a68c5e01 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/DelegatingType.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/DelegatingType.java
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.types;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.List;
 
-public abstract class DelegatingType implements JetType {
-    protected abstract JetType getDelegate();
+public abstract class DelegatingType implements KtType {
+    protected abstract KtType getDelegate();
 
     @NotNull
     @Override
@@ -52,7 +52,7 @@ public abstract class DelegatingType implements JetType {
 
     @NotNull
     @Override
-    public JetScope getMemberScope() {
+    public KtScope getMemberScope() {
         return getDelegate().getMemberScope();
     }
 
@@ -87,10 +87,10 @@ public abstract class DelegatingType implements JetType {
     @Override
     public boolean equals(Object obj) {
         if (this == obj) return true;
-        if (!(obj instanceof JetType)) return false;
+        if (!(obj instanceof KtType)) return false;
 
-        JetType type = (JetType) obj;
-        return JetTypeChecker.FLEXIBLE_UNEQUAL_TO_INFLEXIBLE.equalTypes(this, type);
+        KtType type = (KtType) obj;
+        return KotlinTypeChecker.FLEXIBLE_UNEQUAL_TO_INFLEXIBLE.equalTypes(this, type);
     }
 
     @Override
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/DescriptorSubstitutor.java b/core/descriptors/src/org/jetbrains/kotlin/types/DescriptorSubstitutor.java
index 346c1651807..23075e72844 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/DescriptorSubstitutor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/DescriptorSubstitutor.java
@@ -67,7 +67,7 @@ public class DescriptorSubstitutor {
 
         for (TypeParameterDescriptor descriptor : typeParameters) {
             TypeParameterDescriptorImpl substituted = substitutedMap.get(descriptor);
-            for (JetType upperBound : descriptor.getUpperBounds()) {
+            for (KtType upperBound : descriptor.getUpperBounds()) {
                 substituted.getUpperBounds().add(substitutor.substitute(upperBound, Variance.INVARIANT));
             }
         }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/DisjointKeysUnionTypeSubstitution.kt b/core/descriptors/src/org/jetbrains/kotlin/types/DisjointKeysUnionTypeSubstitution.kt
index 627bf7d11ae..9abec61ee37 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/DisjointKeysUnionTypeSubstitution.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/DisjointKeysUnionTypeSubstitution.kt
@@ -32,7 +32,7 @@ public class DisjointKeysUnionTypeSubstitution private constructor(
         }
     }
 
-    override fun get(key: JetType) = first[key] ?: second[key]
+    override fun get(key: KtType) = first[key] ?: second[key]
 
     override fun isEmpty() = false
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java b/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java
index f7313029ef5..1daac1f756a 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.resolve.ImportPath;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.types.error.ErrorSimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.utils.Printer;
 
@@ -145,7 +145,7 @@ public class ErrorUtils {
             }
         }
         for (TypeParameterDescriptor parameter : function.getTypeParameters()) {
-            for (JetType upperBound : parameter.getUpperBounds()) {
+            for (KtType upperBound : parameter.getUpperBounds()) {
                 if (containsErrorType(upperBound)) {
                     return true;
                 }
@@ -155,7 +155,7 @@ public class ErrorUtils {
         return false;
     }
 
-    private static abstract class AbstractErrorScope implements JetScope {
+    private static abstract class AbstractErrorScope implements KtScope {
         @Nullable
         @Override
         public ClassifierDescriptor getClassifier(@NotNull Name name) {
@@ -185,7 +185,7 @@ public class ErrorUtils {
         @NotNull
         @Override
         public Collection<PropertyDescriptor> getSyntheticExtensionProperties(
-                @NotNull Collection<? extends JetType> receiverTypes, @NotNull Name name,
+                @NotNull Collection<? extends KtType> receiverTypes, @NotNull Name name,
                 @NotNull LookupLocation location
         ) {
             return ERROR_PROPERTY_GROUP;
@@ -194,7 +194,7 @@ public class ErrorUtils {
         @NotNull
         @Override
         public Collection<FunctionDescriptor> getSyntheticExtensionFunctions(
-                @NotNull Collection<? extends JetType> receiverTypes, @NotNull Name name,
+                @NotNull Collection<? extends KtType> receiverTypes, @NotNull Name name,
                 @NotNull LookupLocation location
         ) {
             return Collections.<FunctionDescriptor>singleton(createErrorFunction(this));
@@ -202,14 +202,14 @@ public class ErrorUtils {
 
         @NotNull
         @Override
-        public Collection<PropertyDescriptor> getSyntheticExtensionProperties(@NotNull Collection<? extends JetType> receiverTypes) {
+        public Collection<PropertyDescriptor> getSyntheticExtensionProperties(@NotNull Collection<? extends KtType> receiverTypes) {
             return ERROR_PROPERTY_GROUP;
         }
 
         @NotNull
         @Override
         public Collection<FunctionDescriptor> getSyntheticExtensionFunctions(
-                @NotNull Collection<? extends JetType> receiverTypes
+                @NotNull Collection<? extends KtType> receiverTypes
         ) {
             return Collections.<FunctionDescriptor>singleton(createErrorFunction(this));
         }
@@ -319,7 +319,7 @@ public class ErrorUtils {
         @NotNull
         @Override
         public Collection<PropertyDescriptor> getSyntheticExtensionProperties(
-                @NotNull Collection<? extends JetType> receiverTypes, @NotNull Name name,
+                @NotNull Collection<? extends KtType> receiverTypes, @NotNull Name name,
                 @NotNull LookupLocation location
         ) {
             throw new IllegalStateException();
@@ -328,7 +328,7 @@ public class ErrorUtils {
         @NotNull
         @Override
         public Collection<FunctionDescriptor> getSyntheticExtensionFunctions(
-                @NotNull Collection<? extends JetType> receiverTypes, @NotNull Name name,
+                @NotNull Collection<? extends KtType> receiverTypes, @NotNull Name name,
                 @NotNull LookupLocation location
         ) {
             throw new IllegalStateException();
@@ -336,14 +336,14 @@ public class ErrorUtils {
 
         @NotNull
         @Override
-        public Collection<PropertyDescriptor> getSyntheticExtensionProperties(@NotNull Collection<? extends JetType> receiverTypes) {
+        public Collection<PropertyDescriptor> getSyntheticExtensionProperties(@NotNull Collection<? extends KtType> receiverTypes) {
             throw new IllegalStateException();
         }
 
         @NotNull
         @Override
         public Collection<FunctionDescriptor> getSyntheticExtensionFunctions(
-                @NotNull Collection<? extends JetType> receiverTypes
+                @NotNull Collection<? extends KtType> receiverTypes
         ) {
             throw new IllegalStateException();
         }
@@ -402,12 +402,12 @@ public class ErrorUtils {
     private static class ErrorClassDescriptor extends ClassDescriptorImpl {
         public ErrorClassDescriptor(@Nullable String name) {
             super(getErrorModule(), Name.special(name == null ? "<ERROR CLASS>" : "<ERROR CLASS: " + name + ">"),
-                  Modality.OPEN, Collections.<JetType>emptyList(), SourceElement.NO_SOURCE);
+                  Modality.OPEN, Collections.<KtType>emptyList(), SourceElement.NO_SOURCE);
 
             ConstructorDescriptorImpl errorConstructor = ConstructorDescriptorImpl.create(this, Annotations.Companion.getEMPTY(), true, SourceElement.NO_SOURCE);
             errorConstructor.initialize(Collections.<TypeParameterDescriptor>emptyList(), Collections.<ValueParameterDescriptor>emptyList(),
                                         Visibilities.INTERNAL);
-            JetScope memberScope = createErrorScope(getName().asString());
+            KtScope memberScope = createErrorScope(getName().asString());
             errorConstructor.setReturnType(
                     new ErrorTypeImpl(
                             createErrorTypeConstructorWithCustomDebugName("<ERROR>", this),
@@ -431,13 +431,13 @@ public class ErrorUtils {
 
         @NotNull
         @Override
-        public JetScope getMemberScope(@NotNull List<? extends TypeProjection> typeArguments) {
+        public KtScope getMemberScope(@NotNull List<? extends TypeProjection> typeArguments) {
             return createErrorScope("Error scope for class " + getName() + " with arguments: " + typeArguments);
         }
 
         @NotNull
         @Override
-        public JetScope getMemberScope(@NotNull TypeSubstitution typeSubstitution) {
+        public KtScope getMemberScope(@NotNull TypeSubstitution typeSubstitution) {
             return createErrorScope("Error scope for class " + getName() + " with arguments: " + typeSubstitution);
         }
     }
@@ -448,19 +448,19 @@ public class ErrorUtils {
     }
 
     @NotNull
-    public static JetScope createErrorScope(@NotNull String debugMessage) {
+    public static KtScope createErrorScope(@NotNull String debugMessage) {
         return createErrorScope(debugMessage, false);
     }
 
     @NotNull
-    public static JetScope createErrorScope(@NotNull String debugMessage, boolean throwExceptions) {
+    public static KtScope createErrorScope(@NotNull String debugMessage, boolean throwExceptions) {
         if (throwExceptions) {
             return new ThrowingScope(debugMessage);
         }
         return new ErrorScope(debugMessage);
     }
 
-    private static final JetType ERROR_PROPERTY_TYPE = createErrorType("<ERROR PROPERTY TYPE>");
+    private static final KtType ERROR_PROPERTY_TYPE = createErrorType("<ERROR PROPERTY TYPE>");
     private static final PropertyDescriptor ERROR_PROPERTY = createErrorProperty();
 
     private static final Set<VariableDescriptor> ERROR_VARIABLE_GROUP = Collections.<VariableDescriptor>singleton(ERROR_PROPERTY);
@@ -483,7 +483,7 @@ public class ErrorUtils {
         descriptor.setType(ERROR_PROPERTY_TYPE,
                            Collections.<TypeParameterDescriptor>emptyList(),
                            null,
-                           (JetType) null
+                           (KtType) null
         );
 
         return descriptor;
@@ -505,22 +505,22 @@ public class ErrorUtils {
     }
 
     @NotNull
-    public static JetType createErrorType(@NotNull String debugMessage) {
+    public static KtType createErrorType(@NotNull String debugMessage) {
         return createErrorTypeWithArguments(debugMessage, Collections.<TypeProjection>emptyList());
     }
 
     @NotNull
-    public static JetType createErrorTypeWithCustomDebugName(@NotNull String debugName) {
+    public static KtType createErrorTypeWithCustomDebugName(@NotNull String debugName) {
         return createErrorTypeWithCustomConstructor(debugName, createErrorTypeConstructorWithCustomDebugName(debugName));
     }
 
     @NotNull
-    public static JetType createErrorTypeWithCustomConstructor(@NotNull String debugName, @NotNull TypeConstructor typeConstructor) {
+    public static KtType createErrorTypeWithCustomConstructor(@NotNull String debugName, @NotNull TypeConstructor typeConstructor) {
         return new ErrorTypeImpl(typeConstructor, createErrorScope(debugName));
     }
 
     @NotNull
-    public static JetType createErrorTypeWithArguments(@NotNull String debugMessage, @NotNull List<TypeProjection> arguments) {
+    public static KtType createErrorTypeWithArguments(@NotNull String debugMessage, @NotNull List<TypeProjection> arguments) {
         return new ErrorTypeImpl(createErrorTypeConstructor(debugMessage), createErrorScope(debugMessage), arguments);
     }
 
@@ -547,7 +547,7 @@ public class ErrorUtils {
 
             @NotNull
             @Override
-            public Collection<JetType> getSupertypes() {
+            public Collection<KtType> getSupertypes() {
                 return emptyList();
             }
 
@@ -586,7 +586,7 @@ public class ErrorUtils {
         };
     }
 
-    public static boolean containsErrorType(@Nullable JetType type) {
+    public static boolean containsErrorType(@Nullable KtType type) {
         if (type == null) return false;
         if (type.isError()) return true;
         for (TypeProjection projection : type.getArguments()) {
@@ -615,14 +615,14 @@ public class ErrorUtils {
         );
     }
 
-    private static class ErrorTypeImpl implements JetType {
+    private static class ErrorTypeImpl implements KtType {
         private final TypeConstructor constructor;
-        private final JetScope memberScope;
+        private final KtScope memberScope;
         private final List<TypeProjection> arguments;
 
         private ErrorTypeImpl(
                 @NotNull TypeConstructor constructor,
-                @NotNull JetScope memberScope,
+                @NotNull KtScope memberScope,
                 @NotNull List<TypeProjection> arguments
         ) {
             this.constructor = constructor;
@@ -630,7 +630,7 @@ public class ErrorUtils {
             this.arguments = arguments;
         }
 
-        private ErrorTypeImpl(@NotNull TypeConstructor constructor, @NotNull JetScope memberScope) {
+        private ErrorTypeImpl(@NotNull TypeConstructor constructor, @NotNull KtScope memberScope) {
             this(constructor, memberScope, Collections.<TypeProjection>emptyList());
         }
 
@@ -659,7 +659,7 @@ public class ErrorUtils {
 
         @NotNull
         @Override
-        public JetScope getMemberScope() {
+        public KtScope getMemberScope() {
             return memberScope;
         }
 
@@ -697,21 +697,21 @@ public class ErrorUtils {
         return ERROR_MODULE;
     }
 
-    public static boolean isUninferredParameter(@Nullable JetType type) {
+    public static boolean isUninferredParameter(@Nullable KtType type) {
         return type != null && type.getConstructor() instanceof UninferredParameterTypeConstructor;
     }
 
-    public static boolean containsUninferredParameter(@Nullable JetType type) {
-        return TypeUtils.containsSpecialType(type, new Function1<JetType, Boolean>() {
+    public static boolean containsUninferredParameter(@Nullable KtType type) {
+        return TypeUtils.containsSpecialType(type, new Function1<KtType, Boolean>() {
             @Override
-            public Boolean invoke(JetType argumentType) {
+            public Boolean invoke(KtType argumentType) {
                 return isUninferredParameter(argumentType);
             }
         });
     }
 
     @NotNull
-    public static JetType createUninferredParameterType(@NotNull TypeParameterDescriptor typeParameterDescriptor) {
+    public static KtType createUninferredParameterType(@NotNull TypeParameterDescriptor typeParameterDescriptor) {
         return createErrorTypeWithCustomConstructor("Scope for error type for not inferred parameter: " + typeParameterDescriptor.getName(),
                                                     new UninferredParameterTypeConstructor(typeParameterDescriptor));
     }
@@ -738,7 +738,7 @@ public class ErrorUtils {
 
         @NotNull
         @Override
-        public Collection<JetType> getSupertypes() {
+        public Collection<KtType> getSupertypes() {
             return errorTypeConstructor.getSupertypes();
         }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/FunctionPlaceholders.kt b/core/descriptors/src/org/jetbrains/kotlin/types/FunctionPlaceholders.kt
index 864bf1c5345..d471ba57ce4 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/FunctionPlaceholders.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/FunctionPlaceholders.kt
@@ -23,9 +23,9 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations
 
 class FunctionPlaceholders(private val builtIns: KotlinBuiltIns) {
     fun createFunctionPlaceholderType(
-            argumentTypes: List<JetType>,
+            argumentTypes: List<KtType>,
             hasDeclaredArguments: Boolean
-    ): JetType {
+    ): KtType {
         return ErrorUtils.createErrorTypeWithCustomConstructor(
                 "function placeholder type",
                 FunctionPlaceholderTypeConstructor(argumentTypes, hasDeclaredArguments, builtIns)
@@ -33,13 +33,13 @@ class FunctionPlaceholders(private val builtIns: KotlinBuiltIns) {
     }
 }
 
-val JetType?.isFunctionPlaceholder: Boolean
+val KtType?.isFunctionPlaceholder: Boolean
     get() {
         return this != null && constructor is FunctionPlaceholderTypeConstructor
     }
 
 class FunctionPlaceholderTypeConstructor(
-        val argumentTypes: List<JetType>,
+        val argumentTypes: List<KtType>,
         val hasDeclaredArguments: Boolean,
         private val kotlinBuiltIns: KotlinBuiltIns
 ) : TypeConstructor {
@@ -49,7 +49,7 @@ class FunctionPlaceholderTypeConstructor(
         return errorTypeConstructor.parameters
     }
 
-    override fun getSupertypes(): Collection<JetType> {
+    override fun getSupertypes(): Collection<KtType> {
         return errorTypeConstructor.supertypes
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/IntersectionTypeConstructor.java b/core/descriptors/src/org/jetbrains/kotlin/types/IntersectionTypeConstructor.java
index fa15d1a8a96..e5a49b54dd5 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/IntersectionTypeConstructor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/IntersectionTypeConstructor.java
@@ -26,14 +26,14 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import java.util.*;
 
 public class IntersectionTypeConstructor extends AnnotatedImpl implements TypeConstructor {
-    private final Set<JetType> intersectedTypes;
+    private final Set<KtType> intersectedTypes;
     private final int hashCode;
 
-    public IntersectionTypeConstructor(Annotations annotations, Collection<JetType> typesToIntersect) {
+    public IntersectionTypeConstructor(Annotations annotations, Collection<KtType> typesToIntersect) {
         super(annotations);
         assert !typesToIntersect.isEmpty() : "Attempt to create an empty intersection";
 
-        this.intersectedTypes = new LinkedHashSet<JetType>(typesToIntersect);
+        this.intersectedTypes = new LinkedHashSet<KtType>(typesToIntersect);
         this.hashCode = intersectedTypes.hashCode();
     }
 
@@ -45,7 +45,7 @@ public class IntersectionTypeConstructor extends AnnotatedImpl implements TypeCo
 
     @NotNull
     @Override
-    public Collection<JetType> getSupertypes() {
+    public Collection<KtType> getSupertypes() {
         return intersectedTypes;
     }
 
@@ -75,10 +75,10 @@ public class IntersectionTypeConstructor extends AnnotatedImpl implements TypeCo
         return makeDebugNameForIntersectionType(intersectedTypes);
     }
 
-    private static String makeDebugNameForIntersectionType(Iterable<JetType> resultingTypes) {
+    private static String makeDebugNameForIntersectionType(Iterable<KtType> resultingTypes) {
         StringBuilder debugName = new StringBuilder("{");
-        for (Iterator<JetType> iterator = resultingTypes.iterator(); iterator.hasNext(); ) {
-            JetType type = iterator.next();
+        for (Iterator<KtType> iterator = resultingTypes.iterator(); iterator.hasNext(); ) {
+            KtType type = iterator.next();
 
             debugName.append(type.toString());
             if (iterator.hasNext()) {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/JetType.java b/core/descriptors/src/org/jetbrains/kotlin/types/KtType.java
similarity index 84%
rename from core/descriptors/src/org/jetbrains/kotlin/types/JetType.java
rename to core/descriptors/src/org/jetbrains/kotlin/types/KtType.java
index 2903e2275ce..8d363665e6e 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/JetType.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/KtType.java
@@ -20,15 +20,15 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.ReadOnly;
 import org.jetbrains.kotlin.descriptors.annotations.Annotated;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.List;
 
 /**
- * @see JetTypeChecker#isSubtypeOf(JetType, JetType)
+ * @see KotlinTypeChecker#isSubtypeOf(KtType, KtType)
  */
-public interface JetType extends Annotated {
+public interface KtType extends Annotated {
     @NotNull
     TypeConstructor getConstructor();
 
@@ -42,7 +42,7 @@ public interface JetType extends Annotated {
     boolean isMarkedNullable();
 
     @NotNull
-    JetScope getMemberScope();
+    KtScope getMemberScope();
 
     boolean isError();
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/JetTypeImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/types/KtTypeImpl.kt
similarity index 81%
rename from core/descriptors/src/org/jetbrains/kotlin/types/JetTypeImpl.kt
rename to core/descriptors/src/org/jetbrains/kotlin/types/KtTypeImpl.kt
index a7be829612a..45341556a8c 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/JetTypeImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/KtTypeImpl.kt
@@ -18,17 +18,17 @@ package org.jetbrains.kotlin.types
 
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 
-public open class JetTypeImpl
+public open class KtTypeImpl
 private constructor(
         private val annotations: Annotations,
         private val constructor: TypeConstructor,
         private val nullable: Boolean,
         private val arguments: List<TypeProjection>,
         private val substitution: TypeSubstitution?,
-        private val memberScope: JetScope
-) : AbstractJetType() {
+        private val memberScope: KtScope
+) : AbstractKtType() {
 
     companion object {
         @JvmStatic
@@ -36,9 +36,9 @@ private constructor(
                           constructor: TypeConstructor,
                           nullable: Boolean,
                           arguments: List<TypeProjection>,
-                          memberScope: JetScope): JetTypeImpl
+                          memberScope: KtScope): KtTypeImpl
 
-                = JetTypeImpl(annotations, constructor, nullable, arguments, null, memberScope)
+                = KtTypeImpl(annotations, constructor, nullable, arguments, null, memberScope)
 
         @JvmStatic
         public fun create(annotations: Annotations,
@@ -46,22 +46,22 @@ private constructor(
                           nullable: Boolean,
                           arguments: List<TypeProjection>,
                           substitution: TypeSubstitution,
-                          memberScope: JetScope,
+                          memberScope: KtScope,
                           capabilities: TypeCapabilities
-        ): JetTypeImpl {
+        ): KtTypeImpl {
             if (capabilities !== TypeCapabilities.NONE) {
                 return WithCapabilities(annotations, constructor, nullable, arguments, substitution, memberScope, capabilities)
             }
-            return JetTypeImpl(annotations, constructor, nullable, arguments, substitution, memberScope)
+            return KtTypeImpl(annotations, constructor, nullable, arguments, substitution, memberScope)
         }
 
         @JvmStatic
         public fun create(annotations: Annotations,
                           descriptor: ClassDescriptor,
                           nullable: Boolean,
-                          arguments: List<TypeProjection>): JetTypeImpl
+                          arguments: List<TypeProjection>): KtTypeImpl
 
-                = JetTypeImpl(
+                = KtTypeImpl(
                     annotations, descriptor.typeConstructor, nullable, arguments, null, descriptor.getMemberScope(arguments)
                 )
     }
@@ -72,9 +72,9 @@ private constructor(
             nullable: Boolean,
             arguments: List<TypeProjection>,
             substitution: TypeSubstitution?,
-            memberScope: JetScope,
+            memberScope: KtScope,
             private val typeCapabilities: TypeCapabilities
-    ) : JetTypeImpl(annotations, constructor, nullable, arguments, substitution, memberScope) {
+    ) : KtTypeImpl(annotations, constructor, nullable, arguments, substitution, memberScope) {
         override fun getCapabilities(): TypeCapabilities = typeCapabilities
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/LazyType.java b/core/descriptors/src/org/jetbrains/kotlin/types/LazyType.java
index 75b3a0f4f45..da055a0b632 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/LazyType.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/LazyType.java
@@ -16,5 +16,5 @@
 
 package org.jetbrains.kotlin.types;
 
-public interface LazyType extends JetType {
+public interface LazyType extends KtType {
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/StarProjectionImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/types/StarProjectionImpl.kt
index 4ba0f409ee7..c8314062c79 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/StarProjectionImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/StarProjectionImpl.kt
@@ -27,14 +27,14 @@ class StarProjectionImpl(
     override fun getProjectionKind() = Variance.OUT_VARIANCE
 
     // No synchronization here: there's no problem in accidentally computing this twice
-    private val _type: JetType by lazy(LazyThreadSafetyMode.NONE) {
+    private val _type: KtType by lazy(LazyThreadSafetyMode.NONE) {
         typeParameter.starProjectionType()
     }
 
     override fun getType() = _type
 }
 
-public fun TypeParameterDescriptor.starProjectionType(): JetType {
+public fun TypeParameterDescriptor.starProjectionType(): KtType {
     val classDescriptor = this.getContainingDeclaration() as ClassDescriptor
     val typeParameters = classDescriptor.getTypeConstructor().getParameters().map { it.getTypeConstructor() }
     return TypeSubstitutor.create(
@@ -49,7 +49,7 @@ public fun TypeParameterDescriptor.starProjectionType(): JetType {
 }
 
 class TypeBasedStarProjectionImpl(
-        private val _type: JetType
+        private val _type: KtType
 ) : TypeProjectionBase() {
     override fun isStarProjection() = true
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeCapabilities.kt b/core/descriptors/src/org/jetbrains/kotlin/types/TypeCapabilities.kt
index 699d68da98b..c4653f2f8d3 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeCapabilities.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeCapabilities.kt
@@ -28,7 +28,7 @@ public interface TypeCapabilities {
     fun <T : TypeCapability> getCapability(capabilityClass: Class<T>): T?
 }
 
-public inline fun <reified T : TypeCapability> JetType.getCapability(): T? = getCapability(javaClass<T>())
+public inline fun <reified T : TypeCapability> KtType.getCapability(): T? = getCapability(javaClass<T>())
 
 public interface Specificity : TypeCapability {
 
@@ -38,16 +38,16 @@ public interface Specificity : TypeCapability {
         DONT_KNOW
     }
 
-    public fun getSpecificityRelationTo(otherType: JetType): Relation
+    public fun getSpecificityRelationTo(otherType: KtType): Relation
 }
 
-fun JetType.getSpecificityRelationTo(otherType: JetType) =
+fun KtType.getSpecificityRelationTo(otherType: KtType) =
         this.getCapability(javaClass<Specificity>())?.getSpecificityRelationTo(otherType) ?: Specificity.Relation.DONT_KNOW
 
-fun oneMoreSpecificThanAnother(a: JetType, b: JetType) =
+fun oneMoreSpecificThanAnother(a: KtType, b: KtType) =
         a.getSpecificityRelationTo(b) != Specificity.Relation.DONT_KNOW || b.getSpecificityRelationTo(a) != Specificity.Relation.DONT_KNOW
 
-// To facilitate laziness, any JetType implementation may inherit from this trait,
+// To facilitate laziness, any KtType implementation may inherit from this trait,
 // even if it turns out that the type an instance represents is not actually a type variable
 // (i.e. it is not derived from a type parameter), see isTypeVariable
 public interface CustomTypeVariable : TypeCapability {
@@ -57,29 +57,29 @@ public interface CustomTypeVariable : TypeCapability {
     public val typeParameterDescriptor: TypeParameterDescriptor?
 
     // Throws an exception when isTypeVariable == false
-    public fun substitutionResult(replacement: JetType): JetType
+    public fun substitutionResult(replacement: KtType): KtType
 }
 
-public fun JetType.isCustomTypeVariable(): Boolean = this.getCapability(javaClass<CustomTypeVariable>())?.isTypeVariable ?: false
-public fun JetType.getCustomTypeVariable(): CustomTypeVariable? =
+public fun KtType.isCustomTypeVariable(): Boolean = this.getCapability(javaClass<CustomTypeVariable>())?.isTypeVariable ?: false
+public fun KtType.getCustomTypeVariable(): CustomTypeVariable? =
         this.getCapability(javaClass<CustomTypeVariable>())?.let {
             if (it.isTypeVariable) it else null
         }
 
 public interface SubtypingRepresentatives : TypeCapability {
-    public val subTypeRepresentative: JetType
-    public val superTypeRepresentative: JetType
+    public val subTypeRepresentative: KtType
+    public val superTypeRepresentative: KtType
 
-    public fun sameTypeConstructor(type: JetType): Boolean
+    public fun sameTypeConstructor(type: KtType): Boolean
 }
 
-public fun JetType.getSubtypeRepresentative(): JetType =
+public fun KtType.getSubtypeRepresentative(): KtType =
         this.getCapability(javaClass<SubtypingRepresentatives>())?.subTypeRepresentative ?: this
 
-public fun JetType.getSupertypeRepresentative(): JetType =
+public fun KtType.getSupertypeRepresentative(): KtType =
         this.getCapability(javaClass<SubtypingRepresentatives>())?.superTypeRepresentative ?: this
 
-public fun sameTypeConstructors(first: JetType, second: JetType): Boolean {
+public fun sameTypeConstructors(first: KtType, second: KtType): Boolean {
     val typeRangeCapability = javaClass<SubtypingRepresentatives>()
     return first.getCapability(typeRangeCapability)?.sameTypeConstructor(second) ?: false
            || second.getCapability(typeRangeCapability)?.sameTypeConstructor(first) ?: false
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeConstructor.java b/core/descriptors/src/org/jetbrains/kotlin/types/TypeConstructor.java
index fc693f8c576..2709312505f 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeConstructor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeConstructor.java
@@ -34,7 +34,7 @@ public interface TypeConstructor extends Annotated {
 
     @NotNull
     @ReadOnly
-    Collection<JetType> getSupertypes();
+    Collection<KtType> getSupertypes();
 
     /**
      * Cannot have subtypes.
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeConstructorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/types/TypeConstructorImpl.java
index 8ff07de633a..b6160b19c0d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeConstructorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeConstructorImpl.java
@@ -40,7 +40,7 @@ public abstract class TypeConstructorImpl extends AnnotatedImpl implements TypeC
             boolean isFinal,
             @NotNull String debugName,
             @NotNull List<? extends TypeParameterDescriptor> parameters,
-            @NotNull Collection<JetType> supertypes
+            @NotNull Collection<KtType> supertypes
     ) {
         return new TypeConstructorImpl(classDescriptor, annotations, isFinal, debugName, parameters, supertypes) {
             @Override
@@ -63,7 +63,7 @@ public abstract class TypeConstructorImpl extends AnnotatedImpl implements TypeC
             boolean isFinal,
             @NotNull String debugName,
             @NotNull List<? extends TypeParameterDescriptor> parameters,
-            @NotNull Collection<JetType> supertypes
+            @NotNull Collection<KtType> supertypes
     ) {
         return new TypeConstructorImpl(typeParameterDescriptor, annotations, isFinal, debugName, parameters, supertypes) {
             @Override
@@ -79,7 +79,7 @@ public abstract class TypeConstructorImpl extends AnnotatedImpl implements TypeC
     }
 
     private final List<TypeParameterDescriptor> parameters;
-    private final Collection<JetType> supertypes;
+    private final Collection<KtType> supertypes;
     private final String debugName;
     private final boolean isFinal;
 
@@ -91,7 +91,7 @@ public abstract class TypeConstructorImpl extends AnnotatedImpl implements TypeC
             boolean isFinal,
             @NotNull String debugName,
             @NotNull List<? extends TypeParameterDescriptor> parameters,
-            @NotNull Collection<JetType> supertypes) {
+            @NotNull Collection<KtType> supertypes) {
         super(annotations);
         this.classifierDescriptor = classifierDescriptor;
         this.isFinal = isFinal;
@@ -108,7 +108,7 @@ public abstract class TypeConstructorImpl extends AnnotatedImpl implements TypeC
 
     @Override
     @NotNull
-    public Collection<JetType> getSupertypes() {
+    public Collection<KtType> getSupertypes() {
         return supertypes;
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeIntersector.java b/core/descriptors/src/org/jetbrains/kotlin/types/TypeIntersector.java
index 80bcb91a450..350c33b6f3f 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeIntersector.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeIntersector.java
@@ -27,8 +27,8 @@ import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl;
 import org.jetbrains.kotlin.resolve.scopes.ChainedScope;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.*;
 
@@ -37,14 +37,14 @@ import static org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.Co
 
 public class TypeIntersector {
 
-    public static boolean isIntersectionEmpty(@NotNull JetType typeA, @NotNull JetType typeB) {
-        return intersectTypes(JetTypeChecker.DEFAULT, new LinkedHashSet<JetType>(Arrays.asList(typeA, typeB))) == null;
+    public static boolean isIntersectionEmpty(@NotNull KtType typeA, @NotNull KtType typeB) {
+        return intersectTypes(KotlinTypeChecker.DEFAULT, new LinkedHashSet<KtType>(Arrays.asList(typeA, typeB))) == null;
     }
 
     @Nullable
-    public static JetType intersectTypes(
-            @NotNull JetTypeChecker typeChecker,
-            @NotNull Set<JetType> types
+    public static KtType intersectTypes(
+            @NotNull KotlinTypeChecker typeChecker,
+            @NotNull Set<KtType> types
     ) {
         assert (!types.isEmpty()) : "Attempting to intersect empty set of types, this case should be dealt with on the call site.";
 
@@ -54,10 +54,10 @@ public class TypeIntersector {
 
         // Intersection of T1..Tn is an intersection of their non-null versions,
         //   made nullable is they all were nullable
-        JetType nothingOrNullableNothing = null;
+        KtType nothingOrNullableNothing = null;
         boolean allNullable = true;
-        List<JetType> nullabilityStripped = new ArrayList<JetType>(types.size());
-        for (JetType type : types) {
+        List<KtType> nullabilityStripped = new ArrayList<KtType>(types.size());
+        for (KtType type : types) {
             if (type.isError()) continue;
 
             if (KotlinBuiltIns.isNothingOrNullableNothing(type)) {
@@ -77,11 +77,11 @@ public class TypeIntersector {
         }
 
         // Now we remove types that have subtypes in the list
-        List<JetType> resultingTypes = new ArrayList<JetType>();
+        List<KtType> resultingTypes = new ArrayList<KtType>();
         outer:
-        for (JetType type : nullabilityStripped) {
+        for (KtType type : nullabilityStripped) {
             if (!TypeUtils.canHaveSubtypes(typeChecker, type)) {
-                for (JetType other : nullabilityStripped) {
+                for (KtType other : nullabilityStripped) {
                     // It makes sense to check for subtyping (other <: type), despite that
                     // type is not supposed to be open, for there're enums
                     if (!TypeUnifier.mayBeEqual(type, other) && !typeChecker.isSubtypeOf(type, other) && !typeChecker.isSubtypeOf(other, type)) {
@@ -91,7 +91,7 @@ public class TypeIntersector {
                 return TypeUtils.makeNullableAsSpecified(type, allNullable);
             }
             else {
-                for (JetType other : nullabilityStripped) {
+                for (KtType other : nullabilityStripped) {
                     if (!type.equals(other) && typeChecker.isSubtypeOf(other, type)) {
                         continue outer;
                     }
@@ -100,7 +100,7 @@ public class TypeIntersector {
             }
 
             // Don't add type if it is already present, to avoid trivial type intersections in result
-            for (JetType other : resultingTypes) {
+            for (KtType other : resultingTypes) {
                 if (typeChecker.equalTypes(other, type)) {
                     continue outer;
                 }
@@ -114,7 +114,7 @@ public class TypeIntersector {
             // in that case, we can safely select the best representative out of that set and return it
             // TODO: maybe return the most specific among the types that are subtypes to all others in the `nullabilityStripped`?
             // TODO: e.g. among {Int, Int?, Int!}, return `Int` (now it returns `Int!`).
-            JetType bestRepresentative = FlexibleTypesKt.singleBestRepresentative(nullabilityStripped);
+            KtType bestRepresentative = FlexibleTypesKt.singleBestRepresentative(nullabilityStripped);
             if (bestRepresentative == null) {
                 throw new AssertionError("Empty intersection for types " + types);
             }
@@ -127,14 +127,14 @@ public class TypeIntersector {
 
         TypeConstructor constructor = new IntersectionTypeConstructor(Annotations.Companion.getEMPTY(), resultingTypes);
 
-        JetScope[] scopes = new JetScope[resultingTypes.size()];
+        KtScope[] scopes = new KtScope[resultingTypes.size()];
         int i = 0;
-        for (JetType type : resultingTypes) {
+        for (KtType type : resultingTypes) {
             scopes[i] = type.getMemberScope();
             i++;
         }
 
-        return JetTypeImpl.create(
+        return KtTypeImpl.create(
                 Annotations.Companion.getEMPTY(),
                 constructor,
                 allNullable,
@@ -145,7 +145,7 @@ public class TypeIntersector {
 
     // TODO : check intersectibility, don't use a chanied scope
     private static class IntersectionScope extends ChainedScope {
-        public IntersectionScope(@NotNull TypeConstructor constructor, @NotNull JetScope[] scopes) {
+        public IntersectionScope(@NotNull TypeConstructor constructor, @NotNull KtScope[] scopes) {
             super(null, "member scope for intersection type " + constructor, scopes);
         }
 
@@ -167,11 +167,11 @@ public class TypeIntersector {
             }
         }
 
-        public static boolean mayBeEqual(@NotNull JetType type, @NotNull JetType other) {
+        public static boolean mayBeEqual(@NotNull KtType type, @NotNull KtType other) {
             return unify(type, other);
         }
 
-        private static boolean unify(JetType withParameters, JetType expected) {
+        private static boolean unify(KtType withParameters, KtType expected) {
             // T -> how T is used
             final Map<TypeParameterDescriptor, Variance> parameters = new HashMap<TypeParameterDescriptor, Variance>();
             Function1<TypeParameterUsage, Unit> processor = new Function1<TypeParameterUsage, Unit>() {
@@ -195,7 +195,7 @@ public class TypeIntersector {
             return constraintSystem.getStatus().isSuccessful();
         }
 
-        private static void processAllTypeParameters(JetType type, Variance howThisTypeIsUsed, Function1<TypeParameterUsage, Unit> result) {
+        private static void processAllTypeParameters(KtType type, Variance howThisTypeIsUsed, Function1<TypeParameterUsage, Unit> result) {
             ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
             if (descriptor instanceof TypeParameterDescriptor) {
                 result.invoke(new TypeParameterUsage((TypeParameterDescriptor) descriptor, howThisTypeIsUsed));
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjection.java b/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjection.java
index d2e102efd2b..37d823bacf5 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjection.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjection.java
@@ -23,7 +23,7 @@ public interface TypeProjection {
     Variance getProjectionKind();
 
     @NotNull
-    JetType getType();
+    KtType getType();
 
     boolean isStarProjection();
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjectionImpl.java b/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjectionImpl.java
index cc596f9dab9..410498f87a3 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjectionImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjectionImpl.java
@@ -20,14 +20,14 @@ import org.jetbrains.annotations.NotNull;
 
 public class TypeProjectionImpl extends TypeProjectionBase {
     private final Variance projection;
-    private final JetType type;
+    private final KtType type;
 
-    public TypeProjectionImpl(@NotNull Variance projection, @NotNull JetType type) {
+    public TypeProjectionImpl(@NotNull Variance projection, @NotNull KtType type) {
         this.projection = projection;
         this.type = type;
     }
 
-    public TypeProjectionImpl(@NotNull JetType type) {
+    public TypeProjectionImpl(@NotNull KtType type) {
         this(Variance.INVARIANT, type);
     }
 
@@ -39,7 +39,7 @@ public class TypeProjectionImpl extends TypeProjectionBase {
 
     @Override
     @NotNull
-    public JetType getType() {
+    public KtType getType() {
         return type;
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitution.kt b/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitution.kt
index 47215b38b5f..81978e1bf8b 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitution.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitution.kt
@@ -22,13 +22,13 @@ public abstract class TypeSubstitution {
     companion object {
         @JvmStatic
         public val EMPTY: TypeSubstitution = object : TypeSubstitution() {
-            override fun get(key: JetType) = null
+            override fun get(key: KtType) = null
             override fun isEmpty() = true
             override fun toString() = "Empty TypeSubstitution"
         }
     }
 
-    public abstract fun get(key: JetType): TypeProjection?
+    public abstract fun get(key: KtType): TypeProjection?
 
     public open fun isEmpty(): Boolean = false
 
@@ -38,7 +38,7 @@ public abstract class TypeSubstitution {
 }
 
 public abstract class TypeConstructorSubstitution : TypeSubstitution() {
-    override fun get(key: JetType) = get(key.constructor)
+    override fun get(key: KtType) = get(key.constructor)
 
     public abstract fun get(key: TypeConstructor): TypeProjection?
 
@@ -79,7 +79,7 @@ public class IndexedParametersSubstitution(
 
     override fun isEmpty(): Boolean = arguments.isEmpty()
 
-    override fun get(key: JetType): TypeProjection? {
+    override fun get(key: KtType): TypeProjection? {
         val parameter = key.constructor.declarationDescriptor as? TypeParameterDescriptor ?: return null
         val index = parameter.index
 
@@ -91,7 +91,7 @@ public class IndexedParametersSubstitution(
     }
 }
 
-public fun JetType.computeNewSubstitution(
+public fun KtType.computeNewSubstitution(
     newParameters: List<TypeParameterDescriptor>,
     newArguments: List<TypeProjection>
 ): TypeSubstitution {
@@ -115,7 +115,7 @@ private class CompositeTypeSubstitution(
     private val second: TypeSubstitution
 ) : TypeSubstitution() {
 
-    override fun get(key: JetType): TypeProjection? {
+    override fun get(key: KtType): TypeProjection? {
         val firstResult = first[key] ?: return second[key]
         return second.buildSubstitutor().substitute(firstResult)
     }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitutor.java b/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitutor.java
index cfac87da111..d32896b517f 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitutor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitutor.java
@@ -60,7 +60,7 @@ public class TypeSubstitutor {
     }
 
     @NotNull
-    public static TypeSubstitutor create(@NotNull JetType context) {
+    public static TypeSubstitutor create(@NotNull KtType context) {
         return create(new IndexedParametersSubstitution(context.getConstructor(), context.getArguments()));
     }
 
@@ -82,7 +82,7 @@ public class TypeSubstitutor {
     }
 
     @NotNull
-    public JetType safeSubstitute(@NotNull JetType type, @NotNull Variance howThisTypeIsUsed) {
+    public KtType safeSubstitute(@NotNull KtType type, @NotNull Variance howThisTypeIsUsed) {
         if (isEmpty()) {
             return type;
         }
@@ -95,7 +95,7 @@ public class TypeSubstitutor {
     }
 
     @Nullable
-    public JetType substitute(@NotNull JetType type, @NotNull Variance howThisTypeIsUsed) {
+    public KtType substitute(@NotNull KtType type, @NotNull Variance howThisTypeIsUsed) {
         TypeProjection projection = substitute(new TypeProjectionImpl(howThisTypeIsUsed, type));
         return projection == null ? null : projection.getType();
     }
@@ -129,7 +129,7 @@ public class TypeSubstitutor {
         if (originalProjection.isStarProjection()) return originalProjection;
 
         // The type is within the substitution range, i.e. T or T?
-        JetType type = originalProjection.getType();
+        KtType type = originalProjection.getType();
         TypeProjection replacement = substitution.get(type);
         Variance originalProjectionKind = originalProjection.getProjectionKind();
         if (replacement == null && FlexibleTypesKt.isFlexible(type) && !TypeCapabilitiesKt.isCustomTypeVariable(type)) {
@@ -144,7 +144,7 @@ public class TypeSubstitutor {
                    originalProjectionKind == Variance.INVARIANT || originalProjectionKind == substitutedProjectionKind :
                     "Unexpected substituted projection kind: " + substitutedProjectionKind + "; original: " + originalProjectionKind;
 
-            JetType substitutedFlexibleType = DelegatingFlexibleType.create(
+            KtType substitutedFlexibleType = DelegatingFlexibleType.create(
                     substitutedLower.getType(), substitutedUpper.getType(), flexibility.getExtraCapabilities());
             return new TypeProjectionImpl(substitutedProjectionKind, substitutedFlexibleType);
         }
@@ -168,7 +168,7 @@ public class TypeSubstitutor {
                         return new TypeProjectionImpl(Variance.OUT_VARIANCE, type.getConstructor().getBuiltIns().getNullableAnyType());
                 }
             }
-            JetType substitutedType;
+            KtType substitutedType;
             CustomTypeVariable typeVariable = TypeCapabilitiesKt.getCustomTypeVariable(type);
             if (replacement.isStarProjection()) {
                 return replacement;
@@ -214,7 +214,7 @@ public class TypeSubstitutor {
             TypeProjection originalProjection,
             int recursionDepth
     ) throws SubstitutionException {
-        final JetType type = originalProjection.getType();
+        final KtType type = originalProjection.getType();
         Variance projectionKind = originalProjection.getProjectionKind();
         if (type.getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor) {
             // substitution can't change type parameter
@@ -233,7 +233,7 @@ public class TypeSubstitutor {
 
             @Nullable
             @Override
-            public TypeProjection get(@NotNull JetType key) {
+            public TypeProjection get(@NotNull KtType key) {
                 return containedOrCapturedTypeParameters.contains(key.getConstructor()) ? substitution.get(key) : null;
             }
 
@@ -242,13 +242,13 @@ public class TypeSubstitutor {
                 return substitution.isEmpty();
             }
         };
-        JetType substitutedType = JetTypeImpl.create(type.getAnnotations(),   // Old annotations. This is questionable
-                                           type.getConstructor(),             // The same constructor
-                                           type.isMarkedNullable(),           // Same nullability
-                                           substitutedArguments,
-                                           substitutionFilteringTypeParameters,
-                                           new SubstitutingScope(type.getMemberScope(), create(substitutionFilteringTypeParameters)),
-                                           type.getCapabilities());
+        KtType substitutedType = KtTypeImpl.create(type.getAnnotations(),   // Old annotations. This is questionable
+                                                   type.getConstructor(),             // The same constructor
+                                                   type.isMarkedNullable(),           // Same nullability
+                                                   substitutedArguments,
+                                                   substitutionFilteringTypeParameters,
+                                                   new SubstitutingScope(type.getMemberScope(), create(substitutionFilteringTypeParameters)),
+                                                   type.getCapabilities());
         return new TypeProjectionImpl(projectionKind, substitutedType);
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.java b/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.java
index 6e259c226e8..816d405ea6b 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.java
@@ -26,19 +26,19 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstructor;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.utils.DFS;
 
 import java.util.*;
 
 public class TypeUtils {
-    public static final JetType DONT_CARE = ErrorUtils.createErrorTypeWithCustomDebugName("DONT_CARE");
-    public static final JetType PLACEHOLDER_FUNCTION_TYPE = ErrorUtils.createErrorTypeWithCustomDebugName("PLACEHOLDER_FUNCTION_TYPE");
+    public static final KtType DONT_CARE = ErrorUtils.createErrorTypeWithCustomDebugName("DONT_CARE");
+    public static final KtType PLACEHOLDER_FUNCTION_TYPE = ErrorUtils.createErrorTypeWithCustomDebugName("PLACEHOLDER_FUNCTION_TYPE");
 
-    public static final JetType CANT_INFER_FUNCTION_PARAM_TYPE = ErrorUtils.createErrorType("Cannot be inferred");
+    public static final KtType CANT_INFER_FUNCTION_PARAM_TYPE = ErrorUtils.createErrorType("Cannot be inferred");
 
-    public static class SpecialType implements JetType {
+    public static class SpecialType implements KtType {
         private final String name;
 
         public SpecialType(String name) {
@@ -70,7 +70,7 @@ public class TypeUtils {
 
         @NotNull
         @Override
-        public JetScope getMemberScope() {
+        public KtScope getMemberScope() {
             throw new IllegalStateException(name);
         }
 
@@ -104,30 +104,30 @@ public class TypeUtils {
     }
 
     @NotNull
-    public static final JetType NO_EXPECTED_TYPE = new SpecialType("NO_EXPECTED_TYPE");
+    public static final KtType NO_EXPECTED_TYPE = new SpecialType("NO_EXPECTED_TYPE");
 
-    public static final JetType UNIT_EXPECTED_TYPE = new SpecialType("UNIT_EXPECTED_TYPE");
+    public static final KtType UNIT_EXPECTED_TYPE = new SpecialType("UNIT_EXPECTED_TYPE");
 
-    public static boolean noExpectedType(@NotNull JetType type) {
+    public static boolean noExpectedType(@NotNull KtType type) {
         return type == NO_EXPECTED_TYPE || type == UNIT_EXPECTED_TYPE;
     }
 
-    public static boolean isDontCarePlaceholder(@Nullable JetType type) {
+    public static boolean isDontCarePlaceholder(@Nullable KtType type) {
         return type != null && type.getConstructor() == DONT_CARE.getConstructor();
     }
 
     @NotNull
-    public static JetType makeNullable(@NotNull JetType type) {
+    public static KtType makeNullable(@NotNull KtType type) {
         return makeNullableAsSpecified(type, true);
     }
 
     @NotNull
-    public static JetType makeNotNullable(@NotNull JetType type) {
+    public static KtType makeNotNullable(@NotNull KtType type) {
         return makeNullableAsSpecified(type, false);
     }
 
     @NotNull
-    public static JetType makeNullableAsSpecified(@NotNull JetType type, boolean nullable) {
+    public static KtType makeNullableAsSpecified(@NotNull KtType type, boolean nullable) {
         NullAwareness nullAwareness = type.getCapability(NullAwareness.class);
         if (nullAwareness != null) {
             return nullAwareness.makeNullableAsSpecified(nullable);
@@ -151,14 +151,14 @@ public class TypeUtils {
     }
 
     @NotNull
-    public static JetType makeNullableIfNeeded(@NotNull JetType type, boolean nullable) {
+    public static KtType makeNullableIfNeeded(@NotNull KtType type, boolean nullable) {
         if (nullable) {
             return makeNullable(type);
         }
         return type;
     }
 
-    public static boolean canHaveSubtypes(JetTypeChecker typeChecker, @NotNull JetType type) {
+    public static boolean canHaveSubtypes(KotlinTypeChecker typeChecker, @NotNull KtType type) {
         if (type.isMarkedNullable()) {
             return true;
         }
@@ -172,7 +172,7 @@ public class TypeUtils {
             TypeParameterDescriptor parameterDescriptor = parameters.get(i);
             TypeProjection typeProjection = arguments.get(i);
             Variance projectionKind = typeProjection.getProjectionKind();
-            JetType argument = typeProjection.getType();
+            KtType argument = typeProjection.getType();
 
             switch (parameterDescriptor.getVariance()) {
                 case INVARIANT:
@@ -223,8 +223,8 @@ public class TypeUtils {
         return false;
     }
 
-    private static boolean lowerThanBound(JetTypeChecker typeChecker, JetType argument, TypeParameterDescriptor parameterDescriptor) {
-        for (JetType bound : parameterDescriptor.getUpperBounds()) {
+    private static boolean lowerThanBound(KotlinTypeChecker typeChecker, KtType argument, TypeParameterDescriptor parameterDescriptor) {
+        for (KtType bound : parameterDescriptor.getUpperBounds()) {
             if (typeChecker.isSubtypeOf(argument, bound)) {
                 if (!argument.getConstructor().equals(bound.getConstructor())) {
                     return true;
@@ -235,13 +235,13 @@ public class TypeUtils {
     }
 
     @NotNull
-    public static JetType makeUnsubstitutedType(ClassDescriptor classDescriptor, JetScope unsubstitutedMemberScope) {
+    public static KtType makeUnsubstitutedType(ClassDescriptor classDescriptor, KtScope unsubstitutedMemberScope) {
         if (ErrorUtils.isError(classDescriptor)) {
             return ErrorUtils.createErrorType("Unsubstituted type for " + classDescriptor);
         }
         TypeConstructor typeConstructor = classDescriptor.getTypeConstructor();
         List<TypeProjection> arguments = getDefaultTypeProjections(typeConstructor.getParameters());
-        return JetTypeImpl.create(
+        return KtTypeImpl.create(
                 Annotations.Companion.getEMPTY(),
                 typeConstructor,
                 false,
@@ -260,13 +260,13 @@ public class TypeUtils {
     }
 
     @NotNull
-    public static List<JetType> getImmediateSupertypes(@NotNull JetType type) {
+    public static List<KtType> getImmediateSupertypes(@NotNull KtType type) {
         boolean isNullable = type.isMarkedNullable();
         TypeSubstitutor substitutor = TypeSubstitutor.create(type);
-        Collection<JetType> originalSupertypes = type.getConstructor().getSupertypes();
-        List<JetType> result = new ArrayList<JetType>(originalSupertypes.size());
-        for (JetType supertype : originalSupertypes) {
-            JetType substitutedType = substitutor.substitute(supertype, Variance.INVARIANT);
+        Collection<KtType> originalSupertypes = type.getConstructor().getSupertypes();
+        List<KtType> result = new ArrayList<KtType>(originalSupertypes.size());
+        for (KtType supertype : originalSupertypes) {
+            KtType substitutedType = substitutor.substitute(supertype, Variance.INVARIANT);
             if (substitutedType != null) {
                 result.add(makeNullableIfNeeded(substitutedType, isNullable));
             }
@@ -274,26 +274,26 @@ public class TypeUtils {
         return result;
     }
 
-    private static void collectAllSupertypes(@NotNull JetType type, @NotNull Set<JetType> result) {
-        List<JetType> immediateSupertypes = getImmediateSupertypes(type);
+    private static void collectAllSupertypes(@NotNull KtType type, @NotNull Set<KtType> result) {
+        List<KtType> immediateSupertypes = getImmediateSupertypes(type);
         result.addAll(immediateSupertypes);
-        for (JetType supertype : immediateSupertypes) {
+        for (KtType supertype : immediateSupertypes) {
             collectAllSupertypes(supertype, result);
         }
     }
 
 
     @NotNull
-    public static Set<JetType> getAllSupertypes(@NotNull JetType type) {
+    public static Set<KtType> getAllSupertypes(@NotNull KtType type) {
         // 15 is obtained by experimentation: JDK classes like ArrayList tend to have so many supertypes,
         // the average number is lower
-        Set<JetType> result = new LinkedHashSet<JetType>(15);
+        Set<KtType> result = new LinkedHashSet<KtType>(15);
         collectAllSupertypes(type, result);
         return result;
     }
 
     public static boolean hasNullableLowerBound(@NotNull TypeParameterDescriptor typeParameterDescriptor) {
-        for (JetType bound : typeParameterDescriptor.getLowerBounds()) {
+        for (KtType bound : typeParameterDescriptor.getLowerBounds()) {
             if (bound.isMarkedNullable()) {
                 return true;
             }
@@ -306,7 +306,7 @@ public class TypeUtils {
      * Semantics should be the same as `!isSubtype(T, Any)`
      * @return true if a value of this type can be null
      */
-    public static boolean isNullableType(@NotNull JetType type) {
+    public static boolean isNullableType(@NotNull KtType type) {
         if (type.isMarkedNullable()) {
             return true;
         }
@@ -324,7 +324,7 @@ public class TypeUtils {
      * Semantics should be the same as `isSubtype(Nothing?, T)`
      * @return true if `null` can be assigned to storage of this type
      */
-    public static boolean acceptsNullable(@NotNull JetType type) {
+    public static boolean acceptsNullable(@NotNull KtType type) {
         if (type.isMarkedNullable()) {
             return true;
         }
@@ -337,13 +337,13 @@ public class TypeUtils {
         return false;
     }
 
-    public static boolean hasNullableSuperType(@NotNull JetType type) {
+    public static boolean hasNullableSuperType(@NotNull KtType type) {
         if (type.getConstructor().getDeclarationDescriptor() instanceof ClassDescriptor) {
             // A class/trait cannot have a nullable supertype
             return false;
         }
 
-        for (JetType supertype : getImmediateSupertypes(type)) {
+        for (KtType supertype : getImmediateSupertypes(type)) {
             if (supertype.isMarkedNullable()) return true;
             if (hasNullableSuperType(supertype)) return true;
         }
@@ -352,7 +352,7 @@ public class TypeUtils {
     }
 
     @Nullable
-    public static ClassDescriptor getClassDescriptor(@NotNull JetType type) {
+    public static ClassDescriptor getClassDescriptor(@NotNull KtType type) {
         DeclarationDescriptor declarationDescriptor = type.getConstructor().getDeclarationDescriptor();
         if (declarationDescriptor instanceof ClassDescriptor) {
             return (ClassDescriptor) declarationDescriptor;
@@ -361,10 +361,10 @@ public class TypeUtils {
     }
 
     @NotNull
-    public static JetType substituteParameters(@NotNull ClassDescriptor clazz, @NotNull List<JetType> typeArguments) {
-        List<TypeProjection> projections = CollectionsKt.map(typeArguments, new Function1<JetType, TypeProjection>() {
+    public static KtType substituteParameters(@NotNull ClassDescriptor clazz, @NotNull List<KtType> typeArguments) {
+        List<TypeProjection> projections = CollectionsKt.map(typeArguments, new Function1<KtType, TypeProjection>() {
             @Override
-            public TypeProjection invoke(JetType type) {
+            public TypeProjection invoke(KtType type) {
                 return new TypeProjectionImpl(type);
             }
         });
@@ -373,7 +373,7 @@ public class TypeUtils {
     }
 
     @NotNull
-    public static JetType substituteProjectionsForParameters(@NotNull ClassDescriptor clazz, @NotNull List<TypeProjection> projections) {
+    public static KtType substituteProjectionsForParameters(@NotNull ClassDescriptor clazz, @NotNull List<TypeProjection> projections) {
         List<TypeParameterDescriptor> clazzTypeParameters = clazz.getTypeConstructor().getParameters();
         if (clazzTypeParameters.size() != projections.size()) {
             throw new IllegalArgumentException("type parameter counts do not match: " + clazz + ", " + projections);
@@ -390,11 +390,11 @@ public class TypeUtils {
         return TypeSubstitutor.create(substitutions).substitute(clazz.getDefaultType(), Variance.INVARIANT);
     }
 
-    public static boolean equalTypes(@NotNull JetType a, @NotNull JetType b) {
-        return JetTypeChecker.DEFAULT.isSubtypeOf(a, b) && JetTypeChecker.DEFAULT.isSubtypeOf(b, a);
+    public static boolean equalTypes(@NotNull KtType a, @NotNull KtType b) {
+        return KotlinTypeChecker.DEFAULT.isSubtypeOf(a, b) && KotlinTypeChecker.DEFAULT.isSubtypeOf(b, a);
     }
 
-    public static boolean dependsOnTypeParameters(@NotNull JetType type, @NotNull Collection<TypeParameterDescriptor> typeParameters) {
+    public static boolean dependsOnTypeParameters(@NotNull KtType type, @NotNull Collection<TypeParameterDescriptor> typeParameters) {
         return dependsOnTypeConstructors(type, CollectionsKt.map(
                 typeParameters,
                 new Function1<TypeParameterDescriptor, TypeConstructor>() {
@@ -406,7 +406,7 @@ public class TypeUtils {
         ));
     }
 
-    public static boolean dependsOnTypeConstructors(@NotNull JetType type, @NotNull Collection<TypeConstructor> typeParameterConstructors) {
+    public static boolean dependsOnTypeConstructors(@NotNull KtType type, @NotNull Collection<TypeConstructor> typeParameterConstructors) {
         if (typeParameterConstructors.contains(type.getConstructor())) return true;
         for (TypeProjection typeProjection : type.getArguments()) {
             if (!typeProjection.isStarProjection() && dependsOnTypeConstructors(typeProjection.getType(), typeParameterConstructors)) {
@@ -416,18 +416,18 @@ public class TypeUtils {
         return false;
     }
 
-    public static boolean containsSpecialType(@Nullable JetType type, @NotNull final JetType specialType) {
-        return containsSpecialType(type, new Function1<JetType, Boolean>() {
+    public static boolean containsSpecialType(@Nullable KtType type, @NotNull final KtType specialType) {
+        return containsSpecialType(type, new Function1<KtType, Boolean>() {
             @Override
-            public Boolean invoke(JetType type) {
+            public Boolean invoke(KtType type) {
                 return specialType.equals(type);
             }
         });
     }
 
     public static boolean containsSpecialType(
-            @Nullable JetType type,
-            @NotNull Function1<JetType, Boolean> isSpecialType
+            @Nullable KtType type,
+            @NotNull Function1<KtType, Boolean> isSpecialType
     ) {
         if (type == null) return false;
         if (isSpecialType.invoke(type)) return true;
@@ -448,10 +448,10 @@ public class TypeUtils {
     }
 
     @Nullable
-    public static JetType commonSupertypeForNumberTypes(@NotNull Collection<JetType> numberLowerBounds) {
+    public static KtType commonSupertypeForNumberTypes(@NotNull Collection<KtType> numberLowerBounds) {
         if (numberLowerBounds.isEmpty()) return null;
-        Set<JetType> intersectionOfSupertypes = getIntersectionOfSupertypes(numberLowerBounds);
-        JetType primitiveNumberType = getDefaultPrimitiveNumberType(intersectionOfSupertypes);
+        Set<KtType> intersectionOfSupertypes = getIntersectionOfSupertypes(numberLowerBounds);
+        KtType primitiveNumberType = getDefaultPrimitiveNumberType(intersectionOfSupertypes);
         if (primitiveNumberType != null) {
             return primitiveNumberType;
         }
@@ -459,10 +459,10 @@ public class TypeUtils {
     }
 
     @NotNull
-    private static Set<JetType> getIntersectionOfSupertypes(@NotNull Collection<JetType> types) {
-        Set<JetType> upperBounds = new HashSet<JetType>();
-        for (JetType type : types) {
-            Collection<JetType> supertypes = type.getConstructor().getSupertypes();
+    private static Set<KtType> getIntersectionOfSupertypes(@NotNull Collection<KtType> types) {
+        Set<KtType> upperBounds = new HashSet<KtType>();
+        for (KtType type : types) {
+            Collection<KtType> supertypes = type.getConstructor().getSupertypes();
             if (upperBounds.isEmpty()) {
                 upperBounds.addAll(supertypes);
             }
@@ -474,29 +474,29 @@ public class TypeUtils {
     }
 
     @NotNull
-    public static JetType getDefaultPrimitiveNumberType(@NotNull IntegerValueTypeConstructor numberValueTypeConstructor) {
-        JetType type = getDefaultPrimitiveNumberType(numberValueTypeConstructor.getSupertypes());
+    public static KtType getDefaultPrimitiveNumberType(@NotNull IntegerValueTypeConstructor numberValueTypeConstructor) {
+        KtType type = getDefaultPrimitiveNumberType(numberValueTypeConstructor.getSupertypes());
         assert type != null : "Strange number value type constructor: " + numberValueTypeConstructor + ". " +
                               "Super types doesn't contain double, int or long: " + numberValueTypeConstructor.getSupertypes();
         return type;
     }
 
     @Nullable
-    private static JetType getDefaultPrimitiveNumberType(@NotNull Collection<JetType> supertypes) {
+    private static KtType getDefaultPrimitiveNumberType(@NotNull Collection<KtType> supertypes) {
         if (supertypes.isEmpty()) {
             return null;
         }
 
         KotlinBuiltIns builtIns = supertypes.iterator().next().getConstructor().getBuiltIns();
-        JetType doubleType = builtIns.getDoubleType();
+        KtType doubleType = builtIns.getDoubleType();
         if (supertypes.contains(doubleType)) {
             return doubleType;
         }
-        JetType intType = builtIns.getIntType();
+        KtType intType = builtIns.getIntType();
         if (supertypes.contains(intType)) {
             return intType;
         }
-        JetType longType = builtIns.getLongType();
+        KtType longType = builtIns.getLongType();
         if (supertypes.contains(longType)) {
             return longType;
         }
@@ -504,15 +504,15 @@ public class TypeUtils {
     }
 
     @NotNull
-    public static JetType getPrimitiveNumberType(
+    public static KtType getPrimitiveNumberType(
             @NotNull IntegerValueTypeConstructor numberValueTypeConstructor,
-            @NotNull JetType expectedType
+            @NotNull KtType expectedType
     ) {
         if (noExpectedType(expectedType) || expectedType.isError()) {
             return getDefaultPrimitiveNumberType(numberValueTypeConstructor);
         }
-        for (JetType primitiveNumberType : numberValueTypeConstructor.getSupertypes()) {
-            if (JetTypeChecker.DEFAULT.isSubtypeOf(primitiveNumberType, expectedType)) {
+        for (KtType primitiveNumberType : numberValueTypeConstructor.getSupertypes()) {
+            if (KotlinTypeChecker.DEFAULT.isSubtypeOf(primitiveNumberType, expectedType)) {
                 return primitiveNumberType;
             }
         }
@@ -520,20 +520,20 @@ public class TypeUtils {
     }
 
     public static List<TypeConstructor> topologicallySortSuperclassesAndRecordAllInstances(
-            @NotNull JetType type,
-            @NotNull final Map<TypeConstructor, Set<JetType>> constructorToAllInstances,
+            @NotNull KtType type,
+            @NotNull final Map<TypeConstructor, Set<KtType>> constructorToAllInstances,
             @NotNull final Set<TypeConstructor> visited
     ) {
         return DFS.dfs(
                 Collections.singletonList(type),
-                new DFS.Neighbors<JetType>() {
+                new DFS.Neighbors<KtType>() {
                     @NotNull
                     @Override
-                    public Iterable<JetType> getNeighbors(JetType current) {
+                    public Iterable<KtType> getNeighbors(KtType current) {
                         TypeSubstitutor substitutor = TypeSubstitutor.create(current);
-                        Collection<JetType> supertypes = current.getConstructor().getSupertypes();
-                        List<JetType> result = new ArrayList<JetType>(supertypes.size());
-                        for (JetType supertype : supertypes) {
+                        Collection<KtType> supertypes = current.getConstructor().getSupertypes();
+                        List<KtType> result = new ArrayList<KtType>(supertypes.size());
+                        for (KtType supertype : supertypes) {
                             if (visited.contains(supertype.getConstructor())) {
                                 continue;
                             }
@@ -542,20 +542,20 @@ public class TypeUtils {
                         return result;
                     }
                 },
-                new DFS.Visited<JetType>() {
+                new DFS.Visited<KtType>() {
                     @Override
-                    public boolean checkAndMarkVisited(JetType current) {
+                    public boolean checkAndMarkVisited(KtType current) {
                         return visited.add(current.getConstructor());
                     }
                 },
-                new DFS.NodeHandlerWithListResult<JetType, TypeConstructor>() {
+                new DFS.NodeHandlerWithListResult<KtType, TypeConstructor>() {
                     @Override
-                    public boolean beforeChildren(JetType current) {
+                    public boolean beforeChildren(KtType current) {
                         TypeConstructor constructor = current.getConstructor();
 
-                        Set<JetType> instances = constructorToAllInstances.get(constructor);
+                        Set<KtType> instances = constructorToAllInstances.get(constructor);
                         if (instances == null) {
-                            instances = new HashSet<JetType>();
+                            instances = new HashSet<KtType>();
                             constructorToAllInstances.put(constructor, instances);
                         }
                         instances.add(current);
@@ -564,14 +564,14 @@ public class TypeUtils {
                     }
 
                     @Override
-                    public void afterChildren(JetType current) {
+                    public void afterChildren(KtType current) {
                         result.addFirst(current.getConstructor());
                     }
                 }
         );
     }
 
-    public static TypeSubstitutor makeConstantSubstitutor(Collection<TypeParameterDescriptor> typeParameterDescriptors, JetType type) {
+    public static TypeSubstitutor makeConstantSubstitutor(Collection<TypeParameterDescriptor> typeParameterDescriptors, KtType type) {
         final Set<TypeConstructor> constructors = org.jetbrains.kotlin.utils.CollectionsKt
                 .newHashSetWithExpectedSize(typeParameterDescriptors.size());
         for (TypeParameterDescriptor typeParameterDescriptor : typeParameterDescriptors) {
@@ -595,27 +595,27 @@ public class TypeUtils {
         });
     }
 
-    public static boolean isTypeParameter(@NotNull JetType type) {
+    public static boolean isTypeParameter(@NotNull KtType type) {
         return getTypeParameterDescriptorOrNull(type) != null;
     }
 
-    public static boolean isNonReifiedTypeParemeter(@NotNull JetType type) {
+    public static boolean isNonReifiedTypeParemeter(@NotNull KtType type) {
         TypeParameterDescriptor typeParameterDescriptor = getTypeParameterDescriptorOrNull(type);
         return typeParameterDescriptor != null && !typeParameterDescriptor.isReified();
     }
 
     @Nullable
-    public static TypeParameterDescriptor getTypeParameterDescriptorOrNull(@NotNull JetType type) {
+    public static TypeParameterDescriptor getTypeParameterDescriptorOrNull(@NotNull KtType type) {
         if (type.getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor) {
             return (TypeParameterDescriptor) type.getConstructor().getDeclarationDescriptor();
         }
         return null;
     }
 
-    private static abstract class AbstractTypeWithKnownNullability extends AbstractJetType {
-        private final JetType delegate;
+    private static abstract class AbstractTypeWithKnownNullability extends AbstractKtType {
+        private final KtType delegate;
 
-        private AbstractTypeWithKnownNullability(@NotNull JetType delegate) {
+        private AbstractTypeWithKnownNullability(@NotNull KtType delegate) {
             this.delegate = delegate;
         }
 
@@ -636,7 +636,7 @@ public class TypeUtils {
 
         @Override
         @NotNull
-        public JetScope getMemberScope() {
+        public KtScope getMemberScope() {
             return delegate.getMemberScope();
         }
 
@@ -672,7 +672,7 @@ public class TypeUtils {
 
     private static class NullableType extends AbstractTypeWithKnownNullability {
 
-        private NullableType(@NotNull JetType delegate) {
+        private NullableType(@NotNull KtType delegate) {
             super(delegate);
         }
 
@@ -684,7 +684,7 @@ public class TypeUtils {
 
     private static class NotNullType extends AbstractTypeWithKnownNullability {
 
-        private NotNullType(@NotNull JetType delegate) {
+        private NotNullType(@NotNull KtType delegate) {
             super(delegate);
         }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.kt b/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.kt
index f4b613c93b3..205503effac 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.utils.toReadOnlyList
 import java.util.ArrayDeque
 import java.util.ArrayList
@@ -35,7 +35,7 @@ public enum class TypeNullability {
     FLEXIBLE
 }
 
-public fun JetType.nullability(): TypeNullability {
+public fun KtType.nullability(): TypeNullability {
     return when {
         isNullabilityFlexible() -> TypeNullability.FLEXIBLE
         TypeUtils.isNullableType(this) -> TypeNullability.NULLABLE
@@ -43,22 +43,22 @@ public fun JetType.nullability(): TypeNullability {
     }
 }
 
-val JetType.builtIns: KotlinBuiltIns
+val KtType.builtIns: KotlinBuiltIns
     get() = constructor.builtIns
 
-fun JetType.makeNullable() = TypeUtils.makeNullable(this)
-fun JetType.makeNotNullable() = TypeUtils.makeNotNullable(this)
+fun KtType.makeNullable() = TypeUtils.makeNullable(this)
+fun KtType.makeNotNullable() = TypeUtils.makeNotNullable(this)
 
-fun JetType.immediateSupertypes(): Collection<JetType> = TypeUtils.getImmediateSupertypes(this)
-fun JetType.supertypes(): Collection<JetType> = TypeUtils.getAllSupertypes(this)
+fun KtType.immediateSupertypes(): Collection<KtType> = TypeUtils.getImmediateSupertypes(this)
+fun KtType.supertypes(): Collection<KtType> = TypeUtils.getAllSupertypes(this)
 
-fun JetType.isNothing(): Boolean = KotlinBuiltIns.isNothing(this)
-fun JetType.isUnit(): Boolean = KotlinBuiltIns.isUnit(this)
-fun JetType.isAnyOrNullableAny(): Boolean = KotlinBuiltIns.isAnyOrNullableAny(this)
-fun JetType.isBoolean(): Boolean = KotlinBuiltIns.isBoolean(this)
-fun JetType.isBooleanOrNullableBoolean(): Boolean = KotlinBuiltIns.isBooleanOrNullableBoolean(this)
+fun KtType.isNothing(): Boolean = KotlinBuiltIns.isNothing(this)
+fun KtType.isUnit(): Boolean = KotlinBuiltIns.isUnit(this)
+fun KtType.isAnyOrNullableAny(): Boolean = KotlinBuiltIns.isAnyOrNullableAny(this)
+fun KtType.isBoolean(): Boolean = KotlinBuiltIns.isBoolean(this)
+fun KtType.isBooleanOrNullableBoolean(): Boolean = KotlinBuiltIns.isBooleanOrNullableBoolean(this)
 
-private fun JetType.getContainedTypeParameters(): Collection<TypeParameterDescriptor> {
+private fun KtType.getContainedTypeParameters(): Collection<TypeParameterDescriptor> {
     val declarationDescriptor = getConstructor().getDeclarationDescriptor()
     if (declarationDescriptor is TypeParameterDescriptor) return listOf(declarationDescriptor)
 
@@ -85,24 +85,24 @@ fun DeclarationDescriptor.getCapturedTypeParameters(): Collection<TypeParameterD
     return result
 }
 
-public fun JetType.getContainedAndCapturedTypeParameterConstructors(): Collection<TypeConstructor> {
+public fun KtType.getContainedAndCapturedTypeParameterConstructors(): Collection<TypeConstructor> {
     // todo type arguments (instead of type parameters) of the type of outer class must be considered; KT-6325
     val capturedTypeParameters = getConstructor().getDeclarationDescriptor()?.getCapturedTypeParameters() ?: emptyList()
     val typeParameters = getContainedTypeParameters() + capturedTypeParameters
     return typeParameters.map { it.getTypeConstructor() }.toReadOnlyList()
 }
 
-public fun JetType.isSubtypeOf(superType: JetType): Boolean = JetTypeChecker.DEFAULT.isSubtypeOf(this, superType)
+public fun KtType.isSubtypeOf(superType: KtType): Boolean = KotlinTypeChecker.DEFAULT.isSubtypeOf(this, superType)
 
-public fun JetType.cannotBeReified(): Boolean = KotlinBuiltIns.isNothingOrNullableNothing(this) || this.isDynamic()
+public fun KtType.cannotBeReified(): Boolean = KotlinBuiltIns.isNothingOrNullableNothing(this) || this.isDynamic()
 
-fun TypeProjection.substitute(doSubstitute: (JetType) -> JetType): TypeProjection {
+fun TypeProjection.substitute(doSubstitute: (KtType) -> KtType): TypeProjection {
     return if (isStarProjection())
         this
     else TypeProjectionImpl(getProjectionKind(), doSubstitute(getType()))
 }
 
-fun JetType.replaceAnnotations(newAnnotations: Annotations): JetType {
+fun KtType.replaceAnnotations(newAnnotations: Annotations): KtType {
     if (newAnnotations.isEmpty()) return this
     return object : DelegatingType() {
         override fun getDelegate() = this@replaceAnnotations
@@ -111,13 +111,13 @@ fun JetType.replaceAnnotations(newAnnotations: Annotations): JetType {
     }
 }
 
-public fun JetTypeChecker.equalTypesOrNulls(type1: JetType?, type2: JetType?): Boolean {
+public fun KotlinTypeChecker.equalTypesOrNulls(type1: KtType?, type2: KtType?): Boolean {
     if (type1 === type2) return true
     if (type1 == null || type2 == null) return false
     return equalTypes(type1, type2)
 }
 
-fun JetType.getNestedArguments(): List<TypeProjection> {
+fun KtType.getNestedArguments(): List<TypeProjection> {
     val result = ArrayList<TypeProjection>()
 
     val stack = ArrayDeque<TypeProjection>()
@@ -134,11 +134,11 @@ fun JetType.getNestedArguments(): List<TypeProjection> {
     return result
 }
 
-fun JetType.containsError() = ErrorUtils.containsErrorType(this)
+fun KtType.containsError() = ErrorUtils.containsErrorType(this)
 
-public fun List<JetType>.defaultProjections(): List<TypeProjection> = map { TypeProjectionImpl(it) }
+public fun List<KtType>.defaultProjections(): List<TypeProjection> = map { TypeProjectionImpl(it) }
 
-public fun JetType.isDefaultBound(): Boolean = KotlinBuiltIns.isDefaultBound(getSupertypeRepresentative())
+public fun KtType.isDefaultBound(): Boolean = KotlinBuiltIns.isDefaultBound(getSupertypeRepresentative())
 
-public fun createProjection(type: JetType, projectionKind: Variance, typeParameterDescriptor: TypeParameterDescriptor?): TypeProjection =
+public fun createProjection(type: KtType, projectionKind: Variance, typeParameterDescriptor: TypeParameterDescriptor?): TypeProjection =
         TypeProjectionImpl(if (typeParameterDescriptor?.variance == projectionKind) Variance.INVARIANT else projectionKind, type)
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/checker/JetTypeChecker.java b/core/descriptors/src/org/jetbrains/kotlin/types/checker/KotlinTypeChecker.java
similarity index 56%
rename from core/descriptors/src/org/jetbrains/kotlin/types/checker/JetTypeChecker.java
rename to core/descriptors/src/org/jetbrains/kotlin/types/checker/KotlinTypeChecker.java
index 72901df2548..f6fb258cb47 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/checker/JetTypeChecker.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/checker/KotlinTypeChecker.java
@@ -17,34 +17,34 @@
 package org.jetbrains.kotlin.types.checker;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeConstructor;
 
-public class JetTypeChecker {
+public class KotlinTypeChecker {
 
     public interface TypeConstructorEquality {
         boolean equals(@NotNull TypeConstructor a, @NotNull TypeConstructor b);
     }
 
-    public static final JetTypeChecker DEFAULT = new JetTypeChecker(new TypeCheckingProcedure(new TypeCheckerProcedureCallbacksImpl()));
+    public static final KotlinTypeChecker DEFAULT = new KotlinTypeChecker(new TypeCheckingProcedure(new TypeCheckerProcedureCallbacksImpl()));
 
-    public static final JetTypeChecker ERROR_TYPES_ARE_EQUAL_TO_ANYTHING = new JetTypeChecker(new TypeCheckingProcedure(new TypeCheckerProcedureCallbacksImpl() {
+    public static final KotlinTypeChecker ERROR_TYPES_ARE_EQUAL_TO_ANYTHING = new KotlinTypeChecker(new TypeCheckingProcedure(new TypeCheckerProcedureCallbacksImpl() {
         @Override
-        public boolean assertEqualTypes(@NotNull JetType a, @NotNull JetType b, @NotNull TypeCheckingProcedure typeCheckingProcedure) {
+        public boolean assertEqualTypes(@NotNull KtType a, @NotNull KtType b, @NotNull TypeCheckingProcedure typeCheckingProcedure) {
             return a.isError() || b.isError() || super.assertEqualTypes(a, b, typeCheckingProcedure);
         }
     }));
 
-    public static final JetTypeChecker FLEXIBLE_UNEQUAL_TO_INFLEXIBLE = new JetTypeChecker(new TypeCheckingProcedure(new TypeCheckerProcedureCallbacksImpl()) {
+    public static final KotlinTypeChecker FLEXIBLE_UNEQUAL_TO_INFLEXIBLE = new KotlinTypeChecker(new TypeCheckingProcedure(new TypeCheckerProcedureCallbacksImpl()) {
         @Override
-        protected boolean heterogeneousEquivalence(JetType inflexibleType, JetType flexibleType) {
+        protected boolean heterogeneousEquivalence(KtType inflexibleType, KtType flexibleType) {
             return false;
         }
     });
 
     @NotNull
-    public static JetTypeChecker withAxioms(@NotNull final TypeConstructorEquality equalityAxioms) {
-        return new JetTypeChecker(new TypeCheckingProcedure(new TypeCheckerProcedureCallbacksImpl() {
+    public static KotlinTypeChecker withAxioms(@NotNull final TypeConstructorEquality equalityAxioms) {
+        return new KotlinTypeChecker(new TypeCheckingProcedure(new TypeCheckerProcedureCallbacksImpl() {
             @Override
             public boolean assertEqualTypeConstructors(@NotNull TypeConstructor constructor1, @NotNull TypeConstructor constructor2) {
                 return constructor1.equals(constructor2) || equalityAxioms.equals(constructor1, constructor2);
@@ -54,15 +54,15 @@ public class JetTypeChecker {
 
     private final TypeCheckingProcedure procedure;
 
-    private JetTypeChecker(@NotNull TypeCheckingProcedure procedure) {
+    private KotlinTypeChecker(@NotNull TypeCheckingProcedure procedure) {
         this.procedure = procedure;
     }
 
-    public boolean isSubtypeOf(@NotNull JetType subtype, @NotNull JetType supertype) {
+    public boolean isSubtypeOf(@NotNull KtType subtype, @NotNull KtType supertype) {
         return procedure.isSubtypeOf(subtype, supertype);
     }
 
-    public boolean equalTypes(@NotNull JetType a, @NotNull JetType b) {
+    public boolean equalTypes(@NotNull KtType a, @NotNull KtType b) {
         return procedure.equalTypes(a, b);
     }
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckerProcedureCallbacksImpl.java b/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckerProcedureCallbacksImpl.java
index 576f4c32cbd..6d3f1720477 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckerProcedureCallbacksImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckerProcedureCallbacksImpl.java
@@ -17,13 +17,13 @@
 package org.jetbrains.kotlin.types.checker;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeConstructor;
 import org.jetbrains.kotlin.types.TypeProjection;
 
 class TypeCheckerProcedureCallbacksImpl implements TypeCheckingProcedureCallbacks {
     @Override
-    public boolean assertEqualTypes(@NotNull JetType a, @NotNull JetType b, @NotNull TypeCheckingProcedure typeCheckingProcedure) {
+    public boolean assertEqualTypes(@NotNull KtType a, @NotNull KtType b, @NotNull TypeCheckingProcedure typeCheckingProcedure) {
         return typeCheckingProcedure.equalTypes(a, b);
     }
 
@@ -33,17 +33,17 @@ class TypeCheckerProcedureCallbacksImpl implements TypeCheckingProcedureCallback
     }
 
     @Override
-    public boolean assertSubtype(@NotNull JetType subtype, @NotNull JetType supertype, @NotNull TypeCheckingProcedure typeCheckingProcedure) {
+    public boolean assertSubtype(@NotNull KtType subtype, @NotNull KtType supertype, @NotNull TypeCheckingProcedure typeCheckingProcedure) {
         return typeCheckingProcedure.isSubtypeOf(subtype, supertype);
     }
 
     @Override
-    public boolean capture(@NotNull JetType type, @NotNull TypeProjection typeProjection) {
+    public boolean capture(@NotNull KtType type, @NotNull TypeProjection typeProjection) {
         return false;
     }
 
     @Override
-    public boolean noCorrespondingSupertype(@NotNull JetType subtype, @NotNull JetType supertype) {
+    public boolean noCorrespondingSupertype(@NotNull KtType subtype, @NotNull KtType supertype) {
         return false; // type checking fails
     }
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckingProcedure.java b/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckingProcedure.java
index cc9fbc9eb41..197bda5426b 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckingProcedure.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckingProcedure.java
@@ -32,23 +32,23 @@ public class TypeCheckingProcedure {
     // This method returns the supertype of the first parameter that has the same constructor
     // as the second parameter, applying the substitution of type arguments to it
     @Nullable
-    public static JetType findCorrespondingSupertype(@NotNull JetType subtype, @NotNull JetType supertype) {
+    public static KtType findCorrespondingSupertype(@NotNull KtType subtype, @NotNull KtType supertype) {
         return findCorrespondingSupertype(subtype, supertype, new TypeCheckerProcedureCallbacksImpl());
     }
 
     // This method returns the supertype of the first parameter that has the same constructor
     // as the second parameter, applying the substitution of type arguments to it
     @Nullable
-    public static JetType findCorrespondingSupertype(@NotNull JetType subtype, @NotNull JetType supertype, @NotNull TypeCheckingProcedureCallbacks typeCheckingProcedureCallbacks) {
+    public static KtType findCorrespondingSupertype(@NotNull KtType subtype, @NotNull KtType supertype, @NotNull TypeCheckingProcedureCallbacks typeCheckingProcedureCallbacks) {
         return UtilsKt.findCorrespondingSupertype(subtype, supertype, typeCheckingProcedureCallbacks);
     }
 
-    public static JetType getOutType(TypeParameterDescriptor parameter, TypeProjection argument) {
+    public static KtType getOutType(TypeParameterDescriptor parameter, TypeProjection argument) {
         boolean isOutProjected = argument.getProjectionKind() == IN_VARIANCE || parameter.getVariance() == IN_VARIANCE;
         return isOutProjected ? parameter.getUpperBoundsAsType() : argument.getType();
     }
 
-    public static JetType getInType(@NotNull TypeParameterDescriptor parameter, @NotNull TypeProjection argument) {
+    public static KtType getInType(@NotNull TypeParameterDescriptor parameter, @NotNull TypeProjection argument) {
         boolean isOutProjected = argument.getProjectionKind() == OUT_VARIANCE || parameter.getVariance() == OUT_VARIANCE;
         return isOutProjected ? DescriptorUtilsKt.getBuiltIns(parameter).getNothingType() : argument.getType();
     }
@@ -59,7 +59,7 @@ public class TypeCheckingProcedure {
         this.constraints = constraints;
     }
 
-    public boolean equalTypes(@NotNull JetType type1, @NotNull JetType type2) {
+    public boolean equalTypes(@NotNull KtType type1, @NotNull KtType type2) {
         if (type1 == type2) return true;
         if (FlexibleTypesKt.isFlexible(type1)) {
             if (FlexibleTypesKt.isFlexible(type2)) {
@@ -116,7 +116,7 @@ public class TypeCheckingProcedure {
         return true;
     }
 
-    protected boolean heterogeneousEquivalence(JetType inflexibleType, JetType flexibleType) {
+    protected boolean heterogeneousEquivalence(KtType inflexibleType, KtType flexibleType) {
         // This is to account for the case when we have Collection<X> vs (Mutable)Collection<X>! or K(java.util.Collection<? extends X>)
         assert !FlexibleTypesKt.isFlexible(inflexibleType) : "Only inflexible types are allowed here: " + inflexibleType;
         return isSubtypeOf(FlexibleTypesKt.flexibility(flexibleType).getLowerBound(), inflexibleType)
@@ -178,12 +178,12 @@ public class TypeCheckingProcedure {
         return EnrichedProjectionKind.fromVariance(b);
     }
 
-    public boolean isSubtypeOf(@NotNull JetType subtype, @NotNull JetType supertype) {
+    public boolean isSubtypeOf(@NotNull KtType subtype, @NotNull KtType supertype) {
         if (TypeCapabilitiesKt.sameTypeConstructors(subtype, supertype)) {
             return !subtype.isMarkedNullable() || supertype.isMarkedNullable();
         }
-        JetType subtypeRepresentative = TypeCapabilitiesKt.getSubtypeRepresentative(subtype);
-        JetType supertypeRepresentative = TypeCapabilitiesKt.getSupertypeRepresentative(supertype);
+        KtType subtypeRepresentative = TypeCapabilitiesKt.getSubtypeRepresentative(subtype);
+        KtType supertypeRepresentative = TypeCapabilitiesKt.getSupertypeRepresentative(supertype);
         if (subtypeRepresentative != subtype || supertypeRepresentative != supertype) {
             // recursive invocation for possible chain of representatives
             return isSubtypeOf(subtypeRepresentative, supertypeRepresentative);
@@ -191,7 +191,7 @@ public class TypeCheckingProcedure {
         return isSubtypeOfForRepresentatives(subtype, supertype);
     }
 
-    private boolean isSubtypeOfForRepresentatives(JetType subtype, JetType supertype) {
+    private boolean isSubtypeOfForRepresentatives(KtType subtype, KtType supertype) {
         if (subtype.isError() || supertype.isError()) {
             return true;
         }
@@ -204,7 +204,7 @@ public class TypeCheckingProcedure {
             return true;
         }
 
-        @Nullable JetType closestSupertype = findCorrespondingSupertype(subtype, supertype, constraints);
+        @Nullable KtType closestSupertype = findCorrespondingSupertype(subtype, supertype, constraints);
         if (closestSupertype == null) {
             return constraints.noCorrespondingSupertype(subtype, supertype); // if this returns true, there still isn't any supertype to continue with
         }
@@ -216,7 +216,7 @@ public class TypeCheckingProcedure {
         return checkSubtypeForTheSameConstructor(closestSupertype, supertype);
     }
 
-    private boolean checkSubtypeForTheSameConstructor(@NotNull JetType subtype, @NotNull JetType supertype) {
+    private boolean checkSubtypeForTheSameConstructor(@NotNull KtType subtype, @NotNull KtType supertype) {
         TypeConstructor constructor = subtype.getConstructor();
         assert constraints.assertEqualTypeConstructors(constructor, supertype.getConstructor()) : constructor + " is not " + supertype.getConstructor();
 
@@ -231,12 +231,12 @@ public class TypeCheckingProcedure {
             TypeProjection superArgument = superArguments.get(i);
             if (superArgument.isStarProjection()) continue;
 
-            JetType superIn = getInType(parameter, superArgument);
-            JetType superOut = getOutType(parameter, superArgument);
+            KtType superIn = getInType(parameter, superArgument);
+            KtType superOut = getOutType(parameter, superArgument);
 
             TypeProjection subArgument = subArguments.get(i);
-            JetType subIn = getInType(parameter, subArgument);
-            JetType subOut = getOutType(parameter, subArgument);
+            KtType subIn = getInType(parameter, subArgument);
+            KtType subOut = getOutType(parameter, subArgument);
 
             if (capture(subArgument, superArgument, parameter)) continue;
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckingProcedureCallbacks.java b/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckingProcedureCallbacks.java
index 2c3fce0902c..e0375932e22 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckingProcedureCallbacks.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckingProcedureCallbacks.java
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.types.checker;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeConstructor;
 import org.jetbrains.kotlin.types.TypeProjection;
 
@@ -25,13 +25,13 @@ import org.jetbrains.kotlin.types.TypeProjection;
  * Methods of this class return true to continue type checking and false to fail
  */
 public interface TypeCheckingProcedureCallbacks {
-    boolean assertEqualTypes(@NotNull JetType a, @NotNull JetType b, @NotNull TypeCheckingProcedure typeCheckingProcedure);
+    boolean assertEqualTypes(@NotNull KtType a, @NotNull KtType b, @NotNull TypeCheckingProcedure typeCheckingProcedure);
 
     boolean assertEqualTypeConstructors(@NotNull TypeConstructor a, @NotNull TypeConstructor b);
 
-    boolean assertSubtype(@NotNull JetType subtype, @NotNull JetType supertype, @NotNull TypeCheckingProcedure typeCheckingProcedure);
+    boolean assertSubtype(@NotNull KtType subtype, @NotNull KtType supertype, @NotNull TypeCheckingProcedure typeCheckingProcedure);
 
-    boolean capture(@NotNull JetType type, @NotNull TypeProjection typeProjection);
+    boolean capture(@NotNull KtType type, @NotNull TypeProjection typeProjection);
 
-    boolean noCorrespondingSupertype(@NotNull JetType subtype, @NotNull JetType supertype);
+    boolean noCorrespondingSupertype(@NotNull KtType subtype, @NotNull KtType supertype);
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/checker/utils.kt b/core/descriptors/src/org/jetbrains/kotlin/types/checker/utils.kt
index dae7c30b0e3..3ed9027cc70 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/checker/utils.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/checker/utils.kt
@@ -16,19 +16,19 @@
 
 package org.jetbrains.kotlin.types.checker
 
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.checker.TypeCheckingProcedureCallbacks
 import java.util.*
 
-private class SubtypePathNode(val type: JetType, val previous: SubtypePathNode?)
+private class SubtypePathNode(val type: KtType, val previous: SubtypePathNode?)
 
 public fun findCorrespondingSupertype(
-        subtype: JetType, supertype: JetType,
+        subtype: KtType, supertype: KtType,
         typeCheckingProcedureCallbacks: TypeCheckingProcedureCallbacks
-): JetType? {
+): KtType? {
     val queue = ArrayDeque<SubtypePathNode>()
     queue.add(SubtypePathNode(subtype, null))
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/dynamicTypes.kt b/core/descriptors/src/org/jetbrains/kotlin/types/dynamicTypes.kt
index 7f3fc6cc6fb..803296f91a1 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/dynamicTypes.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/dynamicTypes.kt
@@ -31,7 +31,7 @@ class DynamicTypesAllowed: DynamicTypesSettings() {
 
 interface Dynamicity : TypeCapability
 
-fun JetType.isDynamic(): Boolean = this.getCapability(javaClass<Dynamicity>()) != null
+fun KtType.isDynamic(): Boolean = this.getCapability(javaClass<Dynamicity>()) != null
 
 fun createDynamicType(builtIns: KotlinBuiltIns) = object : DelegatingFlexibleType(
         builtIns.nothingType,
@@ -42,7 +42,7 @@ fun createDynamicType(builtIns: KotlinBuiltIns) = object : DelegatingFlexibleTyp
 public object DynamicTypeCapabilities : FlexibleTypeCapabilities {
     override val id: String get() = "kotlin.DynamicType"
 
-    override fun <T : TypeCapability> getCapability(capabilityClass: Class<T>, jetType: JetType, flexibility: Flexibility): T? {
+    override fun <T : TypeCapability> getCapability(capabilityClass: Class<T>, jetType: KtType, flexibility: Flexibility): T? {
         @Suppress("UNCHECKED_CAST")
         return if (capabilityClass in Impl.capabilityClasses) Impl(flexibility) as T else null
     }
@@ -57,13 +57,13 @@ public object DynamicTypeCapabilities : FlexibleTypeCapabilities {
             )
         }
 
-        override val delegateType: JetType = flexibility.upperBound
+        override val delegateType: KtType = flexibility.upperBound
 
-        override fun getSpecificityRelationTo(otherType: JetType): Specificity.Relation {
+        override fun getSpecificityRelationTo(otherType: KtType): Specificity.Relation {
             return if (!otherType.isDynamic()) Specificity.Relation.LESS_SPECIFIC else Specificity.Relation.DONT_KNOW
         }
 
-        override fun makeNullableAsSpecified(nullable: Boolean): JetType {
+        override fun makeNullableAsSpecified(nullable: Boolean): KtType {
             // Nullability has no effect on dynamics
             return createDynamicType(delegateType.builtIns)
         }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/flexibleTypes.kt b/core/descriptors/src/org/jetbrains/kotlin/types/flexibleTypes.kt
index 7015653d685..1f5033ad549 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/flexibleTypes.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/flexibleTypes.kt
@@ -19,14 +19,14 @@ package org.jetbrains.kotlin.types
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 
 public interface FlexibleTypeCapabilities {
-    fun <T: TypeCapability> getCapability(capabilityClass: Class<T>, jetType: JetType, flexibility: Flexibility): T?
+    fun <T: TypeCapability> getCapability(capabilityClass: Class<T>, jetType: KtType, flexibility: Flexibility): T?
     val id: String
 
     object NONE : FlexibleTypeCapabilities {
-        override fun <T : TypeCapability> getCapability(capabilityClass: Class<T>, jetType: JetType, flexibility: Flexibility): T? = null
+        override fun <T : TypeCapability> getCapability(capabilityClass: Class<T>, jetType: KtType, flexibility: Flexibility): T? = null
         override val id: String get() = "NONE"
     }
 }
@@ -41,37 +41,37 @@ public interface Flexibility : TypeCapability, SubtypingRepresentatives {
     }
 
     // lowerBound is a subtype of upperBound
-    public val lowerBound: JetType
-    public val upperBound: JetType
+    public val lowerBound: KtType
+    public val upperBound: KtType
 
     public val extraCapabilities: FlexibleTypeCapabilities
 
-    override val subTypeRepresentative: JetType
+    override val subTypeRepresentative: KtType
         get() = lowerBound
 
-    override val superTypeRepresentative: JetType
+    override val superTypeRepresentative: KtType
         get() = upperBound
 
-    override fun sameTypeConstructor(type: JetType) = false
+    override fun sameTypeConstructor(type: KtType) = false
 }
 
-public fun JetType.isFlexible(): Boolean = this.getCapability(javaClass<Flexibility>()) != null
-public fun JetType.flexibility(): Flexibility = this.getCapability(javaClass<Flexibility>())!!
+public fun KtType.isFlexible(): Boolean = this.getCapability(javaClass<Flexibility>()) != null
+public fun KtType.flexibility(): Flexibility = this.getCapability(javaClass<Flexibility>())!!
 
-public fun JetType.isNullabilityFlexible(): Boolean {
+public fun KtType.isNullabilityFlexible(): Boolean {
     val flexibility = this.getCapability(javaClass<Flexibility>()) ?: return false
     return TypeUtils.isNullableType(flexibility.lowerBound) != TypeUtils.isNullableType(flexibility.upperBound)
 }
 
-// This function is intended primarily for sets: since JetType.equals() represents _syntactical_ equality of types,
-// whereas JetTypeChecker.DEFAULT.equalsTypes() represents semantic equality
+// This function is intended primarily for sets: since KtType.equals() represents _syntactical_ equality of types,
+// whereas KotlinTypeChecker.DEFAULT.equalsTypes() represents semantic equality
 // A set of types (e.g. exact bounds etc) may contain, for example, X, X? and X!
-// These are not equal syntactically (by JetType.equals()), but X! is _compatible_ with others as exact bounds,
+// These are not equal syntactically (by KtType.equals()), but X! is _compatible_ with others as exact bounds,
 // moreover, X! is a better fit.
 //
 // So, we are looking for a type among this set such that it is equal to all others semantically
-// (by JetTypeChecker.DEFAULT.equalsTypes()), and fits at least as well as they do.
-fun Collection<JetType>.singleBestRepresentative(): JetType? {
+// (by KotlinTypeChecker.DEFAULT.equalsTypes()), and fits at least as well as they do.
+fun Collection<KtType>.singleBestRepresentative(): KtType? {
     if (this.size() == 1) return this.first()
 
     return this.firstOrNull {
@@ -80,7 +80,7 @@ fun Collection<JetType>.singleBestRepresentative(): JetType? {
             other ->
             // We consider error types equal to anything here, so that intersections like
             // {Array<String>, Array<[ERROR]>} work correctly
-            candidate == other || JetTypeChecker.ERROR_TYPES_ARE_EQUAL_TO_ANYTHING.equalTypes(candidate, other)
+            candidate == other || KotlinTypeChecker.ERROR_TYPES_ARE_EQUAL_TO_ANYTHING.equalTypes(candidate, other)
         }
     }
 }
@@ -97,21 +97,21 @@ fun Collection<TypeProjection>.singleBestRepresentative(): TypeProjection? {
     return TypeProjectionImpl(projectionKinds.single(), bestType)
 }
 
-public fun JetType.lowerIfFlexible(): JetType = if (this.isFlexible()) this.flexibility().lowerBound else this
-public fun JetType.upperIfFlexible(): JetType = if (this.isFlexible()) this.flexibility().upperBound else this
+public fun KtType.lowerIfFlexible(): KtType = if (this.isFlexible()) this.flexibility().lowerBound else this
+public fun KtType.upperIfFlexible(): KtType = if (this.isFlexible()) this.flexibility().upperBound else this
 
 public interface NullAwareness : TypeCapability {
-    public fun makeNullableAsSpecified(nullable: Boolean): JetType
+    public fun makeNullableAsSpecified(nullable: Boolean): KtType
     public fun computeIsNullable(): Boolean
 }
 
 interface FlexibleTypeDelegation : TypeCapability {
-    public val delegateType: JetType
+    public val delegateType: KtType
 }
 
 public open class DelegatingFlexibleType protected constructor(
-        override val lowerBound: JetType,
-        override val upperBound: JetType,
+        override val lowerBound: KtType,
+        override val upperBound: KtType,
         override val extraCapabilities: FlexibleTypeCapabilities
 ) : DelegatingType(), NullAwareness, Flexibility, FlexibleTypeDelegation {
     companion object {
@@ -123,7 +123,7 @@ public open class DelegatingFlexibleType protected constructor(
         )
 
         @JvmStatic
-        fun create(lowerBound: JetType, upperBound: JetType, extraCapabilities: FlexibleTypeCapabilities): JetType {
+        fun create(lowerBound: KtType, upperBound: KtType, extraCapabilities: FlexibleTypeCapabilities): KtType {
             if (lowerBound == upperBound) return lowerBound
             return DelegatingFlexibleType(lowerBound, upperBound, extraCapabilities)
         }
@@ -134,7 +134,7 @@ public open class DelegatingFlexibleType protected constructor(
             assert (!lowerBound.isFlexible()) { "Lower bound of a flexible type can not be flexible: $lowerBound" }
             assert (!upperBound.isFlexible()) { "Upper bound of a flexible type can not be flexible: $upperBound" }
             assert (lowerBound != upperBound) { "Lower and upper bounds are equal: $lowerBound == $upperBound" }
-            assert (JetTypeChecker.DEFAULT.isSubtypeOf(lowerBound, upperBound)) {
+            assert (KotlinTypeChecker.DEFAULT.isSubtypeOf(lowerBound, upperBound)) {
                 "Lower bound $lowerBound of a flexible type must be a subtype of the upper bound $upperBound"
             }
         }
@@ -150,7 +150,7 @@ public open class DelegatingFlexibleType protected constructor(
         return super<DelegatingType>.getCapability(capabilityClass)
     }
 
-    override fun makeNullableAsSpecified(nullable: Boolean): JetType {
+    override fun makeNullableAsSpecified(nullable: Boolean): KtType {
         return create(
                 TypeUtils.makeNullableAsSpecified(lowerBound, nullable),
                 TypeUtils.makeNullableAsSpecified(upperBound, nullable),
@@ -161,7 +161,7 @@ public open class DelegatingFlexibleType protected constructor(
 
     override fun isMarkedNullable(): Boolean = getCapability(javaClass<NullAwareness>())!!.computeIsNullable()
 
-    override val delegateType: JetType = lowerBound
+    override val delegateType: KtType = lowerBound
 
     override fun getDelegate() = getCapability(javaClass<FlexibleTypeDelegation>())!!.delegateType
 
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AdditionalSupertypes.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AdditionalSupertypes.kt
index 898c7779fab..3547274f5e7 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AdditionalSupertypes.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AdditionalSupertypes.kt
@@ -17,12 +17,12 @@
 package org.jetbrains.kotlin.serialization.deserialization
 
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 interface AdditionalSupertypes {
-    fun forClass(classDescriptor: DeserializedClassDescriptor): Collection<JetType>
+    fun forClass(classDescriptor: DeserializedClassDescriptor): Collection<KtType>
 
     object None : AdditionalSupertypes {
-        override fun forClass(classDescriptor: DeserializedClassDescriptor): Collection<JetType> = emptyList()
+        override fun forClass(classDescriptor: DeserializedClassDescriptor): Collection<KtType> = emptyList()
     }
 }
\ No newline at end of file
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoader.java b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoader.java
index ee28c8fb5e6..3b3bcdccf1a 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoader.java
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoader.java
@@ -20,7 +20,7 @@ import com.google.protobuf.MessageLite;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.serialization.ProtoBuf;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.List;
 
@@ -72,6 +72,6 @@ public interface AnnotationAndConstantLoader<A, C, T> {
     C loadPropertyConstant(
             @NotNull ProtoContainer container,
             @NotNull ProtoBuf.Property proto,
-            @NotNull JetType expectedType
+            @NotNull KtType expectedType
     );
 }
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt
index ad93d6f9005..97a59249bce 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation.Argument
 import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation.Argument.Value
 import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation.Argument.Value.Type
 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 org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
 
@@ -65,7 +65,7 @@ public class AnnotationDeserializer(private val module: ModuleDescriptor) {
     }
 
     public fun resolveValue(
-            expectedType: JetType,
+            expectedType: KtType,
             value: Value,
             nameResolver: NameResolver
     ): ConstantValue<*> {
@@ -141,7 +141,7 @@ public class AnnotationDeserializer(private val module: ModuleDescriptor) {
         return factory.createErrorValue("Unresolved enum entry: $enumClassId.$enumEntryName")
     }
 
-    private fun resolveArrayElementType(value: Value, nameResolver: NameResolver): JetType =
+    private fun resolveArrayElementType(value: Value, nameResolver: NameResolver): KtType =
             with(builtIns) {
                 when (value.getType()) {
                     Type.BYTE -> getByteType()
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/TypeDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/TypeDeserializer.kt
index 2ada1539f2a..2e15c340289 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/TypeDeserializer.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/TypeDeserializer.kt
@@ -53,7 +53,7 @@ public class TypeDeserializer(
             get() = typeParameterDescriptors().values().toReadOnlyList()
 
     // TODO: don't load identical types from TypeTable more than once
-    fun type(proto: ProtoBuf.Type, additionalAnnotations: Annotations = Annotations.EMPTY): JetType {
+    fun type(proto: ProtoBuf.Type, additionalAnnotations: Annotations = Annotations.EMPTY): KtType {
         if (proto.hasFlexibleTypeCapabilitiesId()) {
             val id = c.nameResolver.getString(proto.flexibleTypeCapabilitiesId)
             val capabilities = c.components.flexibleTypeCapabilitiesDeserializer.capabilitiesById(id) ?:
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt
index c9c2c78e750..4207308105a 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt
@@ -26,13 +26,13 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DescriptorFactory
 import org.jetbrains.kotlin.resolve.OverridingUtil
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.StaticScopeForKotlinClass
 import org.jetbrains.kotlin.serialization.Flags
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.*
 import org.jetbrains.kotlin.types.AbstractClassTypeConstructor
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.upperIfFlexible
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.singletonOrEmptyList
@@ -134,8 +134,8 @@ public class DeserializedClassDescriptor(
 
     override fun getCompanionObjectDescriptor(): ClassDescriptor? = companionObjectDescriptor()
 
-    private fun computeSupertypes(): Collection<JetType> {
-        val result = ArrayList<JetType>(classProto.supertypeCount)
+    private fun computeSupertypes(): Collection<KtType> {
+        val result = ArrayList<KtType>(classProto.supertypeCount)
         val unresolved = ArrayList<DeserializedType>(0)
 
         for (supertypeProto in classProto.supertypes(c.typeTable)) {
@@ -188,7 +188,7 @@ public class DeserializedClassDescriptor(
     private inner class DeserializedClassMemberScope : DeserializedMemberScope(c, classProto.functionList, classProto.propertyList) {
         private val classDescriptor: DeserializedClassDescriptor get() = this@DeserializedClassDescriptor
         private val allDescriptors = c.storageManager.createLazyValue {
-            computeDescriptors(DescriptorKindFilter.ALL, JetScope.ALL_NAME_FILTER, NoLookupLocation.WHEN_GET_ALL_DESCRIPTORS)
+            computeDescriptors(DescriptorKindFilter.ALL, KtScope.ALL_NAME_FILTER, NoLookupLocation.WHEN_GET_ALL_DESCRIPTORS)
         }
 
         override fun getDescriptors(kindFilter: DescriptorKindFilter,
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedMemberScope.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedMemberScope.kt
index cd1cefee520..fd58de1898c 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedMemberScope.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedMemberScope.kt
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
+import org.jetbrains.kotlin.resolve.scopes.KtScopeImpl
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationContext
 import org.jetbrains.kotlin.serialization.deserialization.receiverType
@@ -33,7 +33,7 @@ public abstract class DeserializedMemberScope protected constructor(
         protected val c: DeserializationContext,
         functionList: Collection<ProtoBuf.Function>,
         propertyList: Collection<ProtoBuf.Property>
-) : JetScopeImpl() {
+) : KtScopeImpl() {
 
     private data class ProtoKey(val name: Name, val isExtension: Boolean)
 
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedTypeParameterDescriptor.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedTypeParameterDescriptor.kt
index 008bc33440a..07b006f22bd 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedTypeParameterDescriptor.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedTypeParameterDescriptor.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.impl.AbstractLazyTypeParameterDescriptor
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.*
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.util.*
 
 class DeserializedTypeParameterDescriptor(
@@ -39,12 +39,12 @@ class DeserializedTypeParameterDescriptor(
 
     override fun getAnnotations(): Annotations = annotations
 
-    override fun resolveUpperBounds(): Set<JetType> {
+    override fun resolveUpperBounds(): Set<KtType> {
         val upperBounds = proto.upperBounds(typeTable)
         if (upperBounds.isEmpty()) {
             return setOf(this.builtIns.getDefaultBound())
         }
-        val result = LinkedHashSet<JetType>(upperBounds.size())
+        val result = LinkedHashSet<KtType>(upperBounds.size())
         for (upperBound in upperBounds) {
             result.add(typeDeserializer.type(upperBound, Annotations.EMPTY))
         }
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt
index f91e9c805e3..5d2eb1a8a4d 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.serialization.deserialization.findClassAcrossModuleDependencies
 import kotlin.reflect.KCallable
 import kotlin.reflect.KClass
@@ -55,9 +55,9 @@ internal class KClassImpl<T : Any>(override val jClass: Class<T>) : KDeclaration
 
     private val classId: ClassId get() = RuntimeTypeMapper.mapJvmClassToKotlinClassId(jClass)
 
-    internal val memberScope: JetScope get() = descriptor.defaultType.memberScope
+    internal val memberScope: KtScope get() = descriptor.defaultType.memberScope
 
-    internal val staticScope: JetScope get() = descriptor.staticScope
+    internal val staticScope: KtScope get() = descriptor.staticScope
 
     override val members: Collection<KCallable<*>>
         get() = getMembers(memberScope, declaredOnly = false, nonExtensions = true, extensions = true)
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KDeclarationContainerImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KDeclarationContainerImpl.kt
index 0d6b00b99cf..eaa6161bf41 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KDeclarationContainerImpl.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KDeclarationContainerImpl.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.load.java.structure.reflect.safeClassLoader
 import org.jetbrains.kotlin.load.kotlin.reflect.RuntimeModuleData
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
-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.NameResolver
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf
@@ -53,7 +53,7 @@ internal abstract class KDeclarationContainerImpl : ClassBasedDeclarationContain
 
     abstract fun getFunctions(name: Name): Collection<FunctionDescriptor>
 
-    fun getMembers(scope: JetScope, declaredOnly: Boolean, nonExtensions: Boolean, extensions: Boolean): Sequence<KCallable<*>> {
+    fun getMembers(scope: KtScope, declaredOnly: Boolean, nonExtensions: Boolean, extensions: Boolean): Sequence<KCallable<*>> {
         val visitor = object : DeclarationDescriptorVisitorEmptyBodies<KCallable<*>?, Unit>() {
             private fun skipCallable(descriptor: CallableMemberDescriptor): Boolean {
                 if (declaredOnly && !descriptor.getKind().isReal()) return true
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPackageImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPackageImpl.kt
index 3088d471672..112a394b735 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPackageImpl.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPackageImpl.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.load.java.structure.reflect.classId
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import kotlin.jvm.internal.KotlinPackage
 import kotlin.reflect.KCallable
 import kotlin.reflect.KPackage
@@ -35,7 +35,7 @@ internal class KPackageImpl(override val jClass: Class<*>, val moduleName: Strin
         }
     }
 
-    internal val scope: JetScope get() = descriptor().memberScope
+    internal val scope: KtScope get() = descriptor().memberScope
 
     override val members: Collection<KCallable<*>>
         get() = getMembers(scope, declaredOnly = false, nonExtensions = true, extensions = true).toList()
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KTypeImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KTypeImpl.kt
index e2f042051b3..eded4c383bb 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KTypeImpl.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KTypeImpl.kt
@@ -16,12 +16,12 @@
 
 package kotlin.reflect.jvm.internal
 
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.lang.reflect.Type
 import kotlin.reflect.KType
 
 internal class KTypeImpl(
-        val type: JetType,
+        val type: KtType,
         computeJavaType: () -> Type
 ) : KType {
     internal val javaType: Type by ReflectProperties.lazySoft(computeJavaType)
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionObjectRenderer.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionObjectRenderer.kt
index 48ff1e1f079..b52e0ee9767 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionObjectRenderer.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionObjectRenderer.kt
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import kotlin.reflect.KParameter
 
 internal object ReflectionObjectRenderer {
@@ -94,7 +94,7 @@ internal object ReflectionObjectRenderer {
         }.toString()
     }
 
-    fun renderType(type: JetType): String {
+    fun renderType(type: KtType): String {
         return renderer.renderType(type)
     }
 }
diff --git a/generators/src/org/jetbrains/kotlin/generators/evaluate/GenerateOperationsMap.kt b/generators/src/org/jetbrains/kotlin/generators/evaluate/GenerateOperationsMap.kt
index d1b20181973..5a0698ced0c 100644
--- a/generators/src/org/jetbrains/kotlin/generators/evaluate/GenerateOperationsMap.kt
+++ b/generators/src/org/jetbrains/kotlin/generators/evaluate/GenerateOperationsMap.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil
 import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.utils.Printer
 import java.io.File
@@ -47,8 +47,8 @@ fun generate(): String {
     p.println("/** This file is generated by org.jetbrains.kotlin.generators.evaluate:generate(). DO NOT MODIFY MANUALLY */")
     p.println()
 
-    val unaryOperationsMap = arrayListOf<Triple<String, List<JetType>, Boolean>>()
-    val binaryOperationsMap = arrayListOf<Pair<String, List<JetType>>>()
+    val unaryOperationsMap = arrayListOf<Triple<String, List<KtType>, Boolean>>()
+    val binaryOperationsMap = arrayListOf<Pair<String, List<KtType>>>()
 
     val builtIns = TargetPlatform.Default.builtIns
     @Suppress("UNCHECKED_CAST")
@@ -122,7 +122,7 @@ fun generate(): String {
     return sb.toString()
 }
 
-fun renderCheckUnaryOperation(name: String, params: List<JetType>): String {
+fun renderCheckUnaryOperation(name: String, params: List<KtType>): String {
     val isAllParamsIntegers = params.fold(true) { a, b -> a && b.isIntegerType() }
     if (!isAllParamsIntegers) {
         return "emptyUnaryFun"
@@ -134,7 +134,7 @@ fun renderCheckUnaryOperation(name: String, params: List<JetType>): String {
     }
 }
 
-fun renderCheckBinaryOperation(name: String, params: List<JetType>): String {
+fun renderCheckBinaryOperation(name: String, params: List<KtType>): String {
     val isAllParamsIntegers = params.fold(true) { a, b -> a && b.isIntegerType() }
     if (!isAllParamsIntegers) {
         return "emptyBinaryFun"
@@ -153,7 +153,7 @@ fun renderCheckBinaryOperation(name: String, params: List<JetType>): String {
     }
 }
 
-private fun JetType.isIntegerType(): Boolean {
+private fun KtType.isIntegerType(): Boolean {
     return KotlinBuiltIns.isInt(this) ||
            KotlinBuiltIns.isShort(this) ||
            KotlinBuiltIns.isByte(this) ||
@@ -161,7 +161,7 @@ private fun JetType.isIntegerType(): Boolean {
 }
 
 
-private fun CallableDescriptor.getParametersTypes(): List<JetType> {
+private fun CallableDescriptor.getParametersTypes(): List<KtType> {
     val list = arrayListOf((getContainingDeclaration() as ClassDescriptor).getDefaultType())
     getValueParameters().map { it.getType() }.forEach {
         list.add(TypeUtils.makeNotNullable(it))
@@ -169,4 +169,4 @@ private fun CallableDescriptor.getParametersTypes(): List<JetType> {
     return list
 }
 
-private fun JetType.asString(): String = getConstructor().getDeclarationDescriptor()!!.getName().asString().toUpperCase()
+private fun KtType.asString(): String = getConstructor().getDeclarationDescriptor()!!.getName().asString().toUpperCase()
diff --git a/generators/src/org/jetbrains/kotlin/generators/frontend/GenerateKeywordStrings.java b/generators/src/org/jetbrains/kotlin/generators/frontend/GenerateKeywordStrings.java
index 4570e0448b5..9dbe4f68c21 100644
--- a/generators/src/org/jetbrains/kotlin/generators/frontend/GenerateKeywordStrings.java
+++ b/generators/src/org/jetbrains/kotlin/generators/frontend/GenerateKeywordStrings.java
@@ -20,8 +20,8 @@ import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil;
-import org.jetbrains.kotlin.lexer.JetKeywordToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtKeywordToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.utils.Printer;
 
 import java.io.File;
@@ -54,11 +54,11 @@ public class GenerateKeywordStrings {
         p.pushIndent();
 
         List<String> strings = new ArrayList<String>();
-        for (IElementType type : JetTokens.KEYWORDS.getTypes()) {
-            assert type instanceof JetKeywordToken : "Not a keyword in JetTokens.KEYWORDS: " + type;
-            JetKeywordToken keyword = (JetKeywordToken) type;
-            assert !keyword.isSoft() : "Soft keyword in JetTokens.KEYWORDS: " + keyword.getValue();
-            if (keyword != JetTokens.AS_SAFE && keyword != JetTokens.NOT_IN && keyword != JetTokens.NOT_IS) {
+        for (IElementType type : KtTokens.KEYWORDS.getTypes()) {
+            assert type instanceof KtKeywordToken : "Not a keyword in KtTokens.KEYWORDS: " + type;
+            KtKeywordToken keyword = (KtKeywordToken) type;
+            assert !keyword.isSoft() : "Soft keyword in KtTokens.KEYWORDS: " + keyword.getValue();
+            if (keyword != KtTokens.AS_SAFE && keyword != KtTokens.NOT_IN && keyword != KtTokens.NOT_IS) {
                 strings.add(keyword.getValue());
             }
         }
diff --git a/generators/src/org/jetbrains/kotlin/generators/tests/generateTestDataForReservedWords.kt b/generators/src/org/jetbrains/kotlin/generators/tests/generateTestDataForReservedWords.kt
index d89bb304f48..52d4538c7c7 100644
--- a/generators/src/org/jetbrains/kotlin/generators/tests/generateTestDataForReservedWords.kt
+++ b/generators/src/org/jetbrains/kotlin/generators/tests/generateTestDataForReservedWords.kt
@@ -18,11 +18,11 @@ package org.jetbrains.kotlin.generators.tests.reservedWords
 
 import com.google.dart.compiler.backend.js.ast.JsFunctionScope
 import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.renderer.KeywordStringsGenerated
 import java.io.File
 
-val MODIFIER_KEYWORDS = JetTokens.MODIFIER_KEYWORDS_ARRAY.map { it.getValue() }.toSet()
+val MODIFIER_KEYWORDS = KtTokens.MODIFIER_KEYWORDS_ARRAY.map { it.getValue() }.toSet()
 
 val commonCases: CaseBuilder.(String, String) -> Unit = { testByName, testByRef ->
     case("val", "val $KEYWORD_MARKER: Int", " = 0", testByName)
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/codeInsight/ReferenceVariantsHelper.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/codeInsight/ReferenceVariantsHelper.kt
index 6cb0bdc383f..8acd07c6310 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/codeInsight/ReferenceVariantsHelper.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/codeInsight/ReferenceVariantsHelper.kt
@@ -23,10 +23,10 @@ import org.jetbrains.kotlin.idea.resolve.frontendService
 import org.jetbrains.kotlin.idea.util.*
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetCodeFragment
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
-import org.jetbrains.kotlin.psi.JetTypeReference
+import org.jetbrains.kotlin.psi.KtCodeFragment
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtTypeReference
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
@@ -35,14 +35,14 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 import org.jetbrains.kotlin.resolve.isAnnotatedAsHidden
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindExclude
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.getDescriptorsFiltered
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.kotlin.resolve.scopes.utils.getDescriptorsFiltered
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.*
 
@@ -53,7 +53,7 @@ public class ReferenceVariantsHelper(
 ) {
     @JvmOverloads
     public fun getReferenceVariants(
-            expression: JetSimpleNameExpression,
+            expression: KtSimpleNameExpression,
             kindFilter: DescriptorKindFilter,
             nameFilter: (Name) -> Boolean,
             callTypeAndReceiver: CallTypeAndReceiver<*, *> = CallTypeAndReceiver.detect(expression),
@@ -85,7 +85,7 @@ public class ReferenceVariantsHelper(
     }
 
     private fun getReferenceVariantsNoVisibilityFilter(
-            expression: JetSimpleNameExpression,
+            expression: KtSimpleNameExpression,
             kindFilter: DescriptorKindFilter,
             nameFilter: (Name) -> Boolean,
             callTypeAndReceiver: CallTypeAndReceiver<*, *>,
@@ -96,7 +96,7 @@ public class ReferenceVariantsHelper(
         @Suppress("NAME_SHADOWING")
         val kindFilter = kindFilter.intersect(callType.descriptorKindFilter)
 
-        val receiverExpression: JetExpression?
+        val receiverExpression: KtExpression?
         when (callTypeAndReceiver) {
             is CallTypeAndReceiver.IMPORT_DIRECTIVE -> {
                 return getVariantsForImportOrPackageDirective(callTypeAndReceiver.receiver, kindFilter, nameFilter)
@@ -115,7 +115,7 @@ public class ReferenceVariantsHelper(
             }
 
             is CallTypeAndReceiver.CALLABLE_REFERENCE -> {
-                val resolutionScope = context[BindingContext.RESOLUTION_SCOPE, expression.parent as JetExpression] ?: return emptyList()
+                val resolutionScope = context[BindingContext.RESOLUTION_SCOPE, expression.parent as KtExpression] ?: return emptyList()
                 return getVariantsForCallableReference(callTypeAndReceiver.receiver, resolutionScope, kindFilter, nameFilter)
             }
 
@@ -168,8 +168,8 @@ public class ReferenceVariantsHelper(
     }
 
     private fun getVariantsForUserType(
-            receiverExpression: JetExpression?,
-            expression: JetSimpleNameExpression,
+            receiverExpression: KtExpression?,
+            expression: KtSimpleNameExpression,
             kindFilter: DescriptorKindFilter,
             nameFilter: (Name) -> Boolean
     ): Collection<DeclarationDescriptor> {
@@ -178,7 +178,7 @@ public class ReferenceVariantsHelper(
             return qualifier.scope.getDescriptorsFiltered(kindFilter, nameFilter)
         }
         else {
-            val lexicalScope = expression.getParentOfType<JetTypeReference>(strict = true)?.let {
+            val lexicalScope = expression.getParentOfType<KtTypeReference>(strict = true)?.let {
                 context[BindingContext.LEXICAL_SCOPE, it]
             } ?: return emptyList()
             return lexicalScope.getDescriptorsFiltered(kindFilter, nameFilter)
@@ -186,8 +186,8 @@ public class ReferenceVariantsHelper(
     }
 
     private fun getVariantsForCallableReference(
-            qualifierTypeRef: JetTypeReference?,
-            resolutionScope: JetScope,
+            qualifierTypeRef: KtTypeReference?,
+            resolutionScope: KtScope,
             kindFilter: DescriptorKindFilter,
             nameFilter: (Name) -> Boolean
     ): Collection<DeclarationDescriptor> {
@@ -207,7 +207,7 @@ public class ReferenceVariantsHelper(
     }
 
     private fun getVariantsForImportOrPackageDirective(
-            receiverExpression: JetExpression?,
+            receiverExpression: KtExpression?,
             kindFilter: DescriptorKindFilter,
             nameFilter: (Name) -> Boolean
     ): Collection<DeclarationDescriptor> {
@@ -222,9 +222,9 @@ public class ReferenceVariantsHelper(
     }
 
     private fun MutableSet<DeclarationDescriptor>.processAll(
-            implicitReceiverTypes: Collection<JetType>,
-            receiverTypes: Collection<JetType>,
-            resolutionScope: JetScope,
+            implicitReceiverTypes: Collection<KtType>,
+            receiverTypes: Collection<KtType>,
+            resolutionScope: KtScope,
             callType: CallType<*>,
             kindFilter: DescriptorKindFilter,
             nameFilter: (Name) -> Boolean
@@ -235,8 +235,8 @@ public class ReferenceVariantsHelper(
     }
 
     private fun MutableSet<DeclarationDescriptor>.addMemberExtensions(
-            dispatchReceiverTypes: Collection<JetType>,
-            extensionReceiverTypes: Collection<JetType>,
+            dispatchReceiverTypes: Collection<KtType>,
+            extensionReceiverTypes: Collection<KtType>,
             callType: CallType<*>,
             kindFilter: DescriptorKindFilter,
             nameFilter: (Name) -> Boolean
@@ -250,7 +250,7 @@ public class ReferenceVariantsHelper(
     }
 
     private fun MutableSet<DeclarationDescriptor>.addNonExtensionMembers(
-            receiverTypes: Collection<JetType>,
+            receiverTypes: Collection<KtType>,
             kindFilter: DescriptorKindFilter,
             nameFilter: (Name) -> Boolean,
             constructorFilter: (ClassDescriptor) -> Boolean
@@ -261,7 +261,7 @@ public class ReferenceVariantsHelper(
     }
 
     private fun MutableSet<DeclarationDescriptor>.addNonExtensionCallablesAndConstructors(
-            scope: JetScope,
+            scope: KtScope,
             kindFilter: DescriptorKindFilter,
             nameFilter: (Name) -> Boolean,
             constructorFilter: (ClassDescriptor) -> Boolean
@@ -286,8 +286,8 @@ public class ReferenceVariantsHelper(
     }
 
     private fun MutableSet<DeclarationDescriptor>.addScopeAndSyntheticExtensions(
-            resolutionScope: JetScope,
-            receiverTypes: Collection<JetType>,
+            resolutionScope: KtScope,
+            receiverTypes: Collection<KtType>,
             callType: CallType<*>,
             kindFilter: DescriptorKindFilter,
             nameFilter: (Name) -> Boolean
@@ -320,10 +320,10 @@ public class ReferenceVariantsHelper(
         }
     }
 
-    private fun getQualifierRuntimeType(receiver: JetExpression): JetType? {
+    private fun getQualifierRuntimeType(receiver: KtExpression): KtType? {
         val type = context.getType(receiver)
-        if (type != null && TypeUtils.canHaveSubtypes(JetTypeChecker.DEFAULT, type)) {
-            val evaluator = receiver.getContainingFile().getCopyableUserData(JetCodeFragment.RUNTIME_TYPE_EVALUATOR)
+        if (type != null && TypeUtils.canHaveSubtypes(KotlinTypeChecker.DEFAULT, type)) {
+            val evaluator = receiver.getContainingFile().getCopyableUserData(KtCodeFragment.RUNTIME_TYPE_EVALUATOR)
             val runtimeType = evaluator?.invoke(receiver)
             if (runtimeType == type) return null
             return runtimeType
@@ -332,7 +332,7 @@ public class ReferenceVariantsHelper(
     }
 
     public fun getPackageReferenceVariants(
-            expression: JetSimpleNameExpression,
+            expression: KtSimpleNameExpression,
             nameFilter: (Name) -> Boolean
     ): Collection<DeclarationDescriptor> {
         val resolutionScope = context[BindingContext.RESOLUTION_SCOPE, expression] ?: return listOf()
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/resolve/ResolutionFacade.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/resolve/ResolutionFacade.kt
index 5ef843ada8b..e0af940c070 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/resolve/ResolutionFacade.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/resolve/ResolutionFacade.kt
@@ -21,19 +21,19 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 
 public interface ResolutionFacade {
     public val project: Project
 
-    public fun analyze(element: JetElement, bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL): BindingContext
+    public fun analyze(element: KtElement, bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL): BindingContext
 
-    public fun analyzeFullyAndGetResult(elements: Collection<JetElement>): AnalysisResult
+    public fun analyzeFullyAndGetResult(elements: Collection<KtElement>): AnalysisResult
 
-    public fun resolveToDescriptor(declaration: JetDeclaration): DeclarationDescriptor
+    public fun resolveToDescriptor(declaration: KtDeclaration): DeclarationDescriptor
 
     public val moduleDescriptor: ModuleDescriptor
 
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/CallType.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/CallType.kt
index 117dd7f6c50..51bebc9d2eb 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/CallType.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/CallType.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.idea.util
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getReceiverExpression
 import org.jetbrains.kotlin.psi.psiUtil.isImportDirectiveExpression
@@ -29,31 +29,31 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastManager
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindExclude
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
 
-public sealed class CallType<TReceiver : JetElement?>(val descriptorKindFilter: DescriptorKindFilter) {
+public sealed class CallType<TReceiver : KtElement?>(val descriptorKindFilter: DescriptorKindFilter) {
     object UNKNOWN : CallType<Nothing?>(DescriptorKindFilter.ALL)
 
     object DEFAULT : CallType<Nothing?>(DescriptorKindFilter.ALL)
 
-    object DOT : CallType<JetExpression>(DescriptorKindFilter.ALL)
+    object DOT : CallType<KtExpression>(DescriptorKindFilter.ALL)
 
-    object SAFE : CallType<JetExpression>(DescriptorKindFilter.ALL)
+    object SAFE : CallType<KtExpression>(DescriptorKindFilter.ALL)
 
-    object INFIX : CallType<JetExpression>(DescriptorKindFilter.FUNCTIONS exclude NonInfixExclude)
+    object INFIX : CallType<KtExpression>(DescriptorKindFilter.FUNCTIONS exclude NonInfixExclude)
 
-    object OPERATOR : CallType<JetExpression>(DescriptorKindFilter.FUNCTIONS exclude NonOperatorExclude)
+    object OPERATOR : CallType<KtExpression>(DescriptorKindFilter.FUNCTIONS exclude NonOperatorExclude)
 
-    object CALLABLE_REFERENCE : CallType<JetTypeReference?>(DescriptorKindFilter.CALLABLES exclude CallableReferenceExclude)
+    object CALLABLE_REFERENCE : CallType<KtTypeReference?>(DescriptorKindFilter.CALLABLES exclude CallableReferenceExclude)
 
-    object IMPORT_DIRECTIVE : CallType<JetExpression?>(DescriptorKindFilter.ALL)
+    object IMPORT_DIRECTIVE : CallType<KtExpression?>(DescriptorKindFilter.ALL)
 
-    object PACKAGE_DIRECTIVE : CallType<JetExpression?>(DescriptorKindFilter.PACKAGES)
+    object PACKAGE_DIRECTIVE : CallType<KtExpression?>(DescriptorKindFilter.PACKAGES)
 
-    object TYPE : CallType<JetExpression?>(DescriptorKindFilter(DescriptorKindFilter.CLASSIFIERS_MASK or DescriptorKindFilter.PACKAGES_MASK))
+    object TYPE : CallType<KtExpression?>(DescriptorKindFilter(DescriptorKindFilter.CLASSIFIERS_MASK or DescriptorKindFilter.PACKAGES_MASK))
 
-    object ANNOTATION : CallType<JetExpression?>(DescriptorKindFilter(DescriptorKindFilter.CLASSIFIERS_MASK or DescriptorKindFilter.PACKAGES_MASK) exclude NonAnnotationClassifierExclude)
+    object ANNOTATION : CallType<KtExpression?>(DescriptorKindFilter(DescriptorKindFilter.CLASSIFIERS_MASK or DescriptorKindFilter.PACKAGES_MASK) exclude NonAnnotationClassifierExclude)
 
     private object NonInfixExclude : DescriptorKindExclude() {
         override fun excludes(descriptor: DeclarationDescriptor) =
@@ -89,26 +89,26 @@ public sealed class CallType<TReceiver : JetElement?>(val descriptorKindFilter:
     }
 }
 
-public sealed class CallTypeAndReceiver<TReceiver : JetElement?, TCallType : CallType<TReceiver>>(
+public sealed class CallTypeAndReceiver<TReceiver : KtElement?, TCallType : CallType<TReceiver>>(
         val callType: TCallType,
         val receiver: TReceiver
 ) {
     object UNKNOWN : CallTypeAndReceiver<Nothing?, CallType.UNKNOWN>(CallType.UNKNOWN, null)
     object DEFAULT : CallTypeAndReceiver<Nothing?, CallType.DEFAULT>(CallType.DEFAULT, null)
-    class DOT(receiver: JetExpression) : CallTypeAndReceiver<JetExpression, CallType.DOT>(CallType.DOT, receiver)
-    class SAFE(receiver: JetExpression) : CallTypeAndReceiver<JetExpression, CallType.SAFE>(CallType.SAFE, receiver)
-    class INFIX(receiver: JetExpression) : CallTypeAndReceiver<JetExpression, CallType.INFIX>(CallType.INFIX, receiver)
-    class OPERATOR(receiver: JetExpression) : CallTypeAndReceiver<JetExpression, CallType.OPERATOR>(CallType.OPERATOR, receiver)
-    class CALLABLE_REFERENCE(receiver: JetTypeReference?) : CallTypeAndReceiver<JetTypeReference?, CallType.CALLABLE_REFERENCE>(CallType.CALLABLE_REFERENCE, receiver)
-    class IMPORT_DIRECTIVE(receiver: JetExpression?) : CallTypeAndReceiver<JetExpression?, CallType.IMPORT_DIRECTIVE>(CallType.IMPORT_DIRECTIVE, receiver)
-    class PACKAGE_DIRECTIVE(receiver: JetExpression?) : CallTypeAndReceiver<JetExpression?, CallType.PACKAGE_DIRECTIVE>(CallType.PACKAGE_DIRECTIVE, receiver)
-    class TYPE(receiver: JetExpression?) : CallTypeAndReceiver<JetExpression?, CallType.TYPE>(CallType.TYPE, receiver)
-    class ANNOTATION(receiver: JetExpression?) : CallTypeAndReceiver<JetExpression?, CallType.ANNOTATION>(CallType.ANNOTATION, receiver)
+    class DOT(receiver: KtExpression) : CallTypeAndReceiver<KtExpression, CallType.DOT>(CallType.DOT, receiver)
+    class SAFE(receiver: KtExpression) : CallTypeAndReceiver<KtExpression, CallType.SAFE>(CallType.SAFE, receiver)
+    class INFIX(receiver: KtExpression) : CallTypeAndReceiver<KtExpression, CallType.INFIX>(CallType.INFIX, receiver)
+    class OPERATOR(receiver: KtExpression) : CallTypeAndReceiver<KtExpression, CallType.OPERATOR>(CallType.OPERATOR, receiver)
+    class CALLABLE_REFERENCE(receiver: KtTypeReference?) : CallTypeAndReceiver<KtTypeReference?, CallType.CALLABLE_REFERENCE>(CallType.CALLABLE_REFERENCE, receiver)
+    class IMPORT_DIRECTIVE(receiver: KtExpression?) : CallTypeAndReceiver<KtExpression?, CallType.IMPORT_DIRECTIVE>(CallType.IMPORT_DIRECTIVE, receiver)
+    class PACKAGE_DIRECTIVE(receiver: KtExpression?) : CallTypeAndReceiver<KtExpression?, CallType.PACKAGE_DIRECTIVE>(CallType.PACKAGE_DIRECTIVE, receiver)
+    class TYPE(receiver: KtExpression?) : CallTypeAndReceiver<KtExpression?, CallType.TYPE>(CallType.TYPE, receiver)
+    class ANNOTATION(receiver: KtExpression?) : CallTypeAndReceiver<KtExpression?, CallType.ANNOTATION>(CallType.ANNOTATION, receiver)
 
     companion object {
-        public fun detect(expression: JetSimpleNameExpression): CallTypeAndReceiver<*, *> {
+        public fun detect(expression: KtSimpleNameExpression): CallTypeAndReceiver<*, *> {
             val parent = expression.parent
-            if (parent is JetCallableReferenceExpression) {
+            if (parent is KtCallableReferenceExpression) {
                 return CallTypeAndReceiver.CALLABLE_REFERENCE(parent.typeReference)
             }
 
@@ -122,9 +122,9 @@ public sealed class CallTypeAndReceiver<TReceiver : JetElement?, TCallType : Cal
                 return CallTypeAndReceiver.PACKAGE_DIRECTIVE(receiverExpression)
             }
 
-            if (parent is JetUserType) {
-                val constructorCallee = (parent.parent as? JetTypeReference)?.parent as? JetConstructorCalleeExpression
-                if (constructorCallee != null && constructorCallee.parent is JetAnnotationEntry) {
+            if (parent is KtUserType) {
+                val constructorCallee = (parent.parent as? KtTypeReference)?.parent as? KtConstructorCalleeExpression
+                if (constructorCallee != null && constructorCallee.parent is KtAnnotationEntry) {
                     return CallTypeAndReceiver.ANNOTATION(receiverExpression)
                 }
 
@@ -132,39 +132,39 @@ public sealed class CallTypeAndReceiver<TReceiver : JetElement?, TCallType : Cal
             }
 
             when (expression) {
-                is JetOperationReferenceExpression -> {
+                is KtOperationReferenceExpression -> {
                     if (receiverExpression == null) {
                         return UNKNOWN // incomplete code
                     }
                     return when (parent) {
-                        is JetBinaryExpression -> {
-                            if (parent.operationToken == JetTokens.IDENTIFIER)
+                        is KtBinaryExpression -> {
+                            if (parent.operationToken == KtTokens.IDENTIFIER)
                                 CallTypeAndReceiver.INFIX(receiverExpression)
                             else
                                 CallTypeAndReceiver.OPERATOR(receiverExpression)
                         }
 
-                        is JetUnaryExpression -> CallTypeAndReceiver.OPERATOR(receiverExpression)
+                        is KtUnaryExpression -> CallTypeAndReceiver.OPERATOR(receiverExpression)
 
                         else -> error("Unknown parent for JetOperationReferenceExpression: $parent")
                     }
                 }
 
-                is JetNameReferenceExpression -> {
+                is KtNameReferenceExpression -> {
                     if (receiverExpression == null) {
                         return CallTypeAndReceiver.DEFAULT
                     }
 
                     return when (parent) {
-                        is JetCallExpression -> {
-                            if ((parent.parent as JetQualifiedExpression).operationSign == JetTokens.SAFE_ACCESS)
+                        is KtCallExpression -> {
+                            if ((parent.parent as KtQualifiedExpression).operationSign == KtTokens.SAFE_ACCESS)
                                 CallTypeAndReceiver.SAFE(receiverExpression)
                             else
                                 CallTypeAndReceiver.DOT(receiverExpression)
                         }
 
-                        is JetQualifiedExpression -> {
-                            if (parent.operationSign == JetTokens.SAFE_ACCESS)
+                        is KtQualifiedExpression -> {
+                            if (parent.operationSign == KtTokens.SAFE_ACCESS)
                                 CallTypeAndReceiver.SAFE(receiverExpression)
                             else
                                 CallTypeAndReceiver.DOT(receiverExpression)
@@ -182,11 +182,11 @@ public sealed class CallTypeAndReceiver<TReceiver : JetElement?, TCallType : Cal
 
 public fun CallTypeAndReceiver<*, *>.receiverTypes(
         bindingContext: BindingContext,
-        position: JetExpression,
+        position: KtExpression,
         moduleDescriptor: ModuleDescriptor,
         predictableSmartCastsOnly: Boolean
-): Collection<JetType>? {
-    val receiverExpression: JetExpression?
+): Collection<KtType>? {
+    val receiverExpression: KtExpression?
     when (this) {
         is CallTypeAndReceiver.CALLABLE_REFERENCE -> {
             return receiver?.let { bindingContext[BindingContext.TYPE, it] }.singletonOrEmptyList()
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/FuzzyType.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/FuzzyType.kt
index f14bfc0c969..03044c917a0 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/FuzzyType.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/FuzzyType.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind
 import org.jetbrains.kotlin.resolve.calls.inference.registerTypeVariables
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.typeUtil.*
@@ -51,7 +51,7 @@ fun FuzzyType.isAlmostEverything(): Boolean {
 }
 
 class FuzzyType(
-        val type: JetType,
+        val type: KtType,
         freeParameters: Collection<TypeParameterDescriptor>
 ) {
     public val freeParameters: Set<TypeParameterDescriptor>
@@ -71,7 +71,7 @@ class FuzzyType(
 
     override fun hashCode() = type.hashCode()
 
-    private fun MutableSet<TypeParameterDescriptor>.addUsedTypeParameters(type: JetType) {
+    private fun MutableSet<TypeParameterDescriptor>.addUsedTypeParameters(type: KtType) {
         val typeParameter = type.getConstructor().getDeclarationDescriptor() as? TypeParameterDescriptor
         if (typeParameter != null && add(typeParameter)) {
             typeParameter.getLowerBounds().forEach { addUsedTypeParameters(it) }
@@ -91,10 +91,10 @@ class FuzzyType(
     public fun checkIsSuperTypeOf(otherType: FuzzyType): TypeSubstitutor?
             = matchedSubstitutor(otherType, MatchKind.IS_SUPERTYPE)
 
-    public fun checkIsSubtypeOf(otherType: JetType): TypeSubstitutor?
+    public fun checkIsSubtypeOf(otherType: KtType): TypeSubstitutor?
             = checkIsSubtypeOf(FuzzyType(otherType, emptyList()))
 
-    public fun checkIsSuperTypeOf(otherType: JetType): TypeSubstitutor?
+    public fun checkIsSuperTypeOf(otherType: KtType): TypeSubstitutor?
             = checkIsSuperTypeOf(FuzzyType(otherType, emptyList()))
 
     private enum class MatchKind {
@@ -106,7 +106,7 @@ class FuzzyType(
         if (type.isError()) return null
         if (otherType.type.isError()) return null
 
-        fun JetType.checkInheritance(otherType: JetType): Boolean {
+        fun KtType.checkInheritance(otherType: KtType): Boolean {
             return when (matchKind) {
                 MatchKind.IS_SUBTYPE -> this.isSubtypeOf(otherType)
                 MatchKind.IS_SUPERTYPE -> otherType.isSubtypeOf(this)
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/IdeDescriptorRenderers.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/IdeDescriptorRenderers.kt
index 63c8d79de2e..69d6051dd93 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/IdeDescriptorRenderers.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/IdeDescriptorRenderers.kt
@@ -20,16 +20,16 @@ import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.DescriptorRendererModifier
 import org.jetbrains.kotlin.renderer.NameShortness
 import org.jetbrains.kotlin.renderer.OverrideRenderingPolicy
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.isDynamic
 import org.jetbrains.kotlin.types.typeUtil.builtIns
 
 public object IdeDescriptorRenderers {
-    public val APPROXIMATE_FLEXIBLE_TYPES: (JetType) -> JetType = { approximateFlexibleTypes(it, true) }
+    public val APPROXIMATE_FLEXIBLE_TYPES: (KtType) -> KtType = { approximateFlexibleTypes(it, true) }
 
-    public val APPROXIMATE_FLEXIBLE_TYPES_IN_ARGUMENTS: (JetType) -> JetType = { approximateFlexibleTypes(it, false) }
+    public val APPROXIMATE_FLEXIBLE_TYPES_IN_ARGUMENTS: (KtType) -> KtType = { approximateFlexibleTypes(it, false) }
 
-    private fun unwrapAnonymousType(type: JetType): JetType {
+    private fun unwrapAnonymousType(type: KtType): KtType {
         if (type.isDynamic()) return type
 
         val classifier = type.constructor.declarationDescriptor
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ImportsUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ImportsUtils.kt
index 79637343079..bd81e950d63 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ImportsUtils.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ImportsUtils.kt
@@ -20,13 +20,13 @@ package org.jetbrains.kotlin.idea.imports
 
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetReferenceExpression
+import org.jetbrains.kotlin.psi.KtReferenceExpression
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.bindingContextUtil.getReferenceTargets
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.resolve.descriptorUtil.getImportableDescriptor
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 public val DeclarationDescriptor.importableFqName: FqName?
     get() {
@@ -51,13 +51,13 @@ public fun DeclarationDescriptor.canBeReferencedViaImport(): Boolean {
     }
 }
 
-public fun JetType.canBeReferencedViaImport(): Boolean {
+public fun KtType.canBeReferencedViaImport(): Boolean {
     val descriptor = getConstructor().getDeclarationDescriptor()
     return descriptor != null && descriptor.canBeReferencedViaImport()
 }
 
 // for cases when class qualifier refers companion object treats it like reference to class itself
-public fun JetReferenceExpression.getImportableTargets(bindingContext: BindingContext): Collection<DeclarationDescriptor> {
+public fun KtReferenceExpression.getImportableTargets(bindingContext: BindingContext): Collection<DeclarationDescriptor> {
     val targets = bindingContext[BindingContext.SHORT_REFERENCE_TO_COMPANION_OBJECT, this]?.let { listOf(it) }
                   ?: getReferenceTargets(bindingContext)
     return targets.map { it.getImportableDescriptor() }.toSet()
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt
index 403b3cdce55..8297feebcb6 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt
@@ -40,14 +40,14 @@ import java.util.*
 public class ShadowedDeclarationsFilter private constructor(
         private val bindingContext: BindingContext,
         private val resolutionFacade: ResolutionFacade,
-        private val context: JetExpression,
+        private val context: KtExpression,
         private val explicitReceiverValue: ReceiverValue
 ) {
     companion object {
         fun create(
                 bindingContext: BindingContext,
                 resolutionFacade: ResolutionFacade,
-                context: JetExpression,
+                context: KtExpression,
                 callTypeAndReceiver: CallTypeAndReceiver<*, *>
         ): ShadowedDeclarationsFilter? {
             val receiverExpression = when (callTypeAndReceiver) {
@@ -67,7 +67,7 @@ public class ShadowedDeclarationsFilter private constructor(
         }
     }
 
-    private val psiFactory = JetPsiFactory(resolutionFacade.project)
+    private val psiFactory = KtPsiFactory(resolutionFacade.project)
     private val dummyExpressionFactory = DummyExpressionFactory(psiFactory)
 
     public fun <TDescriptor : DeclarationDescriptor> filter(declarations: Collection<TDescriptor>): Collection<TDescriptor> {
@@ -173,7 +173,7 @@ public class ShadowedDeclarationsFilter private constructor(
 
             override fun getFunctionLiteralArguments() = emptyList<FunctionLiteralArgument>()
 
-            override fun getTypeArguments() = emptyList<JetTypeProjection>()
+            override fun getTypeArguments() = emptyList<KtTypeProjection>()
 
             override fun getTypeArgumentList() = null
 
@@ -209,10 +209,10 @@ public class ShadowedDeclarationsFilter private constructor(
         return if (filtered.isNotEmpty()) filtered else descriptors /* something went wrong, none of our declarations among resolve candidates, let's not filter anything */
     }
 
-    private class DummyExpressionFactory(val factory: JetPsiFactory) {
-        private val expressions = ArrayList<JetExpression>()
+    private class DummyExpressionFactory(val factory: KtPsiFactory) {
+        private val expressions = ArrayList<KtExpression>()
 
-        fun createDummyExpressions(count: Int): List<JetExpression> {
+        fun createDummyExpressions(count: Int): List<KtExpression> {
             while (expressions.size() < count) {
                 expressions.add(factory.createExpression("dummy"))
             }
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt
index 214954b4cbe..be21002210d 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.resolve.scopes.utils.getClassifier
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.typeUtil.*
 
-public fun approximateFlexibleTypes(jetType: JetType, outermost: Boolean = true): JetType {
+public fun approximateFlexibleTypes(jetType: KtType, outermost: Boolean = true): KtType {
     if (jetType.isDynamic()) return jetType
     if (jetType.isFlexible()) {
         val flexible = jetType.flexibility()
@@ -60,7 +60,7 @@ public fun approximateFlexibleTypes(jetType: JetType, outermost: Boolean = true)
 
         return approximation
     }
-    return JetTypeImpl.create(
+    return KtTypeImpl.create(
             jetType.getAnnotations(),
             jetType.getConstructor(),
             jetType.isMarkedNullable(),
@@ -69,15 +69,15 @@ public fun approximateFlexibleTypes(jetType: JetType, outermost: Boolean = true)
     )
 }
 
-public fun JetType.isAnnotatedReadOnly(): Boolean = hasAnnotationMaybeExternal(JETBRAINS_READONLY_ANNOTATION)
-public fun JetType.isAnnotatedNotNull(): Boolean = hasAnnotationMaybeExternal(JETBRAINS_NOT_NULL_ANNOTATION)
-public fun JetType.isAnnotatedNullable(): Boolean = hasAnnotationMaybeExternal(JETBRAINS_NULLABLE_ANNOTATION)
+public fun KtType.isAnnotatedReadOnly(): Boolean = hasAnnotationMaybeExternal(JETBRAINS_READONLY_ANNOTATION)
+public fun KtType.isAnnotatedNotNull(): Boolean = hasAnnotationMaybeExternal(JETBRAINS_NOT_NULL_ANNOTATION)
+public fun KtType.isAnnotatedNullable(): Boolean = hasAnnotationMaybeExternal(JETBRAINS_NULLABLE_ANNOTATION)
 
-private fun JetType.hasAnnotationMaybeExternal(fqName: FqName) = with (getAnnotations()) {
+private fun KtType.hasAnnotationMaybeExternal(fqName: FqName) = with (getAnnotations()) {
     findAnnotation(fqName) ?: findExternalAnnotation(fqName)
 } != null
 
-fun JetType.isResolvableInScope(scope: LexicalScope?, checkTypeParameters: Boolean): Boolean {
+fun KtType.isResolvableInScope(scope: LexicalScope?, checkTypeParameters: Boolean): Boolean {
     if (canBeReferencedViaImport()) return true
 
     val descriptor = getConstructor().getDeclarationDescriptor()
@@ -87,13 +87,13 @@ fun JetType.isResolvableInScope(scope: LexicalScope?, checkTypeParameters: Boole
     return scope != null && scope.getClassifier(descriptor.name, NoLookupLocation.FROM_IDE) == descriptor
 }
 
-public fun JetType.approximateWithResolvableType(scope: LexicalScope?, checkTypeParameters: Boolean): JetType {
+public fun KtType.approximateWithResolvableType(scope: LexicalScope?, checkTypeParameters: Boolean): KtType {
     if (isError() || isResolvableInScope(scope, checkTypeParameters)) return this
     return supertypes().firstOrNull { it.isResolvableInScope(scope, checkTypeParameters) }
            ?: builtIns.anyType
 }
 
-public fun JetType.anonymousObjectSuperTypeOrNull(): JetType? {
+public fun KtType.anonymousObjectSuperTypeOrNull(): KtType? {
     val classDescriptor = constructor.declarationDescriptor
     if (classDescriptor != null && DescriptorUtils.isAnonymousObject(classDescriptor)) {
         return immediateSupertypes().firstOrNull() ?: classDescriptor.builtIns.anyType
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/Utils.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/Utils.kt
index 8bd0518e496..9305b1f733d 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/Utils.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/Utils.kt
@@ -19,23 +19,23 @@ package org.jetbrains.kotlin.idea.util
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 
-public fun JetFunctionLiteral.findLabelAndCall(): Pair<Name?, JetCallExpression?> {
-    val literalParent = (this.getParent() as JetFunctionLiteralExpression).getParent()
+public fun KtFunctionLiteral.findLabelAndCall(): Pair<Name?, KtCallExpression?> {
+    val literalParent = (this.getParent() as KtFunctionLiteralExpression).getParent()
 
-    fun JetValueArgument.callExpression(): JetCallExpression? {
+    fun KtValueArgument.callExpression(): KtCallExpression? {
         val parent = getParent()
-        return (if (parent is JetValueArgumentList) parent else this).getParent() as? JetCallExpression
+        return (if (parent is KtValueArgumentList) parent else this).getParent() as? KtCallExpression
     }
 
     when (literalParent) {
-        is JetLabeledExpression -> {
-            val callExpression = (literalParent.getParent() as? JetValueArgument)?.callExpression()
+        is KtLabeledExpression -> {
+            val callExpression = (literalParent.getParent() as? KtValueArgument)?.callExpression()
             return Pair(literalParent.getLabelNameAsName(), callExpression)
         }
 
-        is JetValueArgument -> {
+        is KtValueArgument -> {
             val callExpression = literalParent.callExpression()
-            val label = (callExpression?.getCalleeExpression() as? JetSimpleNameExpression)?.getReferencedNameAsName()
+            val label = (callExpression?.getCalleeExpression() as? KtSimpleNameExpression)?.getReferencedNameAsName()
             return Pair(label, callExpression)
         }
 
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt
index d26c42b8481..f46415a4208 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt
@@ -20,16 +20,16 @@ package org.jetbrains.kotlin.idea.util
 
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.psi.JetPsiUtil
-import org.jetbrains.kotlin.psi.JetThisExpression
+import org.jetbrains.kotlin.psi.KtPsiUtil
+import org.jetbrains.kotlin.psi.KtThisExpression
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastManager
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.typeUtil.TypeNullability
 import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import org.jetbrains.kotlin.types.typeUtil.nullability
@@ -51,7 +51,7 @@ public fun CallableDescriptor.substituteExtensionIfCallable(
 }
 
 public fun CallableDescriptor.substituteExtensionIfCallableWithImplicitReceiver(
-        scope: JetScope,
+        scope: KtScope,
         context: BindingContext,
         dataFlowInfo: DataFlowInfo
 ): Collection<CallableDescriptor> {
@@ -73,7 +73,7 @@ public fun CallableDescriptor.substituteExtensionIfCallable(
 }
 
 public fun CallableDescriptor.substituteExtensionIfCallable(
-        receiverTypes: Collection<JetType>,
+        receiverTypes: Collection<KtType>,
         callType: CallType<*>
 ): Collection<CallableDescriptor> {
     if (!callType.descriptorKindFilter.accepts(this)) return listOf()
@@ -105,7 +105,7 @@ public fun CallableDescriptor.substituteExtensionIfCallable(
 public fun ReceiverValue.getThisReceiverOwner(bindingContext: BindingContext): DeclarationDescriptor? {
     return when (this) {
         is ExpressionReceiver -> {
-            val thisRef = (JetPsiUtil.deparenthesize(this.getExpression()) as? JetThisExpression)?.getInstanceReference() ?: return null
+            val thisRef = (KtPsiUtil.deparenthesize(this.getExpression()) as? KtThisExpression)?.getInstanceReference() ?: return null
             bindingContext[BindingContext.REFERENCE_TARGET, thisRef]
         }
 
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/implicitReceiversUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/implicitReceiversUtils.kt
index 4f6bdb4b995..3554d14b433 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/implicitReceiversUtils.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/implicitReceiversUtils.kt
@@ -21,24 +21,24 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetFunctionLiteral
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtFunctionLiteral
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.renderer.render
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import java.util.LinkedHashMap
 import java.util.LinkedHashSet
 
-public fun JetScope.getImplicitReceiversWithInstance(): Collection<ReceiverParameterDescriptor>
+public fun KtScope.getImplicitReceiversWithInstance(): Collection<ReceiverParameterDescriptor>
         = getImplicitReceiversWithInstanceToExpression().keySet()
 
 public interface ReceiverExpressionFactory {
-    public fun createExpression(psiFactory: JetPsiFactory, shortThis: Boolean = true): JetExpression
+    public fun createExpression(psiFactory: KtPsiFactory, shortThis: Boolean = true): KtExpression
 }
 
-public fun JetScope.getImplicitReceiversWithInstanceToExpression(): Map<ReceiverParameterDescriptor, ReceiverExpressionFactory?> {
+public fun KtScope.getImplicitReceiversWithInstanceToExpression(): Map<ReceiverParameterDescriptor, ReceiverExpressionFactory?> {
     // we use a set to workaround a bug with receiver for companion object present twice in the result of getImplicitReceiversHierarchy()
     val receivers = LinkedHashSet(getImplicitReceiversHierarchy())
 
@@ -74,7 +74,7 @@ public fun JetScope.getImplicitReceiversWithInstanceToExpression(): Map<Receiver
         }
         val factory = if (expressionText != null)
             object : ReceiverExpressionFactory {
-                override fun createExpression(psiFactory: JetPsiFactory, shortThis: Boolean): JetExpression {
+                override fun createExpression(psiFactory: KtPsiFactory, shortThis: Boolean): KtExpression {
                     return psiFactory.createExpression(if (shortThis && isImmediateThis) "this" else expressionText)
                 }
             }
@@ -90,6 +90,6 @@ private fun thisQualifierName(receiver: ReceiverParameterDescriptor): Name? {
     val name = descriptor.getName()
     if (!name.isSpecial()) return name
 
-    val functionLiteral = DescriptorToSourceUtils.descriptorToDeclaration(descriptor) as? JetFunctionLiteral
+    val functionLiteral = DescriptorToSourceUtils.descriptorToDeclaration(descriptor) as? KtFunctionLiteral
     return functionLiteral?.findLabelAndCall()?.first
 }
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/scopeUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/scopeUtils.kt
index 479da690261..ae83ba4fb0b 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/scopeUtils.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/scopeUtils.kt
@@ -22,21 +22,21 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 
 
-public fun JetScope.getAllAccessibleVariables(name: Name): Collection<VariableDescriptor>
+public fun KtScope.getAllAccessibleVariables(name: Name): Collection<VariableDescriptor>
         = getVariablesFromImplicitReceivers(name) + getProperties(name, NoLookupLocation.FROM_IDE) + listOfNotNull(getLocalVariable(name))
 
-public fun JetScope.getAllAccessibleFunctions(name: Name): Collection<FunctionDescriptor>
+public fun KtScope.getAllAccessibleFunctions(name: Name): Collection<FunctionDescriptor>
         = getImplicitReceiversWithInstance().flatMap { it.type.memberScope.getFunctions(name, NoLookupLocation.FROM_IDE) } +
           getFunctions(name, NoLookupLocation.FROM_IDE)
 
-public fun JetScope.getVariablesFromImplicitReceivers(name: Name): Collection<VariableDescriptor> = getImplicitReceiversWithInstance().flatMap {
+public fun KtScope.getVariablesFromImplicitReceivers(name: Name): Collection<VariableDescriptor> = getImplicitReceiversWithInstance().flatMap {
     it.type.memberScope.getProperties(name, NoLookupLocation.FROM_IDE)
 }
 
-public fun JetScope.getVariableFromImplicitReceivers(name: Name): VariableDescriptor? {
+public fun KtScope.getVariableFromImplicitReceivers(name: Name): VariableDescriptor? {
     getImplicitReceiversWithInstance().forEach {
         it.type.memberScope.getProperties(name, NoLookupLocation.FROM_IDE).singleOrNull()?.let { return it }
     }
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/PartialBodyResolveFilter.kt b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/PartialBodyResolveFilter.kt
index 436c36bb62d..93d59d9ffa9 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/PartialBodyResolveFilter.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/PartialBodyResolveFilter.kt
@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.resolve.lazy
 
 import com.intellij.psi.PsiElement
 import com.intellij.util.SmartList
-import org.jetbrains.kotlin.JetNodeTypes
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.KtNodeTypes
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.*
 import org.jetbrains.kotlin.resolve.StatementFilter
@@ -33,8 +33,8 @@ import java.util.HashSet
 //TODO: do resolve anonymous object's body
 
 class PartialBodyResolveFilter(
-        elementToResolve: JetElement,
-        private val declaration: JetDeclaration,
+        elementToResolve: KtElement,
+        private val declaration: KtDeclaration,
         probablyNothingCallableNames: ProbablyNothingCallableNames,
         forCompletion: Boolean
 ) : StatementFilter() {
@@ -44,20 +44,20 @@ class PartialBodyResolveFilter(
     private val nothingFunctionNames = HashSet(probablyNothingCallableNames.functionNames())
     private val nothingVariableNames = HashSet(probablyNothingCallableNames.propertyNames())
 
-    override val filter: ((JetExpression) -> Boolean)? = { statementMarks.statementMark(it) != MarkLevel.NONE }
+    override val filter: ((KtExpression) -> Boolean)? = { statementMarks.statementMark(it) != MarkLevel.NONE }
 
-    val allStatementsToResolve: Collection<JetExpression>
+    val allStatementsToResolve: Collection<KtExpression>
         get() = statementMarks.allMarkedStatements()
 
     init {
         assert(declaration.isAncestor(elementToResolve))
-        assert(!JetPsiUtil.isLocal(declaration)) { "Should never be invoked on local declaration otherwise we may miss some local declarations with type Nothing" }
+        assert(!KtPsiUtil.isLocal(declaration)) { "Should never be invoked on local declaration otherwise we may miss some local declarations with type Nothing" }
 
-        declaration.forEachDescendantOfType<JetCallableDeclaration> { declaration ->
+        declaration.forEachDescendantOfType<KtCallableDeclaration> { declaration ->
             if (declaration.getTypeReference().containsProbablyNothing()) {
                 val name = declaration.getName()
                 if (name != null) {
-                    if (declaration is JetNamedFunction) {
+                    if (declaration is KtNamedFunction) {
                         nothingFunctionNames.add(name)
                     }
                     else {
@@ -73,7 +73,7 @@ class PartialBodyResolveFilter(
 
     //TODO: do..while is special case
 
-    private fun processBlock(block: JetBlockExpression): NameFilter {
+    private fun processBlock(block: KtBlockExpression): NameFilter {
         if (isValueNeeded(block)) {
             block.lastStatement()?.let { statementMarks.mark(it, MarkLevel.NEED_REFERENCE_RESOLVE) }
         }
@@ -82,15 +82,15 @@ class PartialBodyResolveFilter(
         val startStatement = statementMarks.lastMarkedStatement(block, MarkLevel.NEED_REFERENCE_RESOLVE) ?: return nameFilter
 
         for (statement in startStatement.siblings(forward = false)) {
-            if (statement !is JetExpression) continue
+            if (statement !is KtExpression) continue
 
-            if (statement is JetNamedDeclaration) {
+            if (statement is KtNamedDeclaration) {
                 val name = statement.getName()
                 if (name != null && nameFilter(name)) {
                     statementMarks.mark(statement, MarkLevel.NEED_REFERENCE_RESOLVE)
                 }
             }
-            else if (statement is JetMultiDeclaration) {
+            else if (statement is KtMultiDeclaration) {
                 if (statement.getEntries().any {
                     val name = it.getName()
                     name != null && nameFilter(name)
@@ -138,22 +138,22 @@ class PartialBodyResolveFilter(
      * Returns map from smart-cast expression names (variable name or qualified variable name) to places.
      */
     private fun potentialSmartCastPlaces(
-            statement: JetExpression,
+            statement: KtExpression,
             filter: (SmartCastName) -> Boolean = { true }
-    ): Map<SmartCastName, List<JetExpression>> {
-        val map = HashMap<SmartCastName, ArrayList<JetExpression>>(0)
+    ): Map<SmartCastName, List<KtExpression>> {
+        val map = HashMap<SmartCastName, ArrayList<KtExpression>>(0)
 
-        fun addPlace(name: SmartCastName, place: JetExpression) {
+        fun addPlace(name: SmartCastName, place: KtExpression) {
             map.getOrPut(name, { ArrayList(1) }).add(place)
         }
 
-        fun addPlaces(name: SmartCastName, places: Collection<JetExpression>) {
+        fun addPlaces(name: SmartCastName, places: Collection<KtExpression>) {
             if (places.isNotEmpty()) {
                 map.getOrPut(name, { ArrayList(places.size()) }).addAll(places)
             }
         }
 
-        fun addIfCanBeSmartCast(expression: JetExpression) {
+        fun addIfCanBeSmartCast(expression: KtExpression) {
             val name = expression.smartCastExpressionName() ?: return
             if (filter(name)) {
                 addPlace(name, expression)
@@ -161,26 +161,26 @@ class PartialBodyResolveFilter(
         }
 
         statement.accept(object : ControlFlowVisitor() {
-            override fun visitPostfixExpression(expression: JetPostfixExpression) {
+            override fun visitPostfixExpression(expression: KtPostfixExpression) {
                 expression.acceptChildren(this)
 
-                if (expression.getOperationToken() == JetTokens.EXCLEXCL) {
+                if (expression.getOperationToken() == KtTokens.EXCLEXCL) {
                     addIfCanBeSmartCast(expression.getBaseExpression() ?: return)
                 }
             }
 
-            override fun visitBinaryWithTypeRHSExpression(expression: JetBinaryExpressionWithTypeRHS) {
+            override fun visitBinaryWithTypeRHSExpression(expression: KtBinaryExpressionWithTypeRHS) {
                 expression.acceptChildren(this)
 
-                if (expression.getOperationReference().getReferencedNameElementType() == JetTokens.AS_KEYWORD) {
+                if (expression.getOperationReference().getReferencedNameElementType() == KtTokens.AS_KEYWORD) {
                     addIfCanBeSmartCast(expression.getLeft())
                 }
             }
 
-            override fun visitBinaryExpression(expression: JetBinaryExpression) {
+            override fun visitBinaryExpression(expression: KtBinaryExpression) {
                 expression.acceptChildren(this)
 
-                if (expression.getOperationToken() == JetTokens.ELVIS) {
+                if (expression.getOperationToken() == KtTokens.ELVIS) {
                     val left = expression.getLeft()
                     val right = expression.getRight()
                     if (left != null && right != null) {
@@ -193,14 +193,14 @@ class PartialBodyResolveFilter(
                 }
             }
 
-            override fun visitIfExpression(expression: JetIfExpression) {
+            override fun visitIfExpression(expression: KtIfExpression) {
                 val condition = expression.getCondition()
                 val thenBranch = expression.getThen()
                 val elseBranch = expression.getElse()
 
                 val (thenSmartCastNames, elseSmartCastNames) = possiblySmartCastInCondition(condition)
 
-                fun processBranchExits(smartCastNames: Collection<SmartCastName>, branch: JetExpression?) {
+                fun processBranchExits(smartCastNames: Collection<SmartCastName>, branch: KtExpression?) {
                     if (branch == null) return
                     val filteredNames = smartCastNames.filter(filter)
                     if (filteredNames.isNotEmpty()) {
@@ -237,12 +237,12 @@ class PartialBodyResolveFilter(
                 }
             }
 
-            override fun visitForExpression(expression: JetForExpression) {
+            override fun visitForExpression(expression: KtForExpression) {
                 // analyze only the loop-range expression, do not enter the loop body
                 expression.getLoopRange()?.accept(this)
             }
 
-            override fun visitWhileExpression(expression: JetWhileExpression) {
+            override fun visitWhileExpression(expression: KtWhileExpression) {
                 val condition = expression.getCondition()
                 // we need to enter the body only for "while(true)"
                 if (condition.isTrueConstant()) {
@@ -264,10 +264,10 @@ class PartialBodyResolveFilter(
      * in then (first component) and else (second component)
      * branches of an if-statement with such condition
      */
-    private fun possiblySmartCastInCondition(condition: JetExpression?): Pair<Set<SmartCastName>, Set<SmartCastName>> {
+    private fun possiblySmartCastInCondition(condition: KtExpression?): Pair<Set<SmartCastName>, Set<SmartCastName>> {
         val emptyResult = Pair(setOf<SmartCastName>(), setOf<SmartCastName>())
         when (condition) {
-            is JetBinaryExpression -> {
+            is KtBinaryExpression -> {
                 val operation = condition.getOperationToken()
                 val left = condition.getLeft() ?: return emptyResult
                 val right = condition.getRight() ?: return emptyResult
@@ -288,17 +288,17 @@ class PartialBodyResolveFilter(
                 }
 
                 when (operation) {
-                    JetTokens.EQEQ, JetTokens.EQEQEQ -> return smartCastInEq()
+                    KtTokens.EQEQ, KtTokens.EQEQEQ -> return smartCastInEq()
 
-                    JetTokens.EXCLEQ, JetTokens.EXCLEQEQEQ -> return smartCastInEq().swap()
+                    KtTokens.EXCLEQ, KtTokens.EXCLEQEQEQ -> return smartCastInEq().swap()
 
-                    JetTokens.ANDAND -> {
+                    KtTokens.ANDAND -> {
                         val casts1 = possiblySmartCastInCondition(left)
                         val casts2 = possiblySmartCastInCondition(right)
                         return Pair(casts1.first.union(casts2.first), casts1.second.intersect(casts2.second))
                     }
 
-                    JetTokens.OROR -> {
+                    KtTokens.OROR -> {
                         val casts1 = possiblySmartCastInCondition(left)
                         val casts2 = possiblySmartCastInCondition(right)
                         return Pair(casts1.first.intersect(casts2.first), casts1.second.union(casts2.second))
@@ -306,19 +306,19 @@ class PartialBodyResolveFilter(
                 }
             }
 
-            is JetIsExpression -> {
+            is KtIsExpression -> {
                 val cast = condition.getLeftHandSide().smartCastExpressionName().singletonOrEmptySet()
                 return if (condition.isNegated()) Pair(setOf(), cast) else Pair(cast, setOf())
             }
 
-            is JetPrefixExpression -> {
-                if (condition.getOperationToken() == JetTokens.EXCL) {
+            is KtPrefixExpression -> {
+                if (condition.getOperationToken() == KtTokens.EXCL) {
                     val operand = condition.getBaseExpression() ?: return emptyResult
                     return possiblySmartCastInCondition(operand).swap()
                 }
             }
 
-            is JetParenthesizedExpression -> {
+            is KtParenthesizedExpression -> {
                 val operand = condition.getExpression() ?: return emptyResult
                 return possiblySmartCastInCondition(operand)
             }
@@ -331,20 +331,20 @@ class PartialBodyResolveFilter(
      * If it's possible that the given statement never passes the execution to the next statement (that is, always exits somewhere)
      * then this function returns a collection of all places in code that are necessary to be kept to preserve this behaviour.
      */
-    private fun collectAlwaysExitPoints(statement: JetExpression?): Collection<JetExpression> {
-        val result = ArrayList<JetExpression>()
+    private fun collectAlwaysExitPoints(statement: KtExpression?): Collection<KtExpression> {
+        val result = ArrayList<KtExpression>()
         statement?.accept(object : ControlFlowVisitor() {
             var insideLoopLevel: Int = 0
 
-            override fun visitReturnExpression(expression: JetReturnExpression) {
+            override fun visitReturnExpression(expression: KtReturnExpression) {
                 result.add(expression)
             }
 
-            override fun visitThrowExpression(expression: JetThrowExpression) {
+            override fun visitThrowExpression(expression: KtThrowExpression) {
                 result.add(expression)
             }
 
-            override fun visitIfExpression(expression: JetIfExpression) {
+            override fun visitIfExpression(expression: KtIfExpression) {
                 expression.getCondition()?.accept(this)
 
                 val thenBranch = expression.getThen()
@@ -361,12 +361,12 @@ class PartialBodyResolveFilter(
                 }
             }
 
-            override fun visitForExpression(loop: JetForExpression) {
+            override fun visitForExpression(loop: KtForExpression) {
                 loop.getLoopRange()?.accept(this)
                 // do not make sense to search exits inside for as not necessary enter it at all
             }
 
-            override fun visitWhileExpression(loop: JetWhileExpression) {
+            override fun visitWhileExpression(loop: KtWhileExpression) {
                 val condition = loop.getCondition() ?: return
                 if (condition.isTrueConstant()) {
                     insideLoopLevel++
@@ -379,42 +379,42 @@ class PartialBodyResolveFilter(
                 }
             }
 
-            override fun visitDoWhileExpression(loop: JetDoWhileExpression) {
+            override fun visitDoWhileExpression(loop: KtDoWhileExpression) {
                 loop.getCondition()?.accept(this)
                 insideLoopLevel++
                 loop.getBody()?.accept(this)
                 insideLoopLevel--
             }
 
-            override fun visitBreakExpression(expression: JetBreakExpression) {
+            override fun visitBreakExpression(expression: KtBreakExpression) {
                 if (insideLoopLevel == 0 || expression.getLabelName() != null) {
                     result.add(expression)
                 }
             }
 
-            override fun visitContinueExpression(expression: JetContinueExpression) {
+            override fun visitContinueExpression(expression: KtContinueExpression) {
                 if (insideLoopLevel == 0 || expression.getLabelName() != null) {
                     result.add(expression)
                 }
             }
 
-            override fun visitCallExpression(expression: JetCallExpression) {
-                val name = (expression.getCalleeExpression() as? JetSimpleNameExpression)?.getReferencedName()
+            override fun visitCallExpression(expression: KtCallExpression) {
+                val name = (expression.getCalleeExpression() as? KtSimpleNameExpression)?.getReferencedName()
                 if (name != null && name in nothingFunctionNames) {
                     result.add(expression)
                 }
                 super.visitCallExpression(expression)
             }
 
-            override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+            override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
                 val name = expression.getReferencedName()
                 if (name in nothingVariableNames) {
                     result.add(expression)
                 }
             }
 
-            override fun visitBinaryExpression(expression: JetBinaryExpression) {
-                if (expression.getOperationToken() == JetTokens.ELVIS) {
+            override fun visitBinaryExpression(expression: KtBinaryExpression) {
+                if (expression.getOperationToken() == KtTokens.ELVIS) {
                     // do not search exits after "?:"
                     expression.getLeft()?.accept(this)
                 }
@@ -429,13 +429,13 @@ class PartialBodyResolveFilter(
     /**
      * Recursively visits code but does not enter constructs that may not affect smart casts/control flow
      */
-    private abstract class ControlFlowVisitor : JetVisitorVoid() {
-        override fun visitJetElement(element: JetElement) {
+    private abstract class ControlFlowVisitor : KtVisitorVoid() {
+        override fun visitJetElement(element: KtElement) {
             if (element.noControlFlowInside()) return
             element.acceptChildren(this)
         }
 
-        private fun JetElement.noControlFlowInside() = this is JetFunction || this is JetClass || this is JetClassBody
+        private fun KtElement.noControlFlowInside() = this is KtFunction || this is KtClass || this is KtClassBody
     }
 
     private data class SmartCastName(
@@ -457,22 +457,22 @@ class PartialBodyResolveFilter(
         }
     }
 
-    private fun JetExpression.smartCastExpressionName(): SmartCastName? {
+    private fun KtExpression.smartCastExpressionName(): SmartCastName? {
         return when (this) {
-            is JetSimpleNameExpression -> SmartCastName(null, this.getReferencedName())
+            is KtSimpleNameExpression -> SmartCastName(null, this.getReferencedName())
 
-            is JetQualifiedExpression -> {
-                val selector = getSelectorExpression() as? JetSimpleNameExpression ?: return null
+            is KtQualifiedExpression -> {
+                val selector = getSelectorExpression() as? KtSimpleNameExpression ?: return null
                 val selectorName = selector.getReferencedName()
                 val receiver = getReceiverExpression()
-                if (receiver is JetThisExpression) {
+                if (receiver is KtThisExpression) {
                     return SmartCastName(null, selectorName)
                 }
                 val receiverName = receiver.smartCastExpressionName() ?: return null
                 return SmartCastName(receiverName, selectorName)
             }
 
-            is JetThisExpression -> SmartCastName(null, null)
+            is KtThisExpression -> SmartCastName(null, null)
 
             else -> null
         }
@@ -487,9 +487,9 @@ class PartialBodyResolveFilter(
         val isEmpty: Boolean
             get() = names?.isEmpty() ?: false
 
-        fun addUsedNames(statement: JetExpression) {
+        fun addUsedNames(statement: KtExpression) {
             if (names != null) {
-                statement.forEachDescendantOfType<JetSimpleNameExpression>(canGoInside = { it !is JetBlockExpression }) {
+                statement.forEachDescendantOfType<KtSimpleNameExpression>(canGoInside = { it !is KtBlockExpression }) {
                     names!!.add(it.getReferencedName())
                 }
             }
@@ -518,74 +518,74 @@ class PartialBodyResolveFilter(
     }
 
     companion object {
-        public fun findStatementToResolve(element: JetElement, declaration: JetDeclaration): JetExpression? {
-            return element.parentsWithSelf.takeWhile { it != declaration }.firstOrNull { it.isStatement() } as JetExpression?
+        public fun findStatementToResolve(element: KtElement, declaration: KtDeclaration): KtExpression? {
+            return element.parentsWithSelf.takeWhile { it != declaration }.firstOrNull { it.isStatement() } as KtExpression?
         }
 
-        private fun JetElement.forTopLevelBlocksInside(action: (JetBlockExpression) -> Unit) {
-            forEachDescendantOfType(canGoInside = { it !is JetBlockExpression }, action = action)
+        private fun KtElement.forTopLevelBlocksInside(action: (KtBlockExpression) -> Unit) {
+            forEachDescendantOfType(canGoInside = { it !is KtBlockExpression }, action = action)
         }
 
-        private fun JetExpression?.isNullLiteral() = this?.getNode()?.getElementType() == JetNodeTypes.NULL
+        private fun KtExpression?.isNullLiteral() = this?.getNode()?.getElementType() == KtNodeTypes.NULL
 
-        private fun JetExpression?.isTrueConstant()
-                = this != null && getNode()?.getElementType() == JetNodeTypes.BOOLEAN_CONSTANT && getText() == "true"
+        private fun KtExpression?.isTrueConstant()
+                = this != null && getNode()?.getElementType() == KtNodeTypes.BOOLEAN_CONSTANT && getText() == "true"
 
         private fun <T : Any> T?.singletonOrEmptySet(): Set<T> = if (this != null) setOf(this) else setOf()
 
         //TODO: review logic
-        private fun isValueNeeded(expression: JetExpression): Boolean {
+        private fun isValueNeeded(expression: KtExpression): Boolean {
             val parent = expression.getParent()
             return when (parent) {
-                is JetBlockExpression -> expression == parent.lastStatement() && isValueNeeded(parent)
+                is KtBlockExpression -> expression == parent.lastStatement() && isValueNeeded(parent)
 
-                is JetContainerNode -> { //TODO - not quite correct
-                    val pparent = parent.getParent() as? JetExpression
+                is KtContainerNode -> { //TODO - not quite correct
+                    val pparent = parent.getParent() as? KtExpression
                     pparent != null && isValueNeeded(pparent)
                 }
 
-                is JetDeclarationWithBody -> {
+                is KtDeclarationWithBody -> {
                     if (expression == parent.getBodyExpression())
                         !parent.hasBlockBody() && !parent.hasDeclaredReturnType()
                     else
                         true
                 }
 
-                is JetClassInitializer -> false
+                is KtClassInitializer -> false
 
                 else -> true
             }
         }
 
-        private fun JetBlockExpression.lastStatement(): JetExpression?
-                = getLastChild()?.siblings(forward = false)?.firstIsInstanceOrNull<JetExpression>()
+        private fun KtBlockExpression.lastStatement(): KtExpression?
+                = getLastChild()?.siblings(forward = false)?.firstIsInstanceOrNull<KtExpression>()
 
-        private fun PsiElement.isStatement() = this is JetExpression && getParent() is JetBlockExpression
+        private fun PsiElement.isStatement() = this is KtExpression && getParent() is KtBlockExpression
 
-        private fun JetTypeReference?.containsProbablyNothing()
-                = this?.typeElement?.anyDescendantOfType<JetUserType> { it.isProbablyNothing() } ?: false
+        private fun KtTypeReference?.containsProbablyNothing()
+                = this?.typeElement?.anyDescendantOfType<KtUserType> { it.isProbablyNothing() } ?: false
     }
 
     private inner class StatementMarks {
-        private val statementMarks = HashMap<JetExpression, MarkLevel>()
-        private val blockLevels = HashMap<JetBlockExpression, MarkLevel>()
+        private val statementMarks = HashMap<KtExpression, MarkLevel>()
+        private val blockLevels = HashMap<KtBlockExpression, MarkLevel>()
 
         fun mark(element: PsiElement, level: MarkLevel) {
             var e = element
             while (e != declaration) {
                 if (e.isStatement()) {
-                    markStatement(e as JetExpression, level)
+                    markStatement(e as KtExpression, level)
                 }
                 e = e.getParent()!!
             }
         }
 
-        private fun markStatement(statement: JetExpression, level: MarkLevel) {
+        private fun markStatement(statement: KtExpression, level: MarkLevel) {
             val currentLevel = statementMark(statement)
             if (currentLevel < level) {
                 statementMarks[statement] = level
 
-                val block = statement.getParent() as JetBlockExpression
+                val block = statement.getParent() as KtBlockExpression
                 val currentBlockLevel = blockLevels[block] ?: MarkLevel.NONE
                 if (currentBlockLevel < level) {
                     blockLevels[block] = level
@@ -593,17 +593,17 @@ class PartialBodyResolveFilter(
             }
         }
 
-        fun statementMark(statement: JetExpression): MarkLevel
+        fun statementMark(statement: KtExpression): MarkLevel
                 = statementMarks[statement] ?: MarkLevel.NONE
 
-        fun allMarkedStatements(): Collection<JetExpression>
+        fun allMarkedStatements(): Collection<KtExpression>
                 = statementMarks.keySet()
 
-        fun lastMarkedStatement(block: JetBlockExpression, minLevel: MarkLevel): JetExpression? {
+        fun lastMarkedStatement(block: KtBlockExpression, minLevel: MarkLevel): KtExpression? {
             val level = blockLevels[block] ?: MarkLevel.NONE
             if (level < minLevel) return null // optimization
             return block.getLastChild().siblings(forward = false)
-                    .filterIsInstance<JetExpression>()
+                    .filterIsInstance<KtExpression>()
                     .first { statementMark(it) >= minLevel }
         }
     }
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/util/TypeIndexUtil.kt b/idea/ide-common/src/org/jetbrains/kotlin/util/TypeIndexUtil.kt
index 2d675ad0dc5..a069fdf9a97 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/util/TypeIndexUtil.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/util/TypeIndexUtil.kt
@@ -21,17 +21,17 @@ import com.google.common.collect.Multimap
 import com.intellij.openapi.util.Key
 import com.intellij.psi.stubs.PsiFileStub
 import com.intellij.psi.stubs.StubElement
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetTypeReference
-import org.jetbrains.kotlin.psi.JetUserType
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtTypeReference
+import org.jetbrains.kotlin.psi.KtUserType
 
-public fun JetUserType.aliasImportMap(): Multimap<String, String> {
+public fun KtUserType.aliasImportMap(): Multimap<String, String> {
     // we need to access containing file via stub because getPsi() may return null when indexing and getContainingFile() will crash
     val file = getStub()?.getContainingFileStub()?.getPsi() ?: return HashMultimap.create()
-    return (file as JetFile).aliasImportMap()
+    return (file as KtFile).aliasImportMap()
 }
 
-private fun JetFile.aliasImportMap(): Multimap<String, String> {
+private fun KtFile.aliasImportMap(): Multimap<String, String> {
     val cached = getUserData(ALIAS_IMPORT_DATA_KEY)
     val modificationStamp = getModificationStamp()
     if (cached != null && modificationStamp == cached.fileModificationStamp) {
@@ -43,7 +43,7 @@ private fun JetFile.aliasImportMap(): Multimap<String, String> {
     return data.map
 }
 
-private fun JetFile.buildAliasImportMap(): Multimap<String, String> {
+private fun KtFile.buildAliasImportMap(): Multimap<String, String> {
     val map = HashMultimap.create<String, String>()
     val importList = getImportList() ?: return map
     for (import in importList.getImports()) {
@@ -58,12 +58,12 @@ private class CachedAliasImportData(val map: Multimap<String, String>, val fileM
 
 private val ALIAS_IMPORT_DATA_KEY = Key<CachedAliasImportData>("ALIAS_IMPORT_MAP_KEY")
 
-public fun JetTypeReference?.isProbablyNothing(): Boolean {
-    val userType = this?.typeElement as? JetUserType ?: return false
+public fun KtTypeReference?.isProbablyNothing(): Boolean {
+    val userType = this?.typeElement as? KtUserType ?: return false
     return userType.isProbablyNothing()
 }
 
-public fun JetUserType?.isProbablyNothing(): Boolean {
+public fun KtUserType?.isProbablyNothing(): Boolean {
     if (this == null) return false
     val referencedName = getReferencedName()
     return referencedName == "Nothing" || aliasImportMap()[referencedName].contains("Nothing")
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/util/descriptorUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/util/descriptorUtils.kt
index e64d0ab977e..19f5c76ac27 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/util/descriptorUtils.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/util/descriptorUtils.kt
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.resolve.OverridingUtil
 import org.jetbrains.kotlin.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.types.TypeConstructor
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure
 import org.jetbrains.kotlin.types.typeUtil.equalTypesOrNulls
 
@@ -32,7 +32,7 @@ public fun descriptorsEqualWithSubstitution(descriptor1: DeclarationDescriptor?,
     if (descriptor1 !is CallableDescriptor) return true
     descriptor2 as CallableDescriptor
 
-    val typeChecker = JetTypeChecker.withAxioms(object: JetTypeChecker.TypeConstructorEquality {
+    val typeChecker = KotlinTypeChecker.withAxioms(object: KotlinTypeChecker.TypeConstructorEquality {
         override fun equals(a: TypeConstructor, b: TypeConstructor): Boolean {
             val typeParam1 = a.getDeclarationDescriptor() as? TypeParameterDescriptor
             val typeParam2 = b.getDeclarationDescriptor() as? TypeParameterDescriptor
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/util/substitutionUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/util/substitutionUtils.kt
index ce6491da092..9357251fc77 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/util/substitutionUtils.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/util/substitutionUtils.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure
 import java.util.LinkedHashMap
 
-public fun getTypeSubstitution(baseType: JetType, derivedType: JetType): LinkedHashMap<TypeConstructor, TypeProjection>? {
+public fun getTypeSubstitution(baseType: KtType, derivedType: KtType): LinkedHashMap<TypeConstructor, TypeProjection>? {
     val substitutedType = TypeCheckingProcedure.findCorrespondingSupertype(derivedType, baseType) ?: return null
 
     val substitution = LinkedHashMap<TypeConstructor, TypeProjection>(substitutedType.getArguments().size())
@@ -55,6 +55,6 @@ public fun getCallableSubstitutor(
     return getCallableSubstitution(baseCallable, derivedCallable)?.let { TypeSubstitutor.create(it) }
 }
 
-public fun getTypeSubstitutor(baseType: JetType, derivedType: JetType): TypeSubstitutor? {
+public fun getTypeSubstitutor(baseType: KtType, derivedType: KtType): TypeSubstitutor? {
     return getTypeSubstitution(baseType, derivedType)?.let { TypeSubstitutor.create(it) }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetDescriptorIconProvider.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetDescriptorIconProvider.java
index febd7c7898f..badad4eac7a 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetDescriptorIconProvider.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetDescriptorIconProvider.java
@@ -25,7 +25,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor;
-import org.jetbrains.kotlin.psi.JetElement;
+import org.jetbrains.kotlin.psi.KtElement;
 
 import javax.swing.*;
 
@@ -38,7 +38,7 @@ public final class JetDescriptorIconProvider {
 
     @NotNull
     public static Icon getIcon(@NotNull DeclarationDescriptor descriptor, @Nullable PsiElement declaration, @Iconable.IconFlags int flags) {
-        if (declaration != null && !(declaration instanceof JetElement)) {
+        if (declaration != null && !(declaration instanceof KtElement)) {
             return declaration.getIcon(flags);
         }
 
@@ -84,7 +84,7 @@ public final class JetDescriptorIconProvider {
         if (descriptor instanceof FunctionDescriptor) {
             FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor;
             if (functionDescriptor.getExtensionReceiverParameter() != null) {
-                return JetIcons.EXTENSION_FUNCTION;
+                return KtIcons.EXTENSION_FUNCTION;
             }
 
             if (descriptor.getContainingDeclaration() instanceof ClassDescriptor) {
@@ -96,38 +96,38 @@ public final class JetDescriptorIconProvider {
                 }
             }
             else {
-                return JetIcons.FUNCTION;
+                return KtIcons.FUNCTION;
             }
         }
         if (descriptor instanceof ClassDescriptor) {
             switch (((ClassDescriptor) descriptor).getKind()) {
                 case INTERFACE:
-                    return JetIcons.TRAIT;
+                    return KtIcons.TRAIT;
                 case ENUM_CLASS:
-                    return JetIcons.ENUM;
+                    return KtIcons.ENUM;
                 case ENUM_ENTRY:
-                    return JetIcons.ENUM;
+                    return KtIcons.ENUM;
                 case ANNOTATION_CLASS:
                     return PlatformIcons.ANNOTATION_TYPE_ICON;
                 case OBJECT:
-                    return JetIcons.OBJECT;
+                    return KtIcons.OBJECT;
                 case CLASS:
-                    return JetIcons.CLASS;
+                    return KtIcons.CLASS;
                 default:
                     LOG.warn("No icon for descriptor: " + descriptor);
                     return null;
             }
         }
         if (descriptor instanceof ValueParameterDescriptor) {
-            return JetIcons.PARAMETER;
+            return KtIcons.PARAMETER;
         }
 
         if (descriptor instanceof LocalVariableDescriptor) {
-            return ((VariableDescriptor) descriptor).isVar() ? JetIcons.VAR : JetIcons.VAL;
+            return ((VariableDescriptor) descriptor).isVar() ? KtIcons.VAR : KtIcons.VAL;
         }
 
         if (descriptor instanceof PropertyDescriptor) {
-            return ((VariableDescriptor) descriptor).isVar() ? JetIcons.FIELD_VAR : JetIcons.FIELD_VAL;
+            return ((VariableDescriptor) descriptor).isVar() ? KtIcons.FIELD_VAR : KtIcons.FIELD_VAL;
         }
 
         if (descriptor instanceof TypeParameterDescriptor) {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetIconProvider.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetIconProvider.java
index 0c4b5f18265..8ca7782473c 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetIconProvider.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetIconProvider.java
@@ -31,7 +31,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.asJava.KotlinLightClassForExplicitDeclaration;
 import org.jetbrains.kotlin.asJava.KotlinLightClassForFacade;
 import org.jetbrains.kotlin.idea.caches.resolve.KotlinLightClassForDecompiledDeclaration;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 
 import javax.swing.*;
@@ -42,16 +42,16 @@ public class JetIconProvider extends IconProvider implements DumbAware {
     public static JetIconProvider INSTANCE = new JetIconProvider();
 
     @Nullable
-    public static JetClassOrObject getMainClass(@NotNull JetFile file) {
-        List<JetDeclaration> classes = ContainerUtil.filter(file.getDeclarations(), new Condition<JetDeclaration>() {
+    public static KtClassOrObject getMainClass(@NotNull KtFile file) {
+        List<KtDeclaration> classes = ContainerUtil.filter(file.getDeclarations(), new Condition<KtDeclaration>() {
             @Override
-            public boolean value(JetDeclaration jetDeclaration) {
-                return jetDeclaration instanceof JetClassOrObject;
+            public boolean value(KtDeclaration jetDeclaration) {
+                return jetDeclaration instanceof KtClassOrObject;
             }
         });
         if (classes.size() == 1) {
             if (StringUtil.getPackageName(file.getName()).equals(classes.get(0).getName())) {
-                return (JetClassOrObject) classes.get(0);
+                return (KtClassOrObject) classes.get(0);
             }
         }
         return null;
@@ -59,15 +59,15 @@ public class JetIconProvider extends IconProvider implements DumbAware {
 
     @Override
     public Icon getIcon(@NotNull PsiElement psiElement, int flags) {
-        if (psiElement instanceof JetFile) {
-            JetFile file = (JetFile) psiElement;
-            JetClassOrObject mainClass = getMainClass(file);
-            return mainClass != null && file.getDeclarations().size() == 1 ? getIcon(mainClass, flags) : JetIcons.FILE;
+        if (psiElement instanceof KtFile) {
+            KtFile file = (KtFile) psiElement;
+            KtClassOrObject mainClass = getMainClass(file);
+            return mainClass != null && file.getDeclarations().size() == 1 ? getIcon(mainClass, flags) : KtIcons.FILE;
         }
 
         Icon result = getBaseIcon(psiElement);
-        if ((flags & Iconable.ICON_FLAG_VISIBILITY) > 0 && psiElement instanceof JetModifierListOwner) {
-            JetModifierList list = ((JetModifierListOwner) psiElement).getModifierList();
+        if ((flags & Iconable.ICON_FLAG_VISIBILITY) > 0 && psiElement instanceof KtModifierListOwner) {
+            KtModifierList list = ((KtModifierListOwner) psiElement).getModifierList();
             result = createRowIcon(result, getVisibilityIcon(list));
         }
         return result;
@@ -80,15 +80,15 @@ public class JetIconProvider extends IconProvider implements DumbAware {
         return rowIcon;
     }
 
-    public static Icon getVisibilityIcon(@Nullable JetModifierList list) {
+    public static Icon getVisibilityIcon(@Nullable KtModifierList list) {
         if (list != null) {
-            if (list.hasModifier(JetTokens.PRIVATE_KEYWORD)) {
+            if (list.hasModifier(KtTokens.PRIVATE_KEYWORD)) {
                 return PlatformIcons.PRIVATE_ICON;
             }
-            if (list.hasModifier(JetTokens.PROTECTED_KEYWORD)) {
+            if (list.hasModifier(KtTokens.PROTECTED_KEYWORD)) {
                 return PlatformIcons.PROTECTED_ICON;
             }
-            if (list.hasModifier(JetTokens.INTERNAL_KEYWORD)) {
+            if (list.hasModifier(KtTokens.INTERNAL_KEYWORD)) {
                 return PlatformIcons.PACKAGE_LOCAL_ICON;
             }
         }
@@ -97,22 +97,22 @@ public class JetIconProvider extends IconProvider implements DumbAware {
     }
 
     public static Icon getBaseIcon(PsiElement psiElement) {
-        if (psiElement instanceof JetPackageDirective) {
+        if (psiElement instanceof KtPackageDirective) {
             return PlatformIcons.PACKAGE_ICON;
         }
 
         if (psiElement instanceof KotlinLightClassForFacade) {
-            return JetIcons.FILE;
+            return KtIcons.FILE;
         }
 
         if (psiElement instanceof KotlinLightClassForDecompiledDeclaration) {
-            JetClassOrObject origin = ((KotlinLightClassForDecompiledDeclaration) psiElement).getOrigin();
+            KtClassOrObject origin = ((KotlinLightClassForDecompiledDeclaration) psiElement).getOrigin();
             if (origin != null) {
                 psiElement = origin;
             }
             else {
                 //TODO (light classes for decompiled files): correct presentation
-                return JetIcons.CLASS;
+                return KtIcons.CLASS;
             }
         }
 
@@ -120,13 +120,13 @@ public class JetIconProvider extends IconProvider implements DumbAware {
             psiElement = psiElement.getNavigationElement();
         }
 
-        if (psiElement instanceof JetNamedFunction) {
-            if (((JetFunction) psiElement).getReceiverTypeReference() != null) {
-                return JetIcons.EXTENSION_FUNCTION;
+        if (psiElement instanceof KtNamedFunction) {
+            if (((KtFunction) psiElement).getReceiverTypeReference() != null) {
+                return KtIcons.EXTENSION_FUNCTION;
             }
 
-            if (PsiTreeUtil.getParentOfType(psiElement, JetNamedDeclaration.class) instanceof JetClass) {
-                if (JetPsiUtil.isAbstract((JetFunction) psiElement)) {
+            if (PsiTreeUtil.getParentOfType(psiElement, KtNamedDeclaration.class) instanceof KtClass) {
+                if (KtPsiUtil.isAbstract((KtFunction) psiElement)) {
                     return PlatformIcons.ABSTRACT_METHOD_ICON;
                 }
                 else {
@@ -134,41 +134,41 @@ public class JetIconProvider extends IconProvider implements DumbAware {
                 }
             }
             else {
-                return JetIcons.FUNCTION;
+                return KtIcons.FUNCTION;
             }
         }
 
-        if (psiElement instanceof JetFunctionLiteral) return JetIcons.LAMBDA;
+        if (psiElement instanceof KtFunctionLiteral) return KtIcons.LAMBDA;
 
-        if (psiElement instanceof JetClass) {
-            JetClass jetClass = (JetClass) psiElement;
-            if (jetClass.isInterface()) {
-                return JetIcons.TRAIT;
+        if (psiElement instanceof KtClass) {
+            KtClass ktClass = (KtClass) psiElement;
+            if (ktClass.isInterface()) {
+                return KtIcons.TRAIT;
             }
 
-            Icon icon = jetClass.isEnum() ? JetIcons.ENUM : JetIcons.CLASS;
-            if (jetClass instanceof JetEnumEntry) {
-                JetEnumEntry enumEntry = (JetEnumEntry) jetClass;
+            Icon icon = ktClass.isEnum() ? KtIcons.ENUM : KtIcons.CLASS;
+            if (ktClass instanceof KtEnumEntry) {
+                KtEnumEntry enumEntry = (KtEnumEntry) ktClass;
                 if (enumEntry.getPrimaryConstructorParameterList() == null) {
-                    icon = JetIcons.ENUM;
+                    icon = KtIcons.ENUM;
                 }
             }
             return icon;
         }
-        if (psiElement instanceof JetObjectDeclaration) {
-            return JetIcons.OBJECT;
+        if (psiElement instanceof KtObjectDeclaration) {
+            return KtIcons.OBJECT;
         }
-        if (psiElement instanceof JetParameter) {
-            JetParameter parameter = (JetParameter) psiElement;
-            if (JetPsiUtil.getClassIfParameterIsProperty(parameter) != null) {
-                return parameter.isMutable() ? JetIcons.FIELD_VAR : JetIcons.FIELD_VAL;
+        if (psiElement instanceof KtParameter) {
+            KtParameter parameter = (KtParameter) psiElement;
+            if (KtPsiUtil.getClassIfParameterIsProperty(parameter) != null) {
+                return parameter.isMutable() ? KtIcons.FIELD_VAR : KtIcons.FIELD_VAL;
             }
 
-            return JetIcons.PARAMETER;
+            return KtIcons.PARAMETER;
         }
-        if (psiElement instanceof JetProperty) {
-            JetProperty property = (JetProperty) psiElement;
-            return property.isVar() ? JetIcons.FIELD_VAR : JetIcons.FIELD_VAL;
+        if (psiElement instanceof KtProperty) {
+            KtProperty property = (KtProperty) psiElement;
+            return property.isVar() ? KtIcons.FIELD_VAR : KtIcons.FIELD_VAL;
         }
 
         return null;
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetIcons.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/KtIcons.java
similarity index 98%
rename from idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetIcons.java
rename to idea/idea-analysis/src/org/jetbrains/kotlin/idea/KtIcons.java
index 49d0151a479..6fc9253aa91 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetIcons.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/KtIcons.java
@@ -21,7 +21,7 @@ import com.intellij.util.PlatformIcons;
 
 import javax.swing.*;
 
-public interface JetIcons {
+public interface KtIcons {
     Icon SMALL_LOGO = IconLoader.getIcon("/org/jetbrains/kotlin/idea/icons/kotlin.png");
     Icon KOTLIN_LOGO_24 = IconLoader.getIcon("/org/jetbrains/kotlin/idea/icons/kotlin24.png");
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/analysis/AnalyzerUtil.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/analysis/AnalyzerUtil.kt
index 865de792a21..6728b3fdb9a 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/analysis/AnalyzerUtil.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/analysis/AnalyzerUtil.kt
@@ -18,26 +18,26 @@ package org.jetbrains.kotlin.idea.analysis
 
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.resolve.frontendService
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.utils.asLexicalScope
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
 import org.jetbrains.kotlin.types.expressions.JetTypeInfo
 import org.jetbrains.kotlin.types.expressions.PreliminaryDeclarationVisitor
 
 @JvmOverloads
-public fun JetExpression.computeTypeInfoInContext(
-        scope: JetScope,
-        contextExpression: JetExpression = this,
+public fun KtExpression.computeTypeInfoInContext(
+        scope: KtScope,
+        contextExpression: KtExpression = this,
         trace: BindingTrace = BindingTraceContext(),
         dataFlowInfo: DataFlowInfo = DataFlowInfo.EMPTY,
-        expectedType: JetType = TypeUtils.NO_EXPECTED_TYPE,
+        expectedType: KtType = TypeUtils.NO_EXPECTED_TYPE,
         isStatement: Boolean = false
 ): JetTypeInfo {
     PreliminaryDeclarationVisitor.createForExpression(this, trace)
@@ -46,12 +46,12 @@ public fun JetExpression.computeTypeInfoInContext(
 }
 
 @JvmOverloads
-public fun JetExpression.analyzeInContext(
-        scope: JetScope,
-        contextExpression: JetExpression = this,
+public fun KtExpression.analyzeInContext(
+        scope: KtScope,
+        contextExpression: KtExpression = this,
         trace: BindingTrace = BindingTraceContext(),
         dataFlowInfo: DataFlowInfo = DataFlowInfo.EMPTY,
-        expectedType: JetType = TypeUtils.NO_EXPECTED_TYPE,
+        expectedType: KtType = TypeUtils.NO_EXPECTED_TYPE,
         isStatement: Boolean = false
 ): BindingContext {
     computeTypeInfoInContext(scope, contextExpression, trace, dataFlowInfo, expectedType, isStatement)
@@ -59,12 +59,12 @@ public fun JetExpression.analyzeInContext(
 }
 
 @JvmOverloads
-public fun JetExpression.computeTypeInContext(
-        scope: JetScope,
-        contextExpression: JetExpression = this,
+public fun KtExpression.computeTypeInContext(
+        scope: KtScope,
+        contextExpression: KtExpression = this,
         trace: BindingTrace = BindingTraceContext(),
         dataFlowInfo: DataFlowInfo = DataFlowInfo.EMPTY,
-        expectedType: JetType = TypeUtils.NO_EXPECTED_TYPE
-): JetType? {
+        expectedType: KtType = TypeUtils.NO_EXPECTED_TYPE
+): KtType? {
     return computeTypeInfoInContext(scope, contextExpression, trace, dataFlowInfo, expectedType).type
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/CodeFragmentAnalyzer.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/CodeFragmentAnalyzer.kt
index dcb65af2572..fd939ca6482 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/CodeFragmentAnalyzer.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/CodeFragmentAnalyzer.kt
@@ -48,9 +48,9 @@ public class CodeFragmentAnalyzer(
     public var resolveElementCache: ResolveElementCache? = null
         @Inject set
 
-    public fun analyzeCodeFragment(codeFragment: JetCodeFragment, trace: BindingTrace, bodyResolveMode: BodyResolveMode) {
+    public fun analyzeCodeFragment(codeFragment: KtCodeFragment, trace: BindingTrace, bodyResolveMode: BodyResolveMode) {
         val codeFragmentExpression = codeFragment.getContentElement()
-        if (codeFragmentExpression !is JetExpression) return
+        if (codeFragmentExpression !is KtExpression) return
 
         val (scopeForContextElement, dataFlowInfo) = getScopeAndDataFlowForAnalyzeFragment(codeFragment) {
             resolveElementCache!!.resolveToElement(it, bodyResolveMode)
@@ -68,18 +68,18 @@ public class CodeFragmentAnalyzer(
     }
 
     //TODO: this code should be moved into debugger which should set correct context for its code fragment
-    private fun JetExpression.correctContextForExpression(): JetExpression {
+    private fun KtExpression.correctContextForExpression(): KtExpression {
         return when (this) {
-                   is JetProperty -> this.getDelegateExpressionOrInitializer()
-                   is JetFunctionLiteral -> this.getBodyExpression()?.getStatements()?.lastOrNull()
-                   is JetDeclarationWithBody -> this.getBodyExpression()
-                   is JetBlockExpression -> this.getStatements().lastOrNull()
+                   is KtProperty -> this.getDelegateExpressionOrInitializer()
+                   is KtFunctionLiteral -> this.getBodyExpression()?.getStatements()?.lastOrNull()
+                   is KtDeclarationWithBody -> this.getBodyExpression()
+                   is KtBlockExpression -> this.getStatements().lastOrNull()
                    else -> {
-                       val previousSibling = this.siblings(forward = false, withItself = false).firstIsInstanceOrNull<JetExpression>()
+                       val previousSibling = this.siblings(forward = false, withItself = false).firstIsInstanceOrNull<KtExpression>()
                        if (previousSibling != null) return previousSibling
                        for (parent in this.parents) {
-                           if (parent is JetWhenEntry || parent is JetIfExpression || parent is JetBlockExpression) return this
-                           if (parent is JetExpression) return parent
+                           if (parent is KtWhenEntry || parent is KtIfExpression || parent is KtBlockExpression) return this
+                           if (parent is KtExpression) return parent
                        }
                        null
                    }
@@ -87,23 +87,23 @@ public class CodeFragmentAnalyzer(
     }
 
     private fun getScopeAndDataFlowForAnalyzeFragment(
-            codeFragment: JetCodeFragment,
-            resolveToElement: (JetElement) -> BindingContext
+            codeFragment: KtCodeFragment,
+            resolveToElement: (KtElement) -> BindingContext
     ): Pair<LexicalScope, DataFlowInfo>? {
         val context = codeFragment.getContext()
-        if (context !is JetExpression) return null
+        if (context !is KtExpression) return null
 
         val scopeForContextElement: LexicalScope?
         val dataFlowInfo: DataFlowInfo
 
         when (context) {
-            is JetPrimaryConstructor -> {
+            is KtPrimaryConstructor -> {
                 val descriptor = resolveSession.getClassDescriptor(context.getContainingClassOrObject(), NoLookupLocation.FROM_IDE) as ClassDescriptorWithResolutionScopes
 
                 scopeForContextElement = descriptor.getScopeForInitializerResolution()
                 dataFlowInfo = DataFlowInfo.EMPTY
             }
-            is JetSecondaryConstructor -> {
+            is KtSecondaryConstructor -> {
                 val correctedContext = context.getDelegationCall().calleeExpression!!
 
                 val contextForElement = resolveToElement(correctedContext)
@@ -111,13 +111,13 @@ public class CodeFragmentAnalyzer(
                 scopeForContextElement = contextForElement[BindingContext.LEXICAL_SCOPE, correctedContext]
                 dataFlowInfo = DataFlowInfo.EMPTY
             }
-            is JetClassOrObject -> {
+            is KtClassOrObject -> {
                 val descriptor = resolveSession.getClassDescriptor(context, NoLookupLocation.FROM_IDE) as ClassDescriptorWithResolutionScopes
 
                 scopeForContextElement = descriptor.getScopeForMemberDeclarationResolution()
                 dataFlowInfo = DataFlowInfo.EMPTY
             }
-            is JetExpression -> {
+            is KtExpression -> {
                 val correctedContext = context.correctContextForExpression()
 
                 val contextForElement = resolveToElement(correctedContext)
@@ -125,7 +125,7 @@ public class CodeFragmentAnalyzer(
                 scopeForContextElement = contextForElement[BindingContext.LEXICAL_SCOPE, correctedContext]
                 dataFlowInfo = contextForElement.getDataFlowInfo(correctedContext)
             }
-            is JetFile -> {
+            is KtFile -> {
                 scopeForContextElement = resolveSession.getFileScopeProvider().getFileScope(context)
                 dataFlowInfo = DataFlowInfo.EMPTY
             }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.kt
index da0f108977d..c8203faf740 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.kt
@@ -47,7 +47,7 @@ import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
 import org.jetbrains.kotlin.resolve.lazy.NoDescriptorForDeclarationException
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.utils.sure
 import java.util.*
 
@@ -55,13 +55,13 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
     private val scopeFileComparator = JavaElementFinder.byClasspathComparator(GlobalSearchScope.allScope(project))
     private val psiManager: PsiManager = PsiManager.getInstance(project)
 
-    override fun getContextForPackage(files: Collection<JetFile>): LightClassConstructionContext {
+    override fun getContextForPackage(files: Collection<KtFile>): LightClassConstructionContext {
         assert(!files.isEmpty()) { "No files in package" }
 
         return getContextForFiles(files)
     }
 
-    private fun getContextForFiles(files: Collection<JetFile>): LightClassConstructionContext {
+    private fun getContextForFiles(files: Collection<KtFile>): LightClassConstructionContext {
         val sortedFiles = files.sortedWith(scopeFileComparator)
         val file = sortedFiles.first()
         val resolveSession = file.getResolutionFacade().getFrontendService(ResolveSession::class.java)
@@ -69,7 +69,7 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
         return LightClassConstructionContext(resolveSession.bindingContext, resolveSession.getModuleDescriptor())
     }
 
-    override fun getContextForClassOrObject(classOrObject: JetClassOrObject): LightClassConstructionContext {
+    override fun getContextForClassOrObject(classOrObject: KtClassOrObject): LightClassConstructionContext {
         val resolutionFacade = classOrObject.getResolutionFacade()
 
         val moduleDescriptor = resolutionFacade.moduleDescriptor
@@ -92,24 +92,24 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
         return LightClassConstructionContext(bindingContext, moduleDescriptor)
     }
 
-    override fun getContextForFacade(files: Collection<JetFile>): LightClassConstructionContext {
+    override fun getContextForFacade(files: Collection<KtFile>): LightClassConstructionContext {
         assert(!files.isEmpty()) { "No files in facade" }
 
         return getContextForFiles(files)
     }
 
-    override fun findClassOrObjectDeclarations(fqName: FqName, searchScope: GlobalSearchScope): Collection<JetClassOrObject> {
+    override fun findClassOrObjectDeclarations(fqName: FqName, searchScope: GlobalSearchScope): Collection<KtClassOrObject> {
         return JetFullClassNameIndex.getInstance().get(fqName.asString(), project, kotlinSourceAndClassFiles(searchScope, project))
     }
 
-    override fun findFilesForPackage(fqName: FqName, searchScope: GlobalSearchScope): Collection<JetFile> {
+    override fun findFilesForPackage(fqName: FqName, searchScope: GlobalSearchScope): Collection<KtFile> {
         return PackageIndexUtil.findFilesWithExactPackage(fqName, kotlinSourceAndClassFiles(searchScope, project), project)
     }
 
     override fun findClassOrObjectDeclarationsInPackage(
             packageFqName: FqName,
             searchScope: GlobalSearchScope
-    ): Collection<JetClassOrObject> {
+    ): Collection<KtClassOrObject> {
         return JetTopLevelClassByPackageIndex.getInstance().get(
                 packageFqName.asString(), project, kotlinSourceAndClassFiles(searchScope, project))
     }
@@ -119,10 +119,10 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
     }
 
     override fun getSubPackages(fqn: FqName, scope: GlobalSearchScope): Collection<FqName> {
-        return PackageIndexUtil.getSubPackageFqNames(fqn, kotlinSourceAndClassFiles(scope, project), project, JetScope.ALL_NAME_FILTER)
+        return PackageIndexUtil.getSubPackageFqNames(fqn, kotlinSourceAndClassFiles(scope, project), project, KtScope.ALL_NAME_FILTER)
     }
 
-    override fun getPsiClass(classOrObject: JetClassOrObject): PsiClass? {
+    override fun getPsiClass(classOrObject: KtClassOrObject): PsiClass? {
         val virtualFile = classOrObject.containingFile.virtualFile
         if (virtualFile != null && LibraryUtil.findLibraryEntry(virtualFile, classOrObject.project) != null) {
             if (ProjectRootsUtil.isLibraryClassFile(project, virtualFile)) {
@@ -135,7 +135,7 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
 
     private fun withFakeLightClasses(
             lightClassForFacade: KotlinLightClassForFacade?,
-            facadeFiles: List<JetFile>
+            facadeFiles: List<KtFile>
     ): List<PsiClass> {
         if (lightClassForFacade == null) return emptyList()
 
@@ -161,7 +161,7 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
 
     public fun createLightClassForFileFacade(
             facadeFqName: FqName,
-            facadeFiles: List<JetFile>,
+            facadeFiles: List<KtFile>,
             moduleInfo: IdeaModuleInfo
     ): List<PsiClass> {
         if (moduleInfo is ModuleSourceInfo) {
@@ -174,11 +174,11 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
         }
     }
 
-    override fun findFilesForFacade(facadeFqName: FqName, scope: GlobalSearchScope): Collection<JetFile> {
+    override fun findFilesForFacade(facadeFqName: FqName, scope: GlobalSearchScope): Collection<KtFile> {
         return JetFileFacadeFqNameIndex.INSTANCE.get(facadeFqName.asString(), project, scope)
     }
 
-    override fun resolveClassToDescriptor(classOrObject: JetClassOrObject): ClassDescriptor? {
+    override fun resolveClassToDescriptor(classOrObject: KtClassOrObject): ClassDescriptor? {
         try {
             return classOrObject.resolveToDescriptor() as ClassDescriptor
         }
@@ -206,7 +206,7 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
     }
 
 
-    private fun forceResolvePackageDeclarations(files: Collection<JetFile>, session: ResolveSession) {
+    private fun forceResolvePackageDeclarations(files: Collection<KtFile>, session: ResolveSession) {
         for (file in files) {
             // SCRIPT: not supported
             if (file.isScript) continue
@@ -222,21 +222,21 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
             }
 
             for (declaration in file.declarations) {
-                if (declaration is JetFunction) {
+                if (declaration is KtFunction) {
                     val name = declaration.nameAsSafeName
                     val functions = packageDescriptor.memberScope.getFunctions(name, NoLookupLocation.FROM_IDE)
                     for (descriptor in functions) {
                         ForceResolveUtil.forceResolveAllContents(descriptor)
                     }
                 }
-                else if (declaration is JetProperty) {
+                else if (declaration is KtProperty) {
                     val name = declaration.nameAsSafeName
                     val properties = packageDescriptor.memberScope.getProperties(name, NoLookupLocation.FROM_IDE)
                     for (descriptor in properties) {
                         ForceResolveUtil.forceResolveAllContents(descriptor)
                     }
                 }
-                else if (declaration is JetClassOrObject) {
+                else if (declaration is KtClassOrObject) {
                     // Do nothing: we are not interested in classes
                 }
                 else {
@@ -248,8 +248,8 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
         }
     }
 
-    private fun getLightClassForDecompiledClassOrObject(decompiledClassOrObject: JetClassOrObject): PsiClass? {
-        if (decompiledClassOrObject is JetEnumEntry) {
+    private fun getLightClassForDecompiledClassOrObject(decompiledClassOrObject: KtClassOrObject): PsiClass? {
+        if (decompiledClassOrObject is KtEnumEntry) {
             return null
         }
         val containingJetFile = decompiledClassOrObject.getContainingJetFile()
@@ -262,7 +262,7 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
     }
 
     private fun findCorrespondingLightClass(
-            decompiledClassOrObject: JetClassOrObject,
+            decompiledClassOrObject: KtClassOrObject,
             rootLightClassForDecompiledFile: PsiClass): PsiClass {
         val relativeFqName = getClassRelativeName(decompiledClassOrObject)
         val iterator = relativeFqName.pathSegments().iterator()
@@ -279,9 +279,9 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
         return current
     }
 
-    private fun getClassRelativeName(decompiledClassOrObject: JetClassOrObject): FqName {
+    private fun getClassRelativeName(decompiledClassOrObject: KtClassOrObject): FqName {
         val name = decompiledClassOrObject.nameAsName!!
-        val parent = PsiTreeUtil.getParentOfType(decompiledClassOrObject, JetClassOrObject::class.java, true)
+        val parent = PsiTreeUtil.getParentOfType(decompiledClassOrObject, KtClassOrObject::class.java, true)
         if (parent == null) {
             assert(decompiledClassOrObject.isTopLevel())
             return FqName.topLevel(name)
@@ -289,10 +289,10 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
         return getClassRelativeName(parent).child(name)
     }
 
-    private fun createLightClassForDecompiledKotlinFile(file: JetFile): KotlinLightClassForDecompiledDeclaration? {
+    private fun createLightClassForDecompiledKotlinFile(file: KtFile): KotlinLightClassForDecompiledDeclaration? {
         val virtualFile = file.virtualFile ?: return null
 
-        val classOrObject = file.declarations.filterIsInstance<JetClassOrObject>().singleOrNull()
+        val classOrObject = file.declarations.filterIsInstance<KtClassOrObject>().singleOrNull()
 
         val javaClsClass = createClsJavaClassFromVirtualFile(
                 file, virtualFile,
@@ -303,9 +303,9 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
     }
 
     private fun createClsJavaClassFromVirtualFile(
-            mirrorFile: JetFile,
+            mirrorFile: KtFile,
             classFile: VirtualFile,
-            correspondingClassOrObject: JetClassOrObject?
+            correspondingClassOrObject: KtClassOrObject?
     ): ClsClassImpl? {
         val javaFileStub = ClsJavaStubByVirtualFileCache.getInstance(project).get(classFile) ?: return null
         val manager = PsiManager.getInstance(mirrorFile.project)
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt
index 2777162c0d7..824e5678808 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.load.java.structure.impl.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 
 private fun PsiElement.getJavaDescriptorResolver(): JavaDescriptorResolver? {
     if (!ProjectRootsUtil.isInProjectOrLibraryClassFile(this)) return null
@@ -78,7 +78,7 @@ public fun JavaDescriptorResolver.resolveField(field: JavaField): PropertyDescri
     return getContainingScope(field)?.getProperties(field.name, NoLookupLocation.FROM_IDE)?.findByJavaElement(field) as? PropertyDescriptor
 }
 
-private fun JavaDescriptorResolver.getContainingScope(member: JavaMember): JetScope? {
+private fun JavaDescriptorResolver.getContainingScope(member: JavaMember): KtScope? {
     val containingClass = resolveClass(member.getContainingClass())
     return if (member.isStatic())
         containingClass?.getStaticScope()
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt
index e980bd40aee..fb184ae0dd8 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt
@@ -31,9 +31,9 @@ import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.js.resolve.JsPlatform
-import org.jetbrains.kotlin.psi.JetCodeFragment
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtCodeFragment
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.utils.keysToMap
@@ -46,7 +46,7 @@ public class KotlinCacheService(val project: Project) {
         public fun getInstance(project: Project): KotlinCacheService = ServiceManager.getService(project, javaClass<KotlinCacheService>())!!
     }
 
-    public fun getResolutionFacade(elements: List<JetElement>): ResolutionFacade {
+    public fun getResolutionFacade(elements: List<KtElement>): ResolutionFacade {
         return getFacadeToAnalyzeFiles(elements.map { it.getContainingJetFile() })
     }
 
@@ -87,7 +87,7 @@ public class KotlinCacheService(val project: Project) {
 
     private fun librariesFacade(platform: TargetPlatform) = globalFacadesPerPlatform[platform]!!.facadeForLibraries
 
-    private fun createFacadeForSyntheticFiles(files: Set<JetFile>): ProjectResolutionFacade {
+    private fun createFacadeForSyntheticFiles(files: Set<KtFile>): ProjectResolutionFacade {
         // we assume that all files come from the same module
         val targetPlatform = files.map { TargetPlatformDetector.getPlatform(it) }.toSet().single()
         val syntheticFileModule = files.map { it.getModuleInfo() }.toSet().single()
@@ -150,14 +150,14 @@ public class KotlinCacheService(val project: Project) {
     private val syntheticFileCachesLock = Any()
 
     private val slruCacheProvider = CachedValueProvider {
-        CachedValueProvider.Result(object : SLRUCache<Set<JetFile>, ProjectResolutionFacade>(2, 3) {
-            override fun createValue(files: Set<JetFile>): ProjectResolutionFacade {
+        CachedValueProvider.Result(object : SLRUCache<Set<KtFile>, ProjectResolutionFacade>(2, 3) {
+            override fun createValue(files: Set<KtFile>): ProjectResolutionFacade {
                 return createFacadeForSyntheticFiles(files)
             }
         }, LibraryModificationTracker.getInstance(project), ProjectRootModificationTracker.getInstance(project))
     }
 
-    private fun getFacadeForSyntheticFiles(files: Set<JetFile>): ProjectResolutionFacade {
+    private fun getFacadeForSyntheticFiles(files: Set<KtFile>): ProjectResolutionFacade {
         return synchronized(syntheticFileCachesLock) {
             //NOTE: computations inside createCacheForSyntheticFiles depend on project root structure
             // so we additionally drop the whole slru cache on change
@@ -165,7 +165,7 @@ public class KotlinCacheService(val project: Project) {
         }
     }
 
-    private fun getFacadeToAnalyzeFiles(files: Collection<JetFile>): ResolutionFacade {
+    private fun getFacadeToAnalyzeFiles(files: Collection<KtFile>): ResolutionFacade {
         val syntheticFiles = findSyntheticFiles(files)
         val file = files.first()
         val projectFacade = if (syntheticFiles.isNotEmpty()) {
@@ -177,17 +177,17 @@ public class KotlinCacheService(val project: Project) {
         return ResolutionFacadeImpl(projectFacade, file.getModuleInfo())
     }
 
-    private fun findSyntheticFiles(files: Collection<JetFile>) = files.map {
-        if (it is JetCodeFragment) it.getContextFile() else it
+    private fun findSyntheticFiles(files: Collection<KtFile>) = files.map {
+        if (it is KtCodeFragment) it.getContextFile() else it
     }.filterNotNull().filter {
         !ProjectRootsUtil.isInProjectSource(it)
     }.toSet()
 
-    private fun JetCodeFragment.getContextFile(): JetFile? {
+    private fun KtCodeFragment.getContextFile(): KtFile? {
         val contextElement = getContext() ?: return null
-        val contextFile = (contextElement as? JetElement)?.getContainingJetFile()
+        val contextFile = (contextElement as? KtElement)?.getContainingJetFile()
                           ?: throw AssertionError("Analyzing kotlin code fragment of type $javaClass with java context of type ${contextElement.javaClass}")
-        return if (contextFile is JetCodeFragment) contextFile.getContextFile() else contextFile
+        return if (contextFile is KtCodeFragment) contextFile.getContextFile() else contextFile
     }
 }
 
@@ -198,7 +198,7 @@ private fun globalResolveSessionProvider(
         dependencies: Collection<Any>,
         moduleFilter: (IdeaModuleInfo) -> Boolean,
         reuseDataFrom: ProjectResolutionFacade? = null,
-        syntheticFiles: Collection<JetFile> = listOf(),
+        syntheticFiles: Collection<KtFile> = listOf(),
         logProcessCanceled: Boolean = false
 ): CachedValueProvider.Result<ModuleResolverProvider> {
     val delegateResolverProvider = reuseDataFrom?.moduleResolverProvider
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinLightClassForDecompiledDeclaration.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinLightClassForDecompiledDeclaration.kt
index c29d189ce6a..89c58dbc90d 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinLightClassForDecompiledDeclaration.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinLightClassForDecompiledDeclaration.kt
@@ -20,18 +20,18 @@ import com.intellij.psi.PsiClass
 import com.intellij.psi.impl.compiled.ClsClassImpl
 import org.jetbrains.kotlin.asJava.KotlinWrappingLightClass
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 
 class KotlinLightClassForDecompiledDeclaration(
         private val clsClass: ClsClassImpl,
-        private val origin: JetClassOrObject?
+        private val origin: KtClassOrObject?
 ) : KotlinWrappingLightClass(clsClass.getManager()) {
     private val fqName = origin?.getFqName() ?: FqName(clsClass.getQualifiedName())
 
     override fun copy() = this
 
     override fun getOwnInnerClasses(): List<PsiClass> {
-        val nestedClasses = origin?.getDeclarations()?.filterIsInstance<JetClassOrObject>() ?: emptyList()
+        val nestedClasses = origin?.getDeclarations()?.filterIsInstance<KtClassOrObject>() ?: emptyList()
         return clsClass.getOwnInnerClasses().map { innerClsClass ->
             KotlinLightClassForDecompiledDeclaration(innerClsClass as ClsClassImpl,
                                                      nestedClasses.firstOrNull { innerClsClass.getName() == it.getName() })
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt
index fcd68adb740..b6209608bb0 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt
@@ -40,10 +40,10 @@ import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import java.util.*
 
-internal class PerFileAnalysisCache(val file: JetFile, val componentProvider: ComponentProvider) {
+internal class PerFileAnalysisCache(val file: KtFile, val componentProvider: ComponentProvider) {
     private val cache = HashMap<PsiElement, AnalysisResult>()
 
-    private fun lookUp(analyzableElement: JetElement): AnalysisResult? {
+    private fun lookUp(analyzableElement: KtElement): AnalysisResult? {
         // Looking for parent elements that are already analyzed
         // Also removing all elements whose parents are already analyzed, to guarantee consistency
         val descendantsOfCurrent = arrayListOf<PsiElement>()
@@ -66,7 +66,7 @@ internal class PerFileAnalysisCache(val file: JetFile, val componentProvider: Co
         return result
     }
 
-    fun getAnalysisResults(element: JetElement): AnalysisResult {
+    fun getAnalysisResults(element: KtElement): AnalysisResult {
         assert (element.getContainingJetFile() == file) { "Wrong file. Expected $file, but was ${element.getContainingJetFile()}" }
 
         val analyzableParent = KotlinResolveDataProvider.findAnalyzableParent(element)
@@ -84,7 +84,7 @@ internal class PerFileAnalysisCache(val file: JetFile, val componentProvider: Co
         }
     }
 
-    private fun analyze(analyzableElement: JetElement): AnalysisResult {
+    private fun analyze(analyzableElement: KtElement): AnalysisResult {
         val project = analyzableElement.getProject()
         if (DumbService.isDumb(project)) {
             return AnalysisResult.EMPTY
@@ -110,45 +110,45 @@ internal class PerFileAnalysisCache(val file: JetFile, val componentProvider: Co
 
 private object KotlinResolveDataProvider {
     private val topmostElementTypes = arrayOf<Class<out PsiElement?>?>(
-            javaClass<JetNamedFunction>(),
-            javaClass<JetClassInitializer>(),
-            javaClass<JetProperty>(),
-            javaClass<JetImportDirective>(),
-            javaClass<JetPackageDirective>(),
-            javaClass<JetCodeFragment>(),
+            javaClass<KtNamedFunction>(),
+            javaClass<KtClassInitializer>(),
+            javaClass<KtProperty>(),
+            javaClass<KtImportDirective>(),
+            javaClass<KtPackageDirective>(),
+            javaClass<KtCodeFragment>(),
             // TODO: Non-analyzable so far, add more granular analysis
-            javaClass<JetAnnotationEntry>(),
-            javaClass<JetTypeConstraint>(),
-            javaClass<JetDelegationSpecifierList>(),
-            javaClass<JetTypeParameter>(),
-            javaClass<JetParameter>()
+            javaClass<KtAnnotationEntry>(),
+            javaClass<KtTypeConstraint>(),
+            javaClass<KtDelegationSpecifierList>(),
+            javaClass<KtTypeParameter>(),
+            javaClass<KtParameter>()
     )
 
-    fun findAnalyzableParent(element: JetElement): JetElement {
-        if (element is JetFile) return element
+    fun findAnalyzableParent(element: KtElement): KtElement {
+        if (element is KtFile) return element
 
-        val topmostElement = JetPsiUtil.getTopmostParentOfTypes(element, *topmostElementTypes) as JetElement?
+        val topmostElement = KtPsiUtil.getTopmostParentOfTypes(element, *topmostElementTypes) as KtElement?
         // parameters and supertype lists are not analyzable by themselves, but if we don't count them as topmost, we'll stop inside, say,
         // object expressions inside arguments of super constructors of classes (note that classes themselves are not topmost elements)
         val analyzableElement = when (topmostElement) {
-            is JetAnnotationEntry,
-            is JetTypeConstraint,
-            is JetDelegationSpecifierList,
-            is JetTypeParameter,
-            is JetParameter -> PsiTreeUtil.getParentOfType(topmostElement, javaClass<JetClassOrObject>(), javaClass<JetCallableDeclaration>())
+            is KtAnnotationEntry,
+            is KtTypeConstraint,
+            is KtDelegationSpecifierList,
+            is KtTypeParameter,
+            is KtParameter -> PsiTreeUtil.getParentOfType(topmostElement, javaClass<KtClassOrObject>(), javaClass<KtCallableDeclaration>())
             else -> topmostElement
         }
         return analyzableElement
                     // if none of the above worked, take the outermost declaration
-                    ?: PsiTreeUtil.getTopmostParentOfType(element, javaClass<JetDeclaration>())
+                    ?: PsiTreeUtil.getTopmostParentOfType(element, javaClass<KtDeclaration>())
                     // if even that didn't work, take the whole file
                     ?: element.getContainingJetFile()
     }
 
-    fun analyze(project: Project, componentProvider: ComponentProvider, analyzableElement: JetElement): AnalysisResult {
+    fun analyze(project: Project, componentProvider: ComponentProvider, analyzableElement: KtElement): AnalysisResult {
         try {
             val module = componentProvider.get<ModuleDescriptor>()
-            if (analyzableElement is JetCodeFragment) {
+            if (analyzableElement is KtCodeFragment) {
                 return AnalysisResult.success(analyzeExpressionCodeFragment(componentProvider, analyzableElement), module)
             }
 
@@ -195,7 +195,7 @@ private object KotlinResolveDataProvider {
         }
     }
 
-    private fun analyzeExpressionCodeFragment(componentProvider: ComponentProvider, codeFragment: JetCodeFragment): BindingContext {
+    private fun analyzeExpressionCodeFragment(componentProvider: ComponentProvider, codeFragment: KtCodeFragment): BindingContext {
         val trace = BindingTraceContext()
         componentProvider.get<CodeFragmentAnalyzer>().analyzeCodeFragment(
                 codeFragment,
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt
index f624b0de326..5c21e4f15c5 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.idea.project.IdeaEnvironment
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
 import org.jetbrains.kotlin.storage.ExceptionTracker
 
@@ -38,7 +38,7 @@ fun createModuleResolverProvider(
         project: Project,
         globalContext: GlobalContextImpl,
         analyzerFacade: AnalyzerFacade<JvmPlatformParameters>,
-        syntheticFiles: Collection<JetFile>,
+        syntheticFiles: Collection<KtFile>,
         delegateResolver: ResolverForProject<IdeaModuleInfo>,
         moduleFilter: (IdeaModuleInfo) -> Boolean
 ): ModuleResolverProvider {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ProjectResolutionFacade.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ProjectResolutionFacade.kt
index 65d5c240846..140b25361a5 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ProjectResolutionFacade.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ProjectResolutionFacade.kt
@@ -29,9 +29,9 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.idea.project.ResolveElementCache
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.CompositeBindingContext
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
@@ -56,15 +56,15 @@ internal class ProjectResolutionFacade(
     private val analysisResults = CachedValuesManager.getManager(project).createCachedValue(
             {
                 val resolverProvider = moduleResolverProvider
-                val results = object : SLRUCache<JetFile, PerFileAnalysisCache>(2, 3) {
-                    override fun createValue(file: JetFile?): PerFileAnalysisCache {
+                val results = object : SLRUCache<KtFile, PerFileAnalysisCache>(2, 3) {
+                    override fun createValue(file: KtFile?): PerFileAnalysisCache {
                         return PerFileAnalysisCache(file!!, resolverProvider.resolverForProject.resolverForModule(file.getModuleInfo()).componentProvider)
                     }
                 }
                 CachedValueProvider.Result(results, PsiModificationTracker.MODIFICATION_COUNT, resolverProvider.exceptionTracker)
             }, false)
 
-    fun getAnalysisResultsForElements(elements: Collection<JetElement>): AnalysisResult {
+    fun getAnalysisResultsForElements(elements: Collection<KtElement>): AnalysisResult {
         assert(elements.isNotEmpty()) { "elements collection should not be empty" }
         val slruCache = synchronized(analysisResults) {
             analysisResults.getValue()!!
@@ -97,15 +97,15 @@ internal class ResolutionFacadeImpl(
     override val moduleDescriptor: ModuleDescriptor
         get() = projectFacade.findModuleDescriptor(moduleInfo)
 
-    override fun analyze(element: JetElement, bodyResolveMode: BodyResolveMode): BindingContext {
+    override fun analyze(element: KtElement, bodyResolveMode: BodyResolveMode): BindingContext {
         val resolveElementCache = getFrontendService(element, javaClass<ResolveElementCache>())
         return resolveElementCache.resolveToElement(element, bodyResolveMode)
     }
 
-    override fun analyzeFullyAndGetResult(elements: Collection<JetElement>): AnalysisResult
+    override fun analyzeFullyAndGetResult(elements: Collection<KtElement>): AnalysisResult
             = projectFacade.getAnalysisResultsForElements(elements)
 
-    override fun resolveToDescriptor(declaration: JetDeclaration): DeclarationDescriptor {
+    override fun resolveToDescriptor(declaration: KtDeclaration): DeclarationDescriptor {
         val resolveSession = projectFacade.resolverForModuleInfo(declaration.getModuleInfo()).componentProvider.get<ResolveSession>()
         return resolveSession.resolveToDescriptor(declaration)
     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/getModuleInfo.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/getModuleInfo.kt
index 9a82f1244c1..914161d69aa 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/getModuleInfo.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/getModuleInfo.kt
@@ -37,7 +37,7 @@ fun PsiElement.getModuleInfo(): IdeaModuleInfo {
 
     if (this is KotlinLightElement<*, *>) return this.getModuleInfoForLightElement()
 
-    val containingJetFile = (this as? JetElement)?.getContainingFile() as? JetFile
+    val containingJetFile = (this as? KtElement)?.getContainingFile() as? KtFile
     val context = containingJetFile?.analysisContext
     if (context != null) return context.getModuleInfo()
 
@@ -48,10 +48,10 @@ fun PsiElement.getModuleInfo(): IdeaModuleInfo {
         )
     }
 
-    val explicitModuleInfo = containingJetFile?.moduleInfo ?: (containingJetFile?.originalFile as? JetFile)?.moduleInfo
+    val explicitModuleInfo = containingJetFile?.moduleInfo ?: (containingJetFile?.originalFile as? KtFile)?.moduleInfo
     if (explicitModuleInfo is IdeaModuleInfo) return explicitModuleInfo
 
-    if (containingJetFile is JetCodeFragment) {
+    if (containingJetFile is KtCodeFragment) {
         return containingJetFile.getContext()?.getModuleInfo()
                ?: logAndReturnDefault("Analyzing code fragment of type ${containingJetFile.javaClass} with no context element\nText:\n${containingJetFile.getText()}")
     }
@@ -66,7 +66,7 @@ fun PsiElement.getModuleInfo(): IdeaModuleInfo {
     return getModuleInfoByVirtualFile(
             project,
             virtualFile,
-            isDecompiledFile = (containingFile as? JetFile)?.isCompiled() ?: false
+            isDecompiledFile = (containingFile as? KtFile)?.isCompiled() ?: false
     )
 }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/resolutionApi.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/resolutionApi.kt
index cbe3c25a7a9..c0a5e180f63 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/resolutionApi.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/resolutionApi.kt
@@ -25,10 +25,10 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.resolve.frontendService
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.ImportPath
@@ -37,19 +37,19 @@ import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider
 import org.jetbrains.kotlin.resolve.lazy.LazyFileScope
 
-public fun JetElement.getResolutionFacade(): ResolutionFacade {
+public fun KtElement.getResolutionFacade(): ResolutionFacade {
     return KotlinCacheService.getInstance(getProject()).getResolutionFacade(listOf(this))
 }
 
-public fun JetDeclaration.resolveToDescriptor(): DeclarationDescriptor {
+public fun KtDeclaration.resolveToDescriptor(): DeclarationDescriptor {
     return getResolutionFacade().resolveToDescriptor(this)
 }
 
-public fun JetDeclaration.resolveToDescriptorIfAny(): DeclarationDescriptor? {
+public fun KtDeclaration.resolveToDescriptorIfAny(): DeclarationDescriptor? {
     return analyze(BodyResolveMode.PARTIAL).get(BindingContext.DECLARATION_TO_DESCRIPTOR, this)
 }
 
-public fun JetFile.resolveImportReference(fqName: FqName): Collection<DeclarationDescriptor> {
+public fun KtFile.resolveImportReference(fqName: FqName): Collection<DeclarationDescriptor> {
     val facade = getResolutionFacade()
     return facade.resolveImportReference(facade.moduleDescriptor, fqName)
 }
@@ -60,24 +60,24 @@ public fun JetFile.resolveImportReference(fqName: FqName): Collection<Declaratio
 // analyzeFully - see KotlinResolveCache, KotlinResolveDataProvider
 // In the future these two approaches should be unified
 @JvmOverloads
-public fun JetElement.analyze(bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL): BindingContext {
+public fun KtElement.analyze(bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL): BindingContext {
     return getResolutionFacade().analyze(this, bodyResolveMode)
 }
 
-public fun JetElement.analyzeAndGetResult(): AnalysisResult {
+public fun KtElement.analyzeAndGetResult(): AnalysisResult {
     val resolutionFacade = getResolutionFacade()
     return AnalysisResult.success(resolutionFacade.analyze(this), resolutionFacade.moduleDescriptor)
 }
 
-public fun JetElement.findModuleDescriptor(): ModuleDescriptor {
+public fun KtElement.findModuleDescriptor(): ModuleDescriptor {
     return getResolutionFacade().moduleDescriptor
 }
 
-public fun JetElement.analyzeFully(): BindingContext {
+public fun KtElement.analyzeFully(): BindingContext {
     return analyzeFullyAndGetResult().bindingContext
 }
 
-public fun JetElement.analyzeFullyAndGetResult(vararg extraFiles: JetFile): AnalysisResult {
+public fun KtElement.analyzeFullyAndGetResult(vararg extraFiles: KtFile): AnalysisResult {
     return KotlinCacheService.getInstance(getProject()).getResolutionFacade(listOf(this) + extraFiles.toList()).analyzeFullyAndGetResult(listOf(this))
 }
 
@@ -86,7 +86,7 @@ public fun ResolutionFacade.resolveImportReference(
         moduleDescriptor: ModuleDescriptor,
         fqName: FqName
 ): Collection<DeclarationDescriptor> {
-    val importDirective = JetPsiFactory(project).createImportDirective(ImportPath(fqName, false))
+    val importDirective = KtPsiFactory(project).createImportDirective(ImportPath(fqName, false))
     val qualifiedExpressionResolver = this.getFrontendService(moduleDescriptor, QualifiedExpressionResolver::class.java)
     return qualifiedExpressionResolver.processImportReference(
             importDirective, moduleDescriptor, BindingTraceContext(), packageFragmentForVisibilityCheck = null)?.getAllDescriptors() ?: emptyList()
@@ -95,13 +95,13 @@ public fun ResolutionFacade.resolveImportReference(
 //NOTE: idea default API returns module search scope for file under module but not in source or production source (for example, test data )
 // this scope can't be used to search for kotlin declarations in index in order to resolve in that case
 // see com.intellij.psi.impl.file.impl.ResolveScopeManagerImpl.getInherentResolveScope
-public fun getResolveScope(file: JetFile): GlobalSearchScope {
+public fun getResolveScope(file: KtFile): GlobalSearchScope {
     return when (file.getModuleInfo()) {
         is ModuleSourceInfo -> file.getResolveScope()
         else -> GlobalSearchScope.EMPTY_SCOPE
     }
 }
 
-public fun ResolutionFacade.getFileTopLevelScope(file: JetFile): LazyFileScope {
+public fun ResolutionFacade.getFileTopLevelScope(file: KtFile): LazyFileScope {
     return frontendService<FileScopeProvider>().getFileScope(file)
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/DescriptorToSourceUtilsIde.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/DescriptorToSourceUtilsIde.kt
index c0375562a9d..0c21ceadd19 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/DescriptorToSourceUtilsIde.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/DescriptorToSourceUtilsIde.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.codeInsight
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.idea.decompiler.navigation.DecompiledNavigationUtils
 import org.jetbrains.kotlin.idea.references.BuiltInsReferenceResolver
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/JetFileReferencesResolver.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/JetFileReferencesResolver.kt
index 9cf81fff190..138e906aa19 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/JetFileReferencesResolver.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/JetFileReferencesResolver.kt
@@ -16,37 +16,37 @@
 
 package org.jetbrains.kotlin.idea.codeInsight
 
-import org.jetbrains.kotlin.psi.JetReferenceExpression
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtReferenceExpression
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetTreeVisitorVoid
-import org.jetbrains.kotlin.psi.JetUserType
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetCallExpression
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtTreeVisitorVoid
+import org.jetbrains.kotlin.psi.KtUserType
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtCallExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import java.util.Collections
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
-import org.jetbrains.kotlin.psi.JetQualifiedExpression
+import org.jetbrains.kotlin.psi.KtQualifiedExpression
 import java.util.LinkedHashMap
 
 object JetFileReferencesResolver {
     fun resolve(
-            element: JetElement,
+            element: KtElement,
             resolveQualifiers: Boolean = true,
             resolveShortNames: Boolean = true
-    ): Map<JetReferenceExpression, BindingContext> {
-        return (element.getContainingFile() as? JetFile)?.let { file ->
+    ): Map<KtReferenceExpression, BindingContext> {
+        return (element.getContainingFile() as? KtFile)?.let { file ->
             resolve(file, listOf(element), resolveQualifiers, resolveShortNames)
         } ?: Collections.emptyMap()
     }
 
     fun resolve(
-            file: JetFile,
-            elements: Iterable<JetElement>? = null,
+            file: KtFile,
+            elements: Iterable<KtElement>? = null,
             resolveQualifiers: Boolean = true,
             resolveShortNames: Boolean = true
-    ): Map<JetReferenceExpression, BindingContext> {
+    ): Map<KtReferenceExpression, BindingContext> {
         val visitor = ResolveAllReferencesVisitor(file, resolveQualifiers, resolveShortNames)
         if (elements != null) {
             elements.forEach { it.accept(visitor) }
@@ -57,13 +57,13 @@ object JetFileReferencesResolver {
         return visitor.result
     }
 
-    private class ResolveAllReferencesVisitor(file: JetFile, val resolveQualifiers: Boolean, val resolveShortNames: Boolean) : JetTreeVisitorVoid() {
+    private class ResolveAllReferencesVisitor(file: KtFile, val resolveQualifiers: Boolean, val resolveShortNames: Boolean) : KtTreeVisitorVoid() {
         private val resolutionFacade = file.getResolutionFacade()
-        private val resolveMap = LinkedHashMap<JetReferenceExpression, BindingContext>()
+        private val resolveMap = LinkedHashMap<KtReferenceExpression, BindingContext>()
 
-        public val result: Map<JetReferenceExpression, BindingContext> = resolveMap
+        public val result: Map<KtReferenceExpression, BindingContext> = resolveMap
 
-        override fun visitUserType(userType: JetUserType) {
+        override fun visitUserType(userType: KtUserType) {
             if (resolveQualifiers) {
                 userType.acceptChildren(this)
             }
@@ -76,7 +76,7 @@ object JetFileReferencesResolver {
             }
         }
 
-        override fun visitQualifiedExpression(expression: JetQualifiedExpression) {
+        override fun visitQualifiedExpression(expression: KtQualifiedExpression) {
             val receiverExpression = expression.getReceiverExpression()
             if (resolveQualifiers || resolutionFacade.analyze(expression)[BindingContext.QUALIFIER, receiverExpression] == null) {
                 receiverExpression.accept(this)
@@ -89,7 +89,7 @@ object JetFileReferencesResolver {
             expression.getSelectorExpression()?.accept(this)
         }
 
-        override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+        override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
             if (resolveShortNames) {
                 resolveMap[expression] = resolutionFacade.analyze(expression)
             }
@@ -97,5 +97,5 @@ object JetFileReferencesResolver {
     }
 }
 
-fun JetExpression.referenceExpression(): JetReferenceExpression? =
-        (if (this is JetCallExpression) getCalleeExpression() else this) as? JetReferenceExpression
+fun KtExpression.referenceExpression(): KtReferenceExpression? =
+        (if (this is KtCallExpression) getCalleeExpression() else this) as? KtReferenceExpression
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/shorten/shortenWaitingSet.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/shorten/shortenWaitingSet.kt
index 5463f06d2f0..a4015622375 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/shorten/shortenWaitingSet.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/shorten/shortenWaitingSet.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.codeInsight.shorten
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.SmartPsiElementPointer
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.UserDataProperty
 import com.intellij.openapi.util.Key
 import org.jetbrains.kotlin.psi.NotNullableUserDataProperty
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.idea.util.ShortenReferences.Options
 import org.jetbrains.kotlin.idea.util.ShortenReferences
 import java.util.*
 
-class ShorteningRequest(val pointer: SmartPsiElementPointer<JetElement>, val options: Options)
+class ShorteningRequest(val pointer: SmartPsiElementPointer<KtElement>, val options: Options)
 
 private var Project.elementsToShorten: MutableSet<ShorteningRequest>?
         by UserDataProperty(Key.create("ELEMENTS_TO_SHORTEN_KEY"))
@@ -62,7 +62,7 @@ private fun Project.getOrCreateElementsToShorten(): MutableSet<ShorteningRequest
     return elements
 }
 
-public fun JetElement.addToShorteningWaitSet(options: Options = Options.DEFAULT) {
+public fun KtElement.addToShorteningWaitSet(options: Options = Options.DEFAULT) {
     assert(ApplicationManager.getApplication()!!.isWriteAccessAllowed()) { "Write access needed" }
     val project = getProject()
     val elementPointer = SmartPointerManager.getInstance(project).createSmartPsiElementPointer(this)
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/AnnotationLoaderForKotlinJavaScriptStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/AnnotationLoaderForKotlinJavaScriptStubBuilder.kt
index d2db5a88ee2..d241612bb66 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/AnnotationLoaderForKotlinJavaScriptStubBuilder.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/AnnotationLoaderForKotlinJavaScriptStubBuilder.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.serialization.deserialization.AnnotationAndConstantL
 import org.jetbrains.kotlin.serialization.deserialization.NameResolver
 import org.jetbrains.kotlin.serialization.deserialization.ProtoContainer
 import org.jetbrains.kotlin.serialization.js.JsProtoBuf
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 public class AnnotationLoaderForKotlinJavaScriptStubBuilder() : AnnotationAndConstantLoader<ClassId, Unit, ClassIdWithTarget> {
 
@@ -79,6 +79,6 @@ public class AnnotationLoaderForKotlinJavaScriptStubBuilder() : AnnotationAndCon
     override fun loadPropertyConstant(
             container: ProtoContainer,
             proto: ProtoBuf.Property,
-            expectedType: JetType
+            expectedType: KtType
     ) {}
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/KotlinClsFileBase.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/KotlinClsFileBase.kt
index 1325c1ff581..77f56786a10 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/KotlinClsFileBase.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/KotlinClsFileBase.kt
@@ -24,26 +24,26 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.idea.decompiler.textBuilder.DecompiledText
 import org.jetbrains.kotlin.idea.decompiler.textBuilder.descriptorToKey
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.utils.concurrent.block.LockedClearableLazyValue
 
-public abstract class KotlinClsFileBase(val provider: KotlinClassFileViewProvider) : JetFile(provider, true) {
+public abstract class KotlinClsFileBase(val provider: KotlinClassFileViewProvider) : KtFile(provider, true) {
     protected abstract val decompiledText: LockedClearableLazyValue<DecompiledText>
 
-    public fun getDeclarationForDescriptor(descriptor: DeclarationDescriptor): JetDeclaration? {
+    public fun getDeclarationForDescriptor(descriptor: DeclarationDescriptor): KtDeclaration? {
         val original = descriptor.getOriginal()
 
         if (original is ValueParameterDescriptor) {
             val callable = original.getContainingDeclaration()
-            val callableDeclaration = getDeclarationForDescriptor(callable) as? JetCallableDeclaration ?: return null
+            val callableDeclaration = getDeclarationForDescriptor(callable) as? KtCallableDeclaration ?: return null
             return callableDeclaration.getValueParameters()[original.getIndex()]
         }
 
         if (original is ConstructorDescriptor && original.isPrimary()) {
-            val classOrObject = getDeclarationForDescriptor(original.getContainingDeclaration()) as? JetClassOrObject
+            val classOrObject = getDeclarationForDescriptor(original.getContainingDeclaration()) as? KtClassOrObject
             return classOrObject?.getPrimaryConstructor() ?: classOrObject
         }
 
@@ -51,7 +51,7 @@ public abstract class KotlinClsFileBase(val provider: KotlinClassFileViewProvide
 
         val range = decompiledText.get().renderedDescriptorsToRange[key]
         return if (range != null) {
-            PsiTreeUtil.findElementOfClassAtRange(this, range.getStartOffset(), range.getEndOffset(), javaClass<JetDeclaration>())
+            PsiTreeUtil.findElementOfClassAtRange(this, range.getStartOffset(), range.getEndOffset(), javaClass<KtDeclaration>())
         }
         else {
             null
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/kotlinFileViewProviders.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/kotlinFileViewProviders.kt
index 97249849f6e..99f6b1f73b5 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/kotlinFileViewProviders.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/kotlinFileViewProviders.kt
@@ -25,7 +25,7 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiManager
 import com.intellij.psi.SingleRootFileViewProvider
 import com.intellij.psi.impl.source.PsiFileImpl
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.utils.concurrent.block.LockedClearableLazyValue
 
@@ -34,7 +34,7 @@ abstract class KotlinClassFileViewProvider(
         file: VirtualFile,
         physical: Boolean) : SingleRootFileViewProvider(manager, file, physical, KotlinLanguage.INSTANCE) {
     val content : LockedClearableLazyValue<String> = LockedClearableLazyValue(Any()) {
-        val psiFile = createFile(manager.getProject(), file, JetFileType.INSTANCE)
+        val psiFile = createFile(manager.getProject(), file, KotlinFileType.INSTANCE)
         val text = psiFile?.getText() ?: ""
 
         (psiFile as? PsiFileImpl)?.markInvalidated()
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/DecompiledNavigationUtils.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/DecompiledNavigationUtils.java
index f1d95230fd8..47ded54a3e5 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/DecompiledNavigationUtils.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/DecompiledNavigationUtils.java
@@ -35,8 +35,8 @@ import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory;
 import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
-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.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor;
@@ -51,7 +51,7 @@ import static org.jetbrains.kotlin.load.kotlin.PackageClassUtils.getPackageClass
 public final class DecompiledNavigationUtils {
 
     @Nullable
-    public static JetDeclaration getDeclarationFromDecompiledClassFile(
+    public static KtDeclaration getDeclarationFromDecompiledClassFile(
             @NotNull Project project,
             @NotNull DeclarationDescriptor referencedDescriptor
     ) {
@@ -130,13 +130,13 @@ public final class DecompiledNavigationUtils {
                 Name partClassName = JvmFileClassUtil.getImplClassName((DeserializedCallableMemberDescriptor) referencedDescriptor);
                 if (partClassName != null) {
                     FqName partFQN = packageFQN.child(partClassName);
-                    Collection<JetFile> multifileFacadeJetFiles =
+                    Collection<KtFile> multifileFacadeJetFiles =
                             StaticFacadeIndexUtil.getMultifileClassForPart(partFQN, GlobalSearchScope.allScope(project), project);
                     if (multifileFacadeJetFiles.isEmpty()) {
                         return new ClassId(packageFQN, partClassName);
                     }
                     else {
-                        JetFile multifileFacade = multifileFacadeJetFiles.iterator().next();
+                        KtFile multifileFacade = multifileFacadeJetFiles.iterator().next();
                         String multifileFacadeName = multifileFacade.getVirtualFile().getNameWithoutExtension();
                         return new ClassId(packageFQN, Name.identifier(multifileFacadeName));
                     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/JetSourceNavigationHelper.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/JetSourceNavigationHelper.java
index 6d58f654abd..7fa86c1c5b6 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/JetSourceNavigationHelper.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/JetSourceNavigationHelper.java
@@ -52,7 +52,7 @@ import org.jetbrains.kotlin.idea.stubindex.JetSourceFilterScope;
 import org.jetbrains.kotlin.idea.stubindex.JetTopLevelFunctionFqnNameIndex;
 import org.jetbrains.kotlin.idea.stubindex.JetTopLevelPropertyFqnNameIndex;
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
@@ -89,10 +89,10 @@ public class JetSourceNavigationHelper {
 
     @NotNull
     private static GlobalSearchScope createLibraryOrSourcesScope(
-            @NotNull JetNamedDeclaration declaration,
+            @NotNull KtNamedDeclaration declaration,
             @NotNull NavigationKind navigationKind
     ) {
-        JetFile containingFile = declaration.getContainingJetFile();
+        KtFile containingFile = declaration.getContainingJetFile();
         VirtualFile libraryFile = containingFile.getVirtualFile();
         if (libraryFile == null) return GlobalSearchScope.EMPTY_SCOPE;
 
@@ -107,20 +107,20 @@ public class JetSourceNavigationHelper {
                : JetSourceFilterScope.kotlinLibraryClassFiles(GlobalSearchScope.allScope(project), project);
     }
 
-    private static List<JetFile> getContainingFiles(@NotNull Iterable<JetNamedDeclaration> declarations) {
-        Set<JetFile> result = Sets.newHashSet();
-        for (JetNamedDeclaration declaration : declarations) {
+    private static List<KtFile> getContainingFiles(@NotNull Iterable<KtNamedDeclaration> declarations) {
+        Set<KtFile> result = Sets.newHashSet();
+        for (KtNamedDeclaration declaration : declarations) {
             PsiFile containingFile = declaration.getContainingFile();
-            if (containingFile instanceof JetFile) {
-                result.add((JetFile) containingFile);
+            if (containingFile instanceof KtFile) {
+                result.add((KtFile) containingFile);
             }
         }
         return Lists.newArrayList(result);
     }
 
-    private static boolean haveRenamesInImports(@NotNull List<JetFile> files) {
-        for (JetFile file : files) {
-            for (JetImportDirective importDirective : file.getImportDirectives()) {
+    private static boolean haveRenamesInImports(@NotNull List<KtFile> files) {
+        for (KtFile file : files) {
+            for (KtImportDirective importDirective : file.getImportDirectives()) {
                 if (importDirective.getAliasName() != null) {
                     return true;
                 }
@@ -130,18 +130,18 @@ public class JetSourceNavigationHelper {
     }
 
     @Nullable
-    private static JetNamedDeclaration findSpecialProperty(@NotNull Name memberName, @NotNull JetClass containingClass) {
+    private static KtNamedDeclaration findSpecialProperty(@NotNull Name memberName, @NotNull KtClass containingClass) {
         // property constructor parameters
-        List<JetParameter> constructorParameters = containingClass.getPrimaryConstructorParameters();
-        for (JetParameter constructorParameter : constructorParameters) {
+        List<KtParameter> constructorParameters = containingClass.getPrimaryConstructorParameters();
+        for (KtParameter constructorParameter : constructorParameters) {
             if (memberName.equals(constructorParameter.getNameAsName()) && constructorParameter.hasValOrVar()) {
                 return constructorParameter;
             }
         }
 
         // enum entries
-        if (containingClass.hasModifier(JetTokens.ENUM_KEYWORD)) {
-            for (JetEnumEntry enumEntry : ContainerUtil.findAll(containingClass.getDeclarations(), JetEnumEntry.class)) {
+        if (containingClass.hasModifier(KtTokens.ENUM_KEYWORD)) {
+            for (KtEnumEntry enumEntry : ContainerUtil.findAll(containingClass.getDeclarations(), KtEnumEntry.class)) {
                 if (memberName.equals(enumEntry.getNameAsName())) {
                     return enumEntry;
                 }
@@ -151,14 +151,14 @@ public class JetSourceNavigationHelper {
     }
 
     @Nullable
-    private static JetNamedDeclaration convertPropertyOrFunction(
-            @NotNull JetNamedDeclaration declaration,
+    private static KtNamedDeclaration convertPropertyOrFunction(
+            @NotNull KtNamedDeclaration declaration,
             @NotNull NavigationKind navigationKind
     ) {
-        if (declaration instanceof JetPrimaryConstructor) {
-            JetClassOrObject sourceClassOrObject =
-                    convertNamedClassOrObject(((JetPrimaryConstructor) declaration).getContainingClassOrObject(), navigationKind);
-            JetPrimaryConstructor primaryConstructor = sourceClassOrObject != null ? sourceClassOrObject.getPrimaryConstructor() : null;
+        if (declaration instanceof KtPrimaryConstructor) {
+            KtClassOrObject sourceClassOrObject =
+                    convertNamedClassOrObject(((KtPrimaryConstructor) declaration).getContainingClassOrObject(), navigationKind);
+            KtPrimaryConstructor primaryConstructor = sourceClassOrObject != null ? sourceClassOrObject.getPrimaryConstructor() : null;
             return primaryConstructor != null ? primaryConstructor : sourceClassOrObject;
         }
 
@@ -171,23 +171,23 @@ public class JetSourceNavigationHelper {
 
         PsiElement decompiledContainer = declaration.getParent();
 
-        Collection<JetNamedDeclaration> candidates;
-        if (decompiledContainer instanceof JetFile) {
+        Collection<KtNamedDeclaration> candidates;
+        if (decompiledContainer instanceof KtFile) {
             candidates = getInitialTopLevelCandidates(declaration, navigationKind);
         }
-        else if (decompiledContainer instanceof JetClassBody) {
-            JetClassOrObject decompiledClassOrObject = (JetClassOrObject) decompiledContainer.getParent();
-            JetClassOrObject sourceClassOrObject = convertNamedClassOrObject(decompiledClassOrObject, navigationKind);
+        else if (decompiledContainer instanceof KtClassBody) {
+            KtClassOrObject decompiledClassOrObject = (KtClassOrObject) decompiledContainer.getParent();
+            KtClassOrObject sourceClassOrObject = convertNamedClassOrObject(decompiledClassOrObject, navigationKind);
 
             //noinspection unchecked
             candidates = sourceClassOrObject == null
-                         ? Collections.<JetNamedDeclaration>emptyList()
+                         ? Collections.<KtNamedDeclaration>emptyList()
                          : getInitialMemberCandidates(sourceClassOrObject, memberName,
-                                                      (Class<JetNamedDeclaration>) declaration.getClass());
+                                                      (Class<KtNamedDeclaration>) declaration.getClass());
 
             if (candidates.isEmpty()) {
-                if (declaration instanceof JetProperty && sourceClassOrObject instanceof JetClass) {
-                    return findSpecialProperty(memberName, (JetClass) sourceClassOrObject);
+                if (declaration instanceof KtProperty && sourceClassOrObject instanceof KtClass) {
+                    return findSpecialProperty(memberName, (KtClass) sourceClassOrObject);
                 }
             }
         }
@@ -220,12 +220,12 @@ public class JetSourceNavigationHelper {
 
         KotlinCodeAnalyzer analyzer = createAnalyzer(candidates, declaration.getProject());
 
-        for (JetNamedDeclaration candidate : candidates) {
+        for (KtNamedDeclaration candidate : candidates) {
             //noinspection unchecked
             CallableDescriptor candidateDescriptor = (CallableDescriptor) analyzer.resolveToDescriptor(candidate);
             if (receiversMatch(declaration, candidateDescriptor)
                     && valueParametersTypesMatch(declaration, candidateDescriptor)
-                    && typeParametersMatch((JetTypeParameterListOwner) declaration, candidateDescriptor.getTypeParameters())) {
+                    && typeParametersMatch((KtTypeParameterListOwner) declaration, candidateDescriptor.getTypeParameters())) {
                 return candidate;
             }
         }
@@ -235,7 +235,7 @@ public class JetSourceNavigationHelper {
 
     @NotNull
     private static KotlinCodeAnalyzer createAnalyzer(
-            @NotNull Collection<JetNamedDeclaration> candidates,
+            @NotNull Collection<KtNamedDeclaration> candidates,
             @NotNull Project project
     ) {
 
@@ -268,8 +268,8 @@ public class JetSourceNavigationHelper {
     }
 
     @Nullable
-    private static JetClassOrObject convertNamedClassOrObject(
-            @NotNull JetClassOrObject classOrObject,
+    private static KtClassOrObject convertNamedClassOrObject(
+            @NotNull KtClassOrObject classOrObject,
             @NotNull NavigationKind navigationKind
     ) {
         FqName classFqName = classOrObject.getFqName();
@@ -279,7 +279,7 @@ public class JetSourceNavigationHelper {
         if (librarySourcesScope == GlobalSearchScope.EMPTY_SCOPE) { // .getProject() == null for EMPTY_SCOPE, and this breaks code
             return null;
         }
-        Collection<JetClassOrObject> classes = JetFullClassNameIndex.getInstance()
+        Collection<KtClassOrObject> classes = JetFullClassNameIndex.getInstance()
                 .get(classFqName.asString(), classOrObject.getProject(), librarySourcesScope);
         if (classes.isEmpty()) {
             return null;
@@ -288,8 +288,8 @@ public class JetSourceNavigationHelper {
     }
 
     @NotNull
-    private static Collection<JetNamedDeclaration> getInitialTopLevelCandidates(
-            @NotNull JetNamedDeclaration declaration,
+    private static Collection<KtNamedDeclaration> getInitialTopLevelCandidates(
+            @NotNull KtNamedDeclaration declaration,
             @NotNull NavigationKind navigationKind
     ) {
         FqName memberFqName = declaration.getFqName();
@@ -300,59 +300,59 @@ public class JetSourceNavigationHelper {
             return Collections.emptyList();
         }
         //noinspection unchecked
-        StringStubIndexExtension<JetNamedDeclaration> index =
-                (StringStubIndexExtension<JetNamedDeclaration>) getIndexForTopLevelPropertyOrFunction(declaration);
+        StringStubIndexExtension<KtNamedDeclaration> index =
+                (StringStubIndexExtension<KtNamedDeclaration>) getIndexForTopLevelPropertyOrFunction(declaration);
         return index.get(memberFqName.asString(), declaration.getProject(), librarySourcesScope);
     }
 
-    private static StringStubIndexExtension<? extends JetNamedDeclaration> getIndexForTopLevelPropertyOrFunction(
-            @NotNull JetNamedDeclaration decompiledDeclaration
+    private static StringStubIndexExtension<? extends KtNamedDeclaration> getIndexForTopLevelPropertyOrFunction(
+            @NotNull KtNamedDeclaration decompiledDeclaration
     ) {
-        if (decompiledDeclaration instanceof JetNamedFunction) {
+        if (decompiledDeclaration instanceof KtNamedFunction) {
             return JetTopLevelFunctionFqnNameIndex.getInstance();
         }
-        if (decompiledDeclaration instanceof JetProperty) {
+        if (decompiledDeclaration instanceof KtProperty) {
             return JetTopLevelPropertyFqnNameIndex.getInstance();
         }
         throw new IllegalArgumentException("Neither function nor declaration: " + decompiledDeclaration.getClass().getName());
     }
 
     @NotNull
-    private static List<JetNamedDeclaration> getInitialMemberCandidates(
-            @NotNull JetClassOrObject sourceClassOrObject,
+    private static List<KtNamedDeclaration> getInitialMemberCandidates(
+            @NotNull KtClassOrObject sourceClassOrObject,
             @NotNull final Name name,
-            @NotNull Class<JetNamedDeclaration> declarationClass
+            @NotNull Class<KtNamedDeclaration> declarationClass
     ) {
-        List<JetNamedDeclaration> allByClass = ContainerUtil.findAll(sourceClassOrObject.getDeclarations(), declarationClass);
-        return ContainerUtil.filter(allByClass, new Condition<JetNamedDeclaration>() {
+        List<KtNamedDeclaration> allByClass = ContainerUtil.findAll(sourceClassOrObject.getDeclarations(), declarationClass);
+        return ContainerUtil.filter(allByClass, new Condition<KtNamedDeclaration>() {
             @Override
-            public boolean value(JetNamedDeclaration declaration) {
+            public boolean value(KtNamedDeclaration declaration) {
                 return name.equals(declaration.getNameAsSafeName());
             }
         });
     }
 
     @NotNull
-    private static List<JetNamedDeclaration> filterByReceiverPresenceAndParametersCount(
-            final @NotNull JetNamedDeclaration decompiledDeclaration,
-            @NotNull Collection<JetNamedDeclaration> candidates
+    private static List<KtNamedDeclaration> filterByReceiverPresenceAndParametersCount(
+            final @NotNull KtNamedDeclaration decompiledDeclaration,
+            @NotNull Collection<KtNamedDeclaration> candidates
     ) {
-        return ContainerUtil.filter(candidates, new Condition<JetNamedDeclaration>() {
+        return ContainerUtil.filter(candidates, new Condition<KtNamedDeclaration>() {
             @Override
-            public boolean value(JetNamedDeclaration candidate) {
+            public boolean value(KtNamedDeclaration candidate) {
                 return sameReceiverPresenceAndParametersCount(candidate, decompiledDeclaration);
             }
         });
     }
 
     @NotNull
-    private static List<JetNamedDeclaration> filterByReceiverAndParameterTypes(
-            final @NotNull JetNamedDeclaration decompiledDeclaration,
-            @NotNull Collection<JetNamedDeclaration> candidates
+    private static List<KtNamedDeclaration> filterByReceiverAndParameterTypes(
+            final @NotNull KtNamedDeclaration decompiledDeclaration,
+            @NotNull Collection<KtNamedDeclaration> candidates
     ) {
-        return ContainerUtil.filter(candidates, new Condition<JetNamedDeclaration>() {
+        return ContainerUtil.filter(candidates, new Condition<KtNamedDeclaration>() {
             @Override
-            public boolean value(JetNamedDeclaration candidate) {
+            public boolean value(KtNamedDeclaration candidate) {
                 return receiverAndParametersShortTypesMatch(candidate, decompiledDeclaration);
             }
         });
@@ -364,7 +364,7 @@ public class JetSourceNavigationHelper {
     }
 
     @Nullable
-    public static PsiClass getOriginalPsiClassOrCreateLightClass(@NotNull JetClassOrObject classOrObject) {
+    public static PsiClass getOriginalPsiClassOrCreateLightClass(@NotNull KtClassOrObject classOrObject) {
         if (LightClassUtil.INSTANCE$.belongsToKotlinBuiltIns(classOrObject.getContainingJetFile())) {
             FqName fqName = classOrObject.getFqName();
             if (fqName != null) {
@@ -381,7 +381,7 @@ public class JetSourceNavigationHelper {
     }
 
     @Nullable
-    public static PsiClass getOriginalClass(@NotNull JetClassOrObject classOrObject) {
+    public static PsiClass getOriginalClass(@NotNull KtClassOrObject classOrObject) {
         // Copied from JavaPsiImplementationHelperImpl:getOriginalClass()
         String internalName = PsiCodegenPredictor.getPredefinedJvmInternalName(classOrObject, NoResolveFileClassesProvider.INSTANCE$);
         if (internalName == null) {
@@ -389,7 +389,7 @@ public class JetSourceNavigationHelper {
         }
         String fqName = JvmClassName.byInternalName(internalName).getFqNameForClassNameWithoutDollars().asString();
 
-        JetFile file = classOrObject.getContainingJetFile();
+        KtFile file = classOrObject.getContainingJetFile();
 
         VirtualFile vFile = file.getVirtualFile();
         Project project = file.getProject();
@@ -427,18 +427,18 @@ public class JetSourceNavigationHelper {
     }
 
     @NotNull
-    public static JetDeclaration getNavigationElement(@NotNull JetDeclaration declaration) {
+    public static KtDeclaration getNavigationElement(@NotNull KtDeclaration declaration) {
         return navigateToDeclaration(declaration, NavigationKind.CLASS_FILES_TO_SOURCES);
     }
 
     @NotNull
-    public static JetDeclaration getOriginalElement(@NotNull JetDeclaration declaration) {
+    public static KtDeclaration getOriginalElement(@NotNull KtDeclaration declaration) {
         return navigateToDeclaration(declaration, NavigationKind.SOURCES_TO_CLASS_FILES);
     }
 
     @NotNull
-    public static JetDeclaration navigateToDeclaration(
-            @NotNull JetDeclaration from,
+    public static KtDeclaration navigateToDeclaration(
+            @NotNull KtDeclaration from,
             @NotNull NavigationKind navigationKind) {
         if (DumbService.isDumb(from.getProject())) return from;
 
@@ -449,15 +449,15 @@ public class JetSourceNavigationHelper {
             case SOURCES_TO_CLASS_FILES:
                 if (from.getContainingJetFile().isCompiled()) return from;
                 if (!ProjectRootsUtil.isInContent(from, false, true, false)) return from;
-                if (JetPsiUtil.isLocal(from)) return from;
+                if (KtPsiUtil.isLocal(from)) return from;
                 break;
         }
 
-        JetDeclaration result = from.accept(new SourceAndDecompiledConversionVisitor(navigationKind), null);
+        KtDeclaration result = from.accept(new SourceAndDecompiledConversionVisitor(navigationKind), null);
         return result != null ? result : from;
     }
 
-    private static class SourceAndDecompiledConversionVisitor extends JetVisitor<JetDeclaration, Void> {
+    private static class SourceAndDecompiledConversionVisitor extends KtVisitor<KtDeclaration, Void> {
         private final NavigationKind navigationKind;
 
         public SourceAndDecompiledConversionVisitor(@NotNull NavigationKind navigationKind) {
@@ -465,45 +465,45 @@ public class JetSourceNavigationHelper {
         }
 
         @Override
-        public JetDeclaration visitNamedFunction(@NotNull JetNamedFunction function, Void data) {
+        public KtDeclaration visitNamedFunction(@NotNull KtNamedFunction function, Void data) {
             return convertPropertyOrFunction(function, navigationKind);
         }
 
         @Override
-        public JetDeclaration visitProperty(@NotNull JetProperty property, Void data) {
+        public KtDeclaration visitProperty(@NotNull KtProperty property, Void data) {
             return convertPropertyOrFunction(property, navigationKind);
         }
 
         @Override
-        public JetDeclaration visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, Void data) {
+        public KtDeclaration visitObjectDeclaration(@NotNull KtObjectDeclaration declaration, Void data) {
             return convertNamedClassOrObject(declaration, navigationKind);
         }
 
         @Override
-        public JetDeclaration visitClass(@NotNull JetClass klass, Void data) {
+        public KtDeclaration visitClass(@NotNull KtClass klass, Void data) {
             return convertNamedClassOrObject(klass, navigationKind);
         }
 
         @Override
-        public JetDeclaration visitParameter(@NotNull JetParameter parameter, Void data) {
-            JetCallableDeclaration callableDeclaration = (JetCallableDeclaration) parameter.getParent().getParent();
-            List<JetParameter> parameters = callableDeclaration.getValueParameters();
+        public KtDeclaration visitParameter(@NotNull KtParameter parameter, Void data) {
+            KtCallableDeclaration callableDeclaration = (KtCallableDeclaration) parameter.getParent().getParent();
+            List<KtParameter> parameters = callableDeclaration.getValueParameters();
             int index = parameters.indexOf(parameter);
 
-            JetCallableDeclaration sourceCallable = (JetCallableDeclaration) callableDeclaration.accept(this, null);
+            KtCallableDeclaration sourceCallable = (KtCallableDeclaration) callableDeclaration.accept(this, null);
             if (sourceCallable == null) return null;
-            List<JetParameter> sourceParameters = sourceCallable.getValueParameters();
+            List<KtParameter> sourceParameters = sourceCallable.getValueParameters();
             if (sourceParameters.size() != parameters.size()) return null;
             return sourceParameters.get(index);
         }
 
         @Override
-        public JetDeclaration visitPrimaryConstructor(@NotNull JetPrimaryConstructor constructor, Void data) {
+        public KtDeclaration visitPrimaryConstructor(@NotNull KtPrimaryConstructor constructor, Void data) {
             return convertPropertyOrFunction(constructor, navigationKind);
         }
 
         @Override
-        public JetDeclaration visitSecondaryConstructor(@NotNull JetSecondaryConstructor constructor, Void data) {
+        public KtDeclaration visitSecondaryConstructor(@NotNull KtSecondaryConstructor constructor, Void data) {
             return convertPropertyOrFunction(constructor, navigationKind);
         }
     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/KotlinDeclarationNavigationPolicyImpl.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/KotlinDeclarationNavigationPolicyImpl.kt
index 961cd3c8252..8fdb9264450 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/KotlinDeclarationNavigationPolicyImpl.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/KotlinDeclarationNavigationPolicyImpl.kt
@@ -17,13 +17,13 @@
 package org.jetbrains.kotlin.idea.decompiler.navigation
 
 import org.jetbrains.kotlin.psi.KotlinDeclarationNavigationPolicy
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtDeclaration
 import com.intellij.openapi.project.DumbService
 
 public class KotlinDeclarationNavigationPolicyImpl : KotlinDeclarationNavigationPolicy {
-    override fun getOriginalElement(declaration: JetDeclaration) =
+    override fun getOriginalElement(declaration: KtDeclaration) =
             JetSourceNavigationHelper.getOriginalElement(declaration)
-    override fun getNavigationElement(declaration: JetDeclaration) =
+    override fun getNavigationElement(declaration: KtDeclaration) =
             JetSourceNavigationHelper.getNavigationElement(declaration)
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/MemberMatching.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/MemberMatching.java
index c43b25e0726..9b75551cea8 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/MemberMatching.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/MemberMatching.java
@@ -28,12 +28,12 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.List;
 import java.util.Set;
@@ -41,39 +41,39 @@ import java.util.Set;
 public class MemberMatching {
     /* DECLARATIONS ROUGH MATCHING */
     @Nullable
-    private static JetTypeReference getReceiverType(@NotNull JetNamedDeclaration propertyOrFunction) {
-        if (propertyOrFunction instanceof JetCallableDeclaration) {
-            return ((JetCallableDeclaration) propertyOrFunction).getReceiverTypeReference();
+    private static KtTypeReference getReceiverType(@NotNull KtNamedDeclaration propertyOrFunction) {
+        if (propertyOrFunction instanceof KtCallableDeclaration) {
+            return ((KtCallableDeclaration) propertyOrFunction).getReceiverTypeReference();
         }
         throw new IllegalArgumentException("Not a callable declaration: " + propertyOrFunction.getClass().getName());
     }
 
     @NotNull
-    private static List<JetParameter> getValueParameters(@NotNull JetNamedDeclaration propertyOrFunction) {
-        if (propertyOrFunction instanceof JetCallableDeclaration) {
-            return ((JetCallableDeclaration) propertyOrFunction).getValueParameters();
+    private static List<KtParameter> getValueParameters(@NotNull KtNamedDeclaration propertyOrFunction) {
+        if (propertyOrFunction instanceof KtCallableDeclaration) {
+            return ((KtCallableDeclaration) propertyOrFunction).getValueParameters();
         }
         throw new IllegalArgumentException("Not a callable declaration: " + propertyOrFunction.getClass().getName());
     }
 
-    private static String getTypeShortName(@NotNull JetTypeReference typeReference) {
-        JetTypeElement typeElement = typeReference.getTypeElement();
+    private static String getTypeShortName(@NotNull KtTypeReference typeReference) {
+        KtTypeElement typeElement = typeReference.getTypeElement();
         assert typeElement != null;
-        return typeElement.accept(new JetVisitor<String, Void>() {
+        return typeElement.accept(new KtVisitor<String, Void>() {
             @Override
-            public String visitDeclaration(@NotNull JetDeclaration declaration, Void data) {
+            public String visitDeclaration(@NotNull KtDeclaration declaration, Void data) {
                 throw new IllegalStateException("This visitor shouldn't be invoked for " + declaration.getClass());
             }
 
             @Override
-            public String visitUserType(@NotNull JetUserType type, Void data) {
-                JetSimpleNameExpression referenceExpression = type.getReferenceExpression();
+            public String visitUserType(@NotNull KtUserType type, Void data) {
+                KtSimpleNameExpression referenceExpression = type.getReferenceExpression();
                 assert referenceExpression != null;
                 return referenceExpression.getReferencedName();
             }
 
             @Override
-            public String visitFunctionType(@NotNull JetFunctionType type, Void data) {
+            public String visitFunctionType(@NotNull KtFunctionType type, Void data) {
                 int parameterCount = type.getParameters().size();
                 if (type.getReceiverTypeReference() != null) {
                     return KotlinBuiltIns.getExtensionFunctionName(parameterCount);
@@ -84,32 +84,32 @@ public class MemberMatching {
             }
 
             @Override
-            public String visitNullableType(@NotNull JetNullableType nullableType, Void data) {
-                JetTypeElement innerType = nullableType.getInnerType();
+            public String visitNullableType(@NotNull KtNullableType nullableType, Void data) {
+                KtTypeElement innerType = nullableType.getInnerType();
                 assert innerType != null : "No inner type: " + nullableType;
                 return innerType.accept(this, null);
             }
 
             @Override
-            public String visitDynamicType(@NotNull JetDynamicType type, Void data) {
+            public String visitDynamicType(@NotNull KtDynamicType type, Void data) {
                 return "dynamic";
             }
         }, null);
     }
 
-    private static boolean typesHaveSameShortName(@NotNull JetTypeReference a, @NotNull JetTypeReference b) {
+    private static boolean typesHaveSameShortName(@NotNull KtTypeReference a, @NotNull KtTypeReference b) {
         return getTypeShortName(a).equals(getTypeShortName(b));
     }
 
-    static boolean sameReceiverPresenceAndParametersCount(@NotNull JetNamedDeclaration a, @NotNull JetNamedDeclaration b) {
+    static boolean sameReceiverPresenceAndParametersCount(@NotNull KtNamedDeclaration a, @NotNull KtNamedDeclaration b) {
         boolean sameReceiverPresence = (getReceiverType(a) == null) == (getReceiverType(b) == null);
         boolean sameParametersCount = getValueParameters(a).size() == getValueParameters(b).size();
         return sameReceiverPresence && sameParametersCount;
     }
 
-    static boolean receiverAndParametersShortTypesMatch(@NotNull JetNamedDeclaration a, @NotNull JetNamedDeclaration b) {
-        JetTypeReference aReceiver = getReceiverType(a);
-        JetTypeReference bReceiver = getReceiverType(b);
+    static boolean receiverAndParametersShortTypesMatch(@NotNull KtNamedDeclaration a, @NotNull KtNamedDeclaration b) {
+        KtTypeReference aReceiver = getReceiverType(a);
+        KtTypeReference bReceiver = getReceiverType(b);
         if ((aReceiver == null) != (bReceiver == null)) {
             return false;
         }
@@ -118,14 +118,14 @@ public class MemberMatching {
             return false;
         }
 
-        List<JetParameter> aParameters = getValueParameters(a);
-        List<JetParameter> bParameters = getValueParameters(b);
+        List<KtParameter> aParameters = getValueParameters(a);
+        List<KtParameter> bParameters = getValueParameters(b);
         if (aParameters.size() != bParameters.size()) {
             return false;
         }
         for (int i = 0; i < aParameters.size(); i++) {
-            JetTypeReference aType = aParameters.get(i).getTypeReference();
-            JetTypeReference bType = bParameters.get(i).getTypeReference();
+            KtTypeReference aType = aParameters.get(i).getTypeReference();
+            KtTypeReference bType = bParameters.get(i).getTypeReference();
 
             assert aType != null;
             assert bType != null;
@@ -139,8 +139,8 @@ public class MemberMatching {
 
 
     /* DECLARATION AND DESCRIPTOR STRICT MATCHING */
-    static boolean receiversMatch(@NotNull JetNamedDeclaration declaration, @NotNull CallableDescriptor descriptor) {
-        JetTypeReference declarationReceiver = getReceiverType(declaration);
+    static boolean receiversMatch(@NotNull KtNamedDeclaration declaration, @NotNull CallableDescriptor descriptor) {
+        KtTypeReference declarationReceiver = getReceiverType(declaration);
         ReceiverParameterDescriptor descriptorReceiver = descriptor.getExtensionReceiverParameter();
         if (declarationReceiver == null && descriptorReceiver == null) {
             return true;
@@ -151,8 +151,8 @@ public class MemberMatching {
         return false;
     }
 
-    static boolean valueParametersTypesMatch(@NotNull JetNamedDeclaration declaration, @NotNull CallableDescriptor descriptor) {
-        List<JetParameter> declarationParameters = getValueParameters(declaration);
+    static boolean valueParametersTypesMatch(@NotNull KtNamedDeclaration declaration, @NotNull CallableDescriptor descriptor) {
+        List<KtParameter> declarationParameters = getValueParameters(declaration);
         List<ValueParameterDescriptor> descriptorParameters = descriptor.getValueParameters();
         if (descriptorParameters.size() != declarationParameters.size()) {
             return false;
@@ -160,20 +160,20 @@ public class MemberMatching {
 
         for (int i = 0; i < descriptorParameters.size(); i++) {
             ValueParameterDescriptor descriptorParameter = descriptorParameters.get(i);
-            JetParameter declarationParameter = declarationParameters.get(i);
-            JetTypeReference typeReference = declarationParameter.getTypeReference();
+            KtParameter declarationParameter = declarationParameters.get(i);
+            KtTypeReference typeReference = declarationParameter.getTypeReference();
             if (typeReference == null) {
                 return false;
             }
-            JetModifierList modifierList = declarationParameter.getModifierList();
-            boolean varargInDeclaration = modifierList != null && modifierList.hasModifier(JetTokens.VARARG_KEYWORD);
+            KtModifierList modifierList = declarationParameter.getModifierList();
+            boolean varargInDeclaration = modifierList != null && modifierList.hasModifier(KtTokens.VARARG_KEYWORD);
             boolean varargInDescriptor = descriptorParameter.getVarargElementType() != null;
             if (varargInDeclaration != varargInDescriptor) {
                 return false;
             }
             String declarationTypeText = typeReference.getText();
 
-            JetType typeToRender = varargInDeclaration ? descriptorParameter.getVarargElementType() : descriptorParameter.getType();
+            KtType typeToRender = varargInDeclaration ? descriptorParameter.getVarargElementType() : descriptorParameter.getType();
             assert typeToRender != null;
             String descriptorParameterText = DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(typeToRender);
             if (!declarationTypeText.equals(descriptorParameterText)) {
@@ -184,34 +184,34 @@ public class MemberMatching {
     }
 
     static boolean typeParametersMatch(
-            @NotNull JetTypeParameterListOwner typeParameterListOwner,
+            @NotNull KtTypeParameterListOwner typeParameterListOwner,
             @NotNull List<TypeParameterDescriptor> typeParameterDescriptors
     ) {
-        List<JetTypeParameter> decompiledParameters = typeParameterListOwner.getTypeParameters();
+        List<KtTypeParameter> decompiledParameters = typeParameterListOwner.getTypeParameters();
         if (decompiledParameters.size() != typeParameterDescriptors.size()) {
             return false;
         }
 
         Multimap<Name, String> decompiledParameterToBounds = HashMultimap.create();
-        for (JetTypeParameter parameter : decompiledParameters) {
-            JetTypeReference extendsBound = parameter.getExtendsBound();
+        for (KtTypeParameter parameter : decompiledParameters) {
+            KtTypeReference extendsBound = parameter.getExtendsBound();
             if (extendsBound != null) {
                 decompiledParameterToBounds.put(parameter.getNameAsName(), extendsBound.getText());
             }
         }
 
-        for (JetTypeConstraint typeConstraint : typeParameterListOwner.getTypeConstraints()) {
-            JetSimpleNameExpression typeParameterName = typeConstraint.getSubjectTypeParameterName();
+        for (KtTypeConstraint typeConstraint : typeParameterListOwner.getTypeConstraints()) {
+            KtSimpleNameExpression typeParameterName = typeConstraint.getSubjectTypeParameterName();
             assert typeParameterName != null;
 
-            JetTypeReference bound = typeConstraint.getBoundTypeReference();
+            KtTypeReference bound = typeConstraint.getBoundTypeReference();
             assert bound != null;
 
             decompiledParameterToBounds.put(typeParameterName.getReferencedNameAsName(), bound.getText());
         }
 
         for (int i = 0; i < decompiledParameters.size(); i++) {
-            JetTypeParameter decompiledParameter = decompiledParameters.get(i);
+            KtTypeParameter decompiledParameter = decompiledParameters.get(i);
             TypeParameterDescriptor descriptor = typeParameterDescriptors.get(i);
 
             Name name = decompiledParameter.getNameAsName();
@@ -221,9 +221,9 @@ public class MemberMatching {
             }
 
             Set<String> descriptorUpperBounds = Sets.newHashSet(ContainerUtil.map(
-                    descriptor.getUpperBounds(), new Function<JetType, String>() {
+                    descriptor.getUpperBounds(), new Function<KtType, String>() {
                 @Override
-                public String fun(JetType type) {
+                public String fun(KtType type) {
                     return DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(type);
                 }
             }));
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/CallableClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/CallableClsStubBuilder.kt
index d41f929acbe..8bb45b6c609 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/CallableClsStubBuilder.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/CallableClsStubBuilder.kt
@@ -20,7 +20,7 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.stubs.StubElement
 import org.jetbrains.kotlin.idea.decompiler.stubBuilder.FlagsToModifiers.*
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinFunctionStubImpl
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinPlaceHolderStubImpl
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinPropertyStubImpl
@@ -235,8 +235,8 @@ private class ConstructorClsStubBuilder(
 
     override fun doCreateCallableStub(parent: StubElement<out PsiElement>): StubElement<out PsiElement> {
         return if (Flags.IS_SECONDARY.get(constructorProto.flags))
-            KotlinPlaceHolderStubImpl(parent, JetStubElementTypes.SECONDARY_CONSTRUCTOR)
+            KotlinPlaceHolderStubImpl(parent, KtStubElementTypes.SECONDARY_CONSTRUCTOR)
         else
-            KotlinPlaceHolderStubImpl(parent, JetStubElementTypes.PRIMARY_CONSTRUCTOR)
+            KotlinPlaceHolderStubImpl(parent, KtStubElementTypes.PRIMARY_CONSTRUCTOR)
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt
index dfe59d02ce1..f55e19dc589 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt
@@ -19,18 +19,15 @@ package org.jetbrains.kotlin.idea.decompiler.stubBuilder
 import com.intellij.psi.PsiElement
 import com.intellij.psi.stubs.StubElement
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.idea.decompiler.stubBuilder.FlagsToModifiers.DATA
-import org.jetbrains.kotlin.idea.decompiler.stubBuilder.FlagsToModifiers.INNER
-import org.jetbrains.kotlin.idea.decompiler.stubBuilder.FlagsToModifiers.MODALITY
-import org.jetbrains.kotlin.idea.decompiler.stubBuilder.FlagsToModifiers.VISIBILITY
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.idea.decompiler.stubBuilder.FlagsToModifiers.*
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.psi.JetClassBody
-import org.jetbrains.kotlin.psi.JetDelegationSpecifierList
-import org.jetbrains.kotlin.psi.JetDelegatorToSuperClass
-import org.jetbrains.kotlin.psi.stubs.elements.JetClassElementType
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.KtClassBody
+import org.jetbrains.kotlin.psi.KtDelegationSpecifierList
+import org.jetbrains.kotlin.psi.KtDelegatorToSuperClass
+import org.jetbrains.kotlin.psi.stubs.elements.KtClassElementType
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinClassStubImpl
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinModifierListStubImpl
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinObjectStubImpl
@@ -92,10 +89,10 @@ private class ClassClsStubBuilder(
             relevantFlags.add(MODALITY)
         }
         val additionalModifiers = when (classKind) {
-            ProtoBuf.Class.Kind.ENUM_CLASS -> listOf(JetTokens.ENUM_KEYWORD)
-            ProtoBuf.Class.Kind.COMPANION_OBJECT -> listOf(JetTokens.COMPANION_KEYWORD)
-            ProtoBuf.Class.Kind.ANNOTATION_CLASS -> listOf(JetTokens.ANNOTATION_KEYWORD)
-            else -> listOf<JetModifierKeywordToken>()
+            ProtoBuf.Class.Kind.ENUM_CLASS -> listOf(KtTokens.ENUM_KEYWORD)
+            ProtoBuf.Class.Kind.COMPANION_OBJECT -> listOf(KtTokens.COMPANION_KEYWORD)
+            ProtoBuf.Class.Kind.ANNOTATION_CLASS -> listOf(KtTokens.ANNOTATION_KEYWORD)
+            else -> listOf<KtModifierKeywordToken>()
         }
         return createModifierListStubForDeclaration(parent, classProto.getFlags(), relevantFlags, additionalModifiers)
     }
@@ -120,7 +117,7 @@ private class ClassClsStubBuilder(
             }
             else -> {
                 KotlinClassStubImpl(
-                        JetClassElementType.getStubType(classKind == ProtoBuf.Class.Kind.ENUM_ENTRY),
+                        KtClassElementType.getStubType(classKind == ProtoBuf.Class.Kind.ENUM_ENTRY),
                         parentStub,
                         fqName.ref(),
                         shortName,
@@ -147,25 +144,25 @@ private class ClassClsStubBuilder(
         if (supertypeIds.isEmpty()) return
 
         val delegationSpecifierListStub =
-                KotlinPlaceHolderStubImpl<JetDelegationSpecifierList>(classOrObjectStub, JetStubElementTypes.DELEGATION_SPECIFIER_LIST)
+                KotlinPlaceHolderStubImpl<KtDelegationSpecifierList>(classOrObjectStub, KtStubElementTypes.DELEGATION_SPECIFIER_LIST)
 
         classProto.supertypes(c.typeTable).forEach { type ->
-            val superClassStub = KotlinPlaceHolderStubImpl<JetDelegatorToSuperClass>(
-                    delegationSpecifierListStub, JetStubElementTypes.DELEGATOR_SUPER_CLASS
+            val superClassStub = KotlinPlaceHolderStubImpl<KtDelegatorToSuperClass>(
+                    delegationSpecifierListStub, KtStubElementTypes.DELEGATOR_SUPER_CLASS
             )
             typeStubBuilder.createTypeReferenceStub(superClassStub, type)
         }
     }
 
     private fun createClassBodyAndMemberStubs() {
-        val classBody = KotlinPlaceHolderStubImpl<JetClassBody>(classOrObjectStub, JetStubElementTypes.CLASS_BODY)
+        val classBody = KotlinPlaceHolderStubImpl<KtClassBody>(classOrObjectStub, KtStubElementTypes.CLASS_BODY)
         createEnumEntryStubs(classBody)
         createCompanionObjectStub(classBody)
         createCallableMemberStubs(classBody)
         createInnerAndNestedClasses(classBody)
     }
 
-    private fun createCompanionObjectStub(classBody: KotlinPlaceHolderStubImpl<JetClassBody>) {
+    private fun createCompanionObjectStub(classBody: KotlinPlaceHolderStubImpl<KtClassBody>) {
         if (companionObjectName == null) {
             return
         }
@@ -174,11 +171,11 @@ private class ClassClsStubBuilder(
         createNestedClassStub(classBody, companionObjectId)
     }
 
-    private fun createEnumEntryStubs(classBody: KotlinPlaceHolderStubImpl<JetClassBody>) {
+    private fun createEnumEntryStubs(classBody: KotlinPlaceHolderStubImpl<KtClassBody>) {
         classProto.getEnumEntryList().forEach { id ->
             val name = c.nameResolver.getName(id)
             KotlinClassStubImpl(
-                    JetStubElementTypes.ENUM_ENTRY,
+                    KtStubElementTypes.ENUM_ENTRY,
                     classBody,
                     qualifiedName = c.containerFqName.child(name).ref(),
                     name = name.ref(),
@@ -191,7 +188,7 @@ private class ClassClsStubBuilder(
         }
     }
 
-    private fun createCallableMemberStubs(classBody: KotlinPlaceHolderStubImpl<JetClassBody>) {
+    private fun createCallableMemberStubs(classBody: KotlinPlaceHolderStubImpl<KtClassBody>) {
         val container = ProtoContainer(classProto, null, c.nameResolver, c.typeTable)
 
         for (secondaryConstructorProto in classProto.constructorList) {
@@ -209,7 +206,7 @@ private class ClassClsStubBuilder(
                classKind == ProtoBuf.Class.Kind.ANNOTATION_CLASS
     }
 
-    private fun createInnerAndNestedClasses(classBody: KotlinPlaceHolderStubImpl<JetClassBody>) {
+    private fun createInnerAndNestedClasses(classBody: KotlinPlaceHolderStubImpl<KtClassBody>) {
         classProto.getNestedClassNameList().forEach { id ->
             val nestedClassName = c.nameResolver.getName(id)
             if (nestedClassName != companionObjectName) {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinClsStubBuilder.kt
index 48c59ba2c92..1499779c627 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinClsStubBuilder.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinClsStubBuilder.kt
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.load.kotlin.header.isCompatibleFileFacadeKind
 import org.jetbrains.kotlin.load.kotlin.header.isCompatibleMultifileClassKind
 import org.jetbrains.kotlin.load.kotlin.header.isCompatiblePackageFacadeKind
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.serialization.deserialization.TypeTable
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
 
@@ -50,7 +50,7 @@ public open class KotlinClsStubBuilder : ClsStubBuilder() {
         return doBuildFileStub(file)
     }
 
-    fun doBuildFileStub(file: VirtualFile): PsiFileStub<JetFile>? {
+    fun doBuildFileStub(file: VirtualFile): PsiFileStub<KtFile>? {
         val kotlinBinaryClass = KotlinBinaryClassCache.getKotlinBinaryClass(file)!!
         val header = kotlinBinaryClass.getClassHeader()
         val classId = kotlinBinaryClass.getClassId()
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinJavaScriptStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinJavaScriptStubBuilder.kt
index c4a87d7657b..7db2b680049 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinJavaScriptStubBuilder.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinJavaScriptStubBuilder.kt
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.idea.decompiler.navigation.JsMetaFileUtils
 import org.jetbrains.kotlin.idea.decompiler.textBuilder.DirectoryBasedKotlinJavaScriptDataFinder
 import org.jetbrains.kotlin.idea.decompiler.textBuilder.DirectoryBasedKotlinJavaScriptMetaFileFinder
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.serialization.deserialization.NameResolver
 import org.jetbrains.kotlin.serialization.deserialization.NameResolverImpl
 import org.jetbrains.kotlin.serialization.deserialization.TypeTable
@@ -48,7 +48,7 @@ public open class KotlinJavaScriptStubBuilder : ClsStubBuilder() {
         return doBuildFileStub(file)
     }
 
-    fun doBuildFileStub(file: VirtualFile): PsiFileStub<JetFile>? {
+    fun doBuildFileStub(file: VirtualFile): PsiFileStub<KtFile>? {
         val packageFqName = JsMetaFileUtils.getPackageFqName(file)
 
         val content = file.contentsToByteArray(false)
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt
index f463830b532..04493b41049 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt
@@ -20,15 +20,15 @@ import com.google.protobuf.MessageLite
 import com.intellij.psi.PsiElement
 import com.intellij.psi.stubs.StubElement
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.stubs.KotlinUserTypeStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import org.jetbrains.kotlin.psi.stubs.impl.*
 import org.jetbrains.kotlin.serialization.Flags
 import org.jetbrains.kotlin.serialization.ProtoBuf
@@ -46,7 +46,7 @@ import java.util.*
 class TypeClsStubBuilder(private val c: ClsStubBuilderContext) {
 
     fun createTypeReferenceStub(parent: StubElement<out PsiElement>, type: Type) {
-        val typeReference = KotlinPlaceHolderStubImpl<JetTypeReference>(parent, JetStubElementTypes.TYPE_REFERENCE)
+        val typeReference = KotlinPlaceHolderStubImpl<KtTypeReference>(parent, KtStubElementTypes.TYPE_REFERENCE)
 
         val annotations = c.components.annotationLoader.loadTypeAnnotations(type, c.nameResolver).filterNot {
             val isTopLevelClass = !it.isNestedClass()
@@ -54,7 +54,7 @@ class TypeClsStubBuilder(private val c: ClsStubBuilderContext) {
         }
 
         val effectiveParent =
-                if (type.getNullable()) KotlinPlaceHolderStubImpl<JetNullableType>(typeReference, JetStubElementTypes.NULLABLE_TYPE)
+                if (type.getNullable()) KotlinPlaceHolderStubImpl<KtNullableType>(typeReference, KtStubElementTypes.NULLABLE_TYPE)
                 else typeReference
 
         fun createTypeParameterStub(name: Name) {
@@ -74,7 +74,7 @@ class TypeClsStubBuilder(private val c: ClsStubBuilderContext) {
             val id = c.nameResolver.getString(type.getFlexibleTypeCapabilitiesId())
 
             if (id == DynamicTypeCapabilities.id) {
-                KotlinPlaceHolderStubImpl<JetDynamicType>(parent, JetStubElementTypes.DYNAMIC_TYPE)
+                KotlinPlaceHolderStubImpl<KtDynamicType>(parent, KtStubElementTypes.DYNAMIC_TYPE)
                 return
             }
         }
@@ -101,12 +101,12 @@ class TypeClsStubBuilder(private val c: ClsStubBuilderContext) {
         if (typeArgumentProtoList.isEmpty()) {
             return
         }
-        val typeArgumentsListStub = KotlinPlaceHolderStubImpl<JetTypeArgumentList>(typeStub, JetStubElementTypes.TYPE_ARGUMENT_LIST)
+        val typeArgumentsListStub = KotlinPlaceHolderStubImpl<KtTypeArgumentList>(typeStub, KtStubElementTypes.TYPE_ARGUMENT_LIST)
         typeArgumentProtoList.forEach { typeArgumentProto ->
             val projectionKind = typeArgumentProto.projection.toProjectionKind()
             val typeProjection = KotlinTypeProjectionStubImpl(typeArgumentsListStub, projectionKind.ordinal())
-            if (projectionKind != JetProjectionKind.STAR) {
-                val modifierKeywordToken = projectionKind.token as? JetModifierKeywordToken
+            if (projectionKind != KtProjectionKind.STAR) {
+                val modifierKeywordToken = projectionKind.token as? KtModifierKeywordToken
                 createModifierListStub(typeProjection, modifierKeywordToken.singletonOrEmptyList())
                 createTypeReferenceStub(typeProjection, typeArgumentProto.type(c.typeTable)!!)
             }
@@ -114,23 +114,23 @@ class TypeClsStubBuilder(private val c: ClsStubBuilderContext) {
     }
 
     private fun Projection.toProjectionKind() = when (this) {
-        Projection.IN -> JetProjectionKind.IN
-        Projection.OUT -> JetProjectionKind.OUT
-        Projection.INV -> JetProjectionKind.NONE
-        Projection.STAR -> JetProjectionKind.STAR
+        Projection.IN -> KtProjectionKind.IN
+        Projection.OUT -> KtProjectionKind.OUT
+        Projection.INV -> KtProjectionKind.NONE
+        Projection.STAR -> KtProjectionKind.STAR
     }
 
     private fun createFunctionTypeStub(parent: StubElement<out PsiElement>, type: Type, isExtensionFunctionType: Boolean) {
         val typeArgumentList = type.argumentList
-        val functionType = KotlinPlaceHolderStubImpl<JetFunctionType>(parent, JetStubElementTypes.FUNCTION_TYPE)
+        val functionType = KotlinPlaceHolderStubImpl<KtFunctionType>(parent, KtStubElementTypes.FUNCTION_TYPE)
         if (isExtensionFunctionType) {
             val functionTypeReceiverStub
-                    = KotlinPlaceHolderStubImpl<JetFunctionTypeReceiver>(functionType, JetStubElementTypes.FUNCTION_TYPE_RECEIVER)
+                    = KotlinPlaceHolderStubImpl<KtFunctionTypeReceiver>(functionType, KtStubElementTypes.FUNCTION_TYPE_RECEIVER)
             val receiverTypeProto = typeArgumentList.first().type(c.typeTable)!!
             createTypeReferenceStub(functionTypeReceiverStub, receiverTypeProto)
         }
 
-        val parameterList = KotlinPlaceHolderStubImpl<JetParameterList>(functionType, JetStubElementTypes.VALUE_PARAMETER_LIST)
+        val parameterList = KotlinPlaceHolderStubImpl<KtParameterList>(functionType, KtStubElementTypes.VALUE_PARAMETER_LIST)
         val typeArgumentsWithoutReceiverAndReturnType
                 = typeArgumentList.subList(if (isExtensionFunctionType) 1 else 0, typeArgumentList.size() - 1)
         typeArgumentsWithoutReceiverAndReturnType.forEach { argument ->
@@ -150,7 +150,7 @@ class TypeClsStubBuilder(private val c: ClsStubBuilderContext) {
             parameters: List<ProtoBuf.ValueParameter>,
             container: ProtoContainer
     ) {
-        val parameterListStub = KotlinPlaceHolderStubImpl<JetParameterList>(parent, JetStubElementTypes.VALUE_PARAMETER_LIST)
+        val parameterListStub = KotlinPlaceHolderStubImpl<KtParameterList>(parent, KtStubElementTypes.VALUE_PARAMETER_LIST)
         for ((index, valueParameterProto) in parameters.withIndex()) {
             val name = c.nameResolver.getName(valueParameterProto.name)
             val parameterStub = KotlinParameterStubImpl(
@@ -163,11 +163,11 @@ class TypeClsStubBuilder(private val c: ClsStubBuilderContext) {
             )
             val varargElementType = valueParameterProto.varargElementType(c.typeTable)
             val typeProto = varargElementType ?: valueParameterProto.type(c.typeTable)
-            val modifiers = arrayListOf<JetModifierKeywordToken>()
+            val modifiers = arrayListOf<KtModifierKeywordToken>()
 
-            if (varargElementType != null) { modifiers.add(JetTokens.VARARG_KEYWORD) }
-            if (Flags.IS_CROSSINLINE.get(valueParameterProto.flags)) { modifiers.add(JetTokens.CROSSINLINE_KEYWORD) }
-            if (Flags.IS_NOINLINE.get(valueParameterProto.flags)) { modifiers.add(JetTokens.NOINLINE_KEYWORD) }
+            if (varargElementType != null) { modifiers.add(KtTokens.VARARG_KEYWORD) }
+            if (Flags.IS_CROSSINLINE.get(valueParameterProto.flags)) { modifiers.add(KtTokens.CROSSINLINE_KEYWORD) }
+            if (Flags.IS_NOINLINE.get(valueParameterProto.flags)) { modifiers.add(KtTokens.NOINLINE_KEYWORD) }
 
             val modifierList = createModifierListStub(parameterStub, modifiers)
             val parameterAnnotations = c.components.annotationLoader.loadValueParameterAnnotations(
@@ -185,7 +185,7 @@ class TypeClsStubBuilder(private val c: ClsStubBuilderContext) {
         return KotlinModifierListStubImpl(
                 parameterStub,
                 ModifierMaskUtils.computeMask { false },
-                JetStubElementTypes.MODIFIER_LIST
+                KtStubElementTypes.MODIFIER_LIST
         )
     }
 
@@ -195,7 +195,7 @@ class TypeClsStubBuilder(private val c: ClsStubBuilderContext) {
     ): List<Pair<Name, Type>> {
         if (typeParameterProtoList.isEmpty()) return listOf()
 
-        val typeParameterListStub = KotlinPlaceHolderStubImpl<JetTypeParameterList>(parent, JetStubElementTypes.TYPE_PARAMETER_LIST)
+        val typeParameterListStub = KotlinPlaceHolderStubImpl<KtTypeParameterList>(parent, KtStubElementTypes.TYPE_PARAMETER_LIST)
         val protosForTypeConstraintList = arrayListOf<Pair<Name, Type>>()
         for (proto in typeParameterProtoList) {
             val name = c.nameResolver.getName(proto.name)
@@ -225,9 +225,9 @@ class TypeClsStubBuilder(private val c: ClsStubBuilderContext) {
         if (protosForTypeConstraintList.isEmpty()) {
             return
         }
-        val typeConstraintListStub = KotlinPlaceHolderStubImpl<JetTypeConstraintList>(parent, JetStubElementTypes.TYPE_CONSTRAINT_LIST)
+        val typeConstraintListStub = KotlinPlaceHolderStubImpl<KtTypeConstraintList>(parent, KtStubElementTypes.TYPE_CONSTRAINT_LIST)
         for ((name, type) in protosForTypeConstraintList) {
-            val typeConstraintStub = KotlinPlaceHolderStubImpl<JetTypeConstraint>(typeConstraintListStub, JetStubElementTypes.TYPE_CONSTRAINT)
+            val typeConstraintStub = KotlinPlaceHolderStubImpl<KtTypeConstraint>(typeConstraintListStub, KtStubElementTypes.TYPE_CONSTRAINT)
             KotlinNameReferenceExpressionStubImpl(typeConstraintStub, name.ref())
             createTypeReferenceStub(typeConstraintStub, type)
         }
@@ -237,13 +237,13 @@ class TypeClsStubBuilder(private val c: ClsStubBuilderContext) {
             typeParameterStub: KotlinTypeParameterStubImpl,
             typeParameterProto: ProtoBuf.TypeParameter
     ) {
-        val modifiers = ArrayList<JetModifierKeywordToken>()
+        val modifiers = ArrayList<KtModifierKeywordToken>()
         when (typeParameterProto.getVariance()) {
-            Variance.IN -> modifiers.add(JetTokens.IN_KEYWORD)
-            Variance.OUT -> modifiers.add(JetTokens.OUT_KEYWORD)
+            Variance.IN -> modifiers.add(KtTokens.IN_KEYWORD)
+            Variance.OUT -> modifiers.add(KtTokens.OUT_KEYWORD)
         }
         if (typeParameterProto.getReified()) {
-            modifiers.add(JetTokens.REIFIED_KEYWORD)
+            modifiers.add(KtTokens.REIFIED_KEYWORD)
         }
         createModifierListStub(typeParameterStub, modifiers)
     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt
index 37fcc7a8af7..334a960654c 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt
@@ -22,15 +22,15 @@ import com.intellij.psi.stubs.StubElement
 import com.intellij.util.io.StringRef
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.idea.stubindex.KotlinFileStubForIde
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.stubs.KotlinUserTypeStub
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import org.jetbrains.kotlin.psi.stubs.impl.*
 import org.jetbrains.kotlin.serialization.Flags
 import org.jetbrains.kotlin.serialization.ProtoBuf
@@ -99,12 +99,12 @@ fun createFileStub(packageFqName: FqName): KotlinFileStubImpl {
 }
 
 private fun setupFileStub(fileStub: KotlinFileStubImpl, packageFqName: FqName) {
-    val packageDirectiveStub = KotlinPlaceHolderStubImpl<JetPackageDirective>(fileStub, JetStubElementTypes.PACKAGE_DIRECTIVE)
+    val packageDirectiveStub = KotlinPlaceHolderStubImpl<KtPackageDirective>(fileStub, KtStubElementTypes.PACKAGE_DIRECTIVE)
     createStubForPackageName(packageDirectiveStub, packageFqName)
-    KotlinPlaceHolderStubImpl<JetImportList>(fileStub, JetStubElementTypes.IMPORT_LIST)
+    KotlinPlaceHolderStubImpl<KtImportList>(fileStub, KtStubElementTypes.IMPORT_LIST)
 }
 
-fun createStubForPackageName(packageDirectiveStub: KotlinPlaceHolderStubImpl<JetPackageDirective>, packageFqName: FqName) {
+fun createStubForPackageName(packageDirectiveStub: KotlinPlaceHolderStubImpl<KtPackageDirective>, packageFqName: FqName) {
     val segments = packageFqName.pathSegments().toArrayList()
     val iterator = segments.listIterator(segments.size())
 
@@ -117,7 +117,7 @@ fun createStubForPackageName(packageDirectiveStub: KotlinPlaceHolderStubImpl<Jet
             }
             else -> {
                 val lastSegment = iterator.previous()
-                val receiver = KotlinPlaceHolderStubImpl<JetDotQualifiedExpression>(current, JetStubElementTypes.DOT_QUALIFIED_EXPRESSION)
+                val receiver = KotlinPlaceHolderStubImpl<KtDotQualifiedExpression>(current, KtStubElementTypes.DOT_QUALIFIED_EXPRESSION)
                 recCreateStubForPackageName(receiver)
                 KotlinNameReferenceExpressionStubImpl(receiver, lastSegment.ref())
             }
@@ -150,93 +150,93 @@ fun createStubForTypeName(typeClassId: ClassId, parent: StubElement<out PsiEleme
 
 enum class FlagsToModifiers {
     MODALITY {
-        override fun getModifiers(flags: Int): JetModifierKeywordToken {
+        override fun getModifiers(flags: Int): KtModifierKeywordToken {
             val modality = Flags.MODALITY.get(flags)
             return when (modality) {
-                ProtoBuf.Modality.ABSTRACT -> JetTokens.ABSTRACT_KEYWORD
-                ProtoBuf.Modality.FINAL -> JetTokens.FINAL_KEYWORD
-                ProtoBuf.Modality.OPEN -> JetTokens.OPEN_KEYWORD
-                ProtoBuf.Modality.SEALED -> JetTokens.SEALED_KEYWORD
+                ProtoBuf.Modality.ABSTRACT -> KtTokens.ABSTRACT_KEYWORD
+                ProtoBuf.Modality.FINAL -> KtTokens.FINAL_KEYWORD
+                ProtoBuf.Modality.OPEN -> KtTokens.OPEN_KEYWORD
+                ProtoBuf.Modality.SEALED -> KtTokens.SEALED_KEYWORD
                 null -> throw IllegalStateException("Unexpected modality: null")
             }
         }
     },
 
     VISIBILITY {
-        override fun getModifiers(flags: Int): JetModifierKeywordToken? {
+        override fun getModifiers(flags: Int): KtModifierKeywordToken? {
             val visibility = Flags.VISIBILITY.get(flags)
             return when (visibility) {
-                ProtoBuf.Visibility.PRIVATE, ProtoBuf.Visibility.PRIVATE_TO_THIS -> JetTokens.PRIVATE_KEYWORD
-                ProtoBuf.Visibility.INTERNAL -> JetTokens.INTERNAL_KEYWORD
-                ProtoBuf.Visibility.PROTECTED -> JetTokens.PROTECTED_KEYWORD
-                ProtoBuf.Visibility.PUBLIC -> JetTokens.PUBLIC_KEYWORD
+                ProtoBuf.Visibility.PRIVATE, ProtoBuf.Visibility.PRIVATE_TO_THIS -> KtTokens.PRIVATE_KEYWORD
+                ProtoBuf.Visibility.INTERNAL -> KtTokens.INTERNAL_KEYWORD
+                ProtoBuf.Visibility.PROTECTED -> KtTokens.PROTECTED_KEYWORD
+                ProtoBuf.Visibility.PUBLIC -> KtTokens.PUBLIC_KEYWORD
                 else -> throw IllegalStateException("Unexpected visibility: $visibility")
             }
         }
     },
 
     INNER {
-        override fun getModifiers(flags: Int): JetModifierKeywordToken? {
-            return if (Flags.IS_INNER.get(flags)) JetTokens.INNER_KEYWORD else null
+        override fun getModifiers(flags: Int): KtModifierKeywordToken? {
+            return if (Flags.IS_INNER.get(flags)) KtTokens.INNER_KEYWORD else null
         }
     },
 
     CONST {
-        override fun getModifiers(flags: Int): JetModifierKeywordToken? {
-            return if (Flags.IS_CONST.get(flags)) JetTokens.CONST_KEYWORD else null
+        override fun getModifiers(flags: Int): KtModifierKeywordToken? {
+            return if (Flags.IS_CONST.get(flags)) KtTokens.CONST_KEYWORD else null
         }
     },
 
     LATEINIT {
-        override fun getModifiers(flags: Int): JetModifierKeywordToken? {
-            return if (Flags.IS_LATEINIT.get(flags)) JetTokens.LATEINIT_KEYWORD else null
+        override fun getModifiers(flags: Int): KtModifierKeywordToken? {
+            return if (Flags.IS_LATEINIT.get(flags)) KtTokens.LATEINIT_KEYWORD else null
         }
     },
 
     OPERATOR {
-        override fun getModifiers(flags: Int): JetModifierKeywordToken? {
-            return if (Flags.IS_OPERATOR.get(flags)) JetTokens.OPERATOR_KEYWORD else null
+        override fun getModifiers(flags: Int): KtModifierKeywordToken? {
+            return if (Flags.IS_OPERATOR.get(flags)) KtTokens.OPERATOR_KEYWORD else null
         }
     },
 
     INFIX {
-        override fun getModifiers(flags: Int): JetModifierKeywordToken? {
-            return if (Flags.IS_INFIX.get(flags)) JetTokens.INFIX_KEYWORD else null
+        override fun getModifiers(flags: Int): KtModifierKeywordToken? {
+            return if (Flags.IS_INFIX.get(flags)) KtTokens.INFIX_KEYWORD else null
         }
     },
 
     DATA {
-        override fun getModifiers(flags: Int): JetModifierKeywordToken? {
-            return if (Flags.IS_DATA.get(flags)) JetTokens.DATA_KEYWORD else null
+        override fun getModifiers(flags: Int): KtModifierKeywordToken? {
+            return if (Flags.IS_DATA.get(flags)) KtTokens.DATA_KEYWORD else null
         }
     },
 
     EXTERNAL_FUN {
-        override fun getModifiers(flags: Int): JetModifierKeywordToken? {
-            return if (Flags.IS_EXTERNAL_FUNCTION.get(flags)) JetTokens.EXTERNAL_KEYWORD else null
+        override fun getModifiers(flags: Int): KtModifierKeywordToken? {
+            return if (Flags.IS_EXTERNAL_FUNCTION.get(flags)) KtTokens.EXTERNAL_KEYWORD else null
         }
     },
 
     INLINE {
-        override fun getModifiers(flags: Int): JetModifierKeywordToken? {
-            return if (Flags.IS_INLINE.get(flags)) JetTokens.INLINE_KEYWORD else null
+        override fun getModifiers(flags: Int): KtModifierKeywordToken? {
+            return if (Flags.IS_INLINE.get(flags)) KtTokens.INLINE_KEYWORD else null
         }
     },
 
     TAILREC {
-        override fun getModifiers(flags: Int): JetModifierKeywordToken? {
-            return if (Flags.IS_TAILREC.get(flags)) JetTokens.TAILREC_KEYWORD else null
+        override fun getModifiers(flags: Int): KtModifierKeywordToken? {
+            return if (Flags.IS_TAILREC.get(flags)) KtTokens.TAILREC_KEYWORD else null
         }
     };
 
-    abstract fun getModifiers(flags: Int): JetModifierKeywordToken?
+    abstract fun getModifiers(flags: Int): KtModifierKeywordToken?
 }
 
 fun createModifierListStubForDeclaration(
         parent: StubElement<out PsiElement>,
         flags: Int,
         flagsToTranslate: List<FlagsToModifiers> = listOf(),
-        additionalModifiers: List<JetModifierKeywordToken> = listOf()
+        additionalModifiers: List<KtModifierKeywordToken> = listOf()
 ): KotlinModifierListStubImpl {
     assert(flagsToTranslate.isNotEmpty())
 
@@ -246,7 +246,7 @@ fun createModifierListStubForDeclaration(
 
 fun createModifierListStub(
         parent: StubElement<out PsiElement>,
-        modifiers: Collection<JetModifierKeywordToken>
+        modifiers: Collection<KtModifierKeywordToken>
 ): KotlinModifierListStubImpl? {
     if (modifiers.isEmpty()) {
         return null
@@ -254,7 +254,7 @@ fun createModifierListStub(
     return KotlinModifierListStubImpl(
             parent,
             ModifierMaskUtils.computeMask { it in modifiers },
-            JetStubElementTypes.MODIFIER_LIST
+            KtStubElementTypes.MODIFIER_LIST
     )
 }
 
@@ -278,8 +278,8 @@ fun createTargetedAnnotationStubs(
         if (target != null) {
             KotlinAnnotationUseSiteTargetStubImpl(annotationEntryStubImpl, StringRef.fromString(target.name())!!)
         }
-        val constructorCallee = KotlinPlaceHolderStubImpl<JetConstructorCalleeExpression>(annotationEntryStubImpl, JetStubElementTypes.CONSTRUCTOR_CALLEE)
-        val typeReference = KotlinPlaceHolderStubImpl<JetTypeReference>(constructorCallee, JetStubElementTypes.TYPE_REFERENCE)
+        val constructorCallee = KotlinPlaceHolderStubImpl<KtConstructorCalleeExpression>(annotationEntryStubImpl, KtStubElementTypes.CONSTRUCTOR_CALLEE)
+        val typeReference = KotlinPlaceHolderStubImpl<KtTypeReference>(constructorCallee, KtStubElementTypes.TYPE_REFERENCE)
         createStubForTypeName(annotationClassId, typeReference)
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/missingDependencies.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/missingDependencies.kt
index 20d214f52e4..3e8a3a7d962 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/missingDependencies.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/missingDependencies.kt
@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.descriptors.impl.PackageFragmentDescriptorImpl
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
+import org.jetbrains.kotlin.resolve.scopes.KtScope
+import org.jetbrains.kotlin.resolve.scopes.KtScopeImpl
 import org.jetbrains.kotlin.types.ErrorUtils.createErrorType
 import org.jetbrains.kotlin.types.TypeProjection
 import org.jetbrains.kotlin.types.TypeSubstitution
@@ -35,12 +35,12 @@ import org.jetbrains.kotlin.utils.Printer
 
 private class PackageFragmentWithMissingDependencies(override val fqName: FqName, moduleDescriptor: ModuleDescriptor) :
         PackageFragmentDescriptorImpl(moduleDescriptor, fqName) {
-    override fun getMemberScope(): JetScope {
+    override fun getMemberScope(): KtScope {
         return ScopeWithMissingDependencies(fqName, this)
     }
 }
 
-private class ScopeWithMissingDependencies(val fqName: FqName, val containing: DeclarationDescriptor) : JetScopeImpl() {
+private class ScopeWithMissingDependencies(val fqName: FqName, val containing: DeclarationDescriptor) : KtScopeImpl() {
     override fun getContainingDeclaration(): DeclarationDescriptor {
         return containing
     }
@@ -74,7 +74,7 @@ private class MissingDependencyErrorClassDescriptor(
         val emptyConstructor = ConstructorDescriptorImpl.create(this, Annotations.EMPTY, true, SourceElement.NO_SOURCE)
         emptyConstructor.initialize(listOf(), listOf(), Visibilities.DEFAULT_VISIBILITY)
         emptyConstructor.setReturnType(createErrorType("<ERROR RETURN TYPE>"))
-        initialize(JetScope.Empty, setOf(emptyConstructor), emptyConstructor)
+        initialize(KtScope.Empty, setOf(emptyConstructor), emptyConstructor)
     }
 
     override fun substitute(substitutor: TypeSubstitutor) = this
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/JetFindUsagesProvider.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/JetFindUsagesProvider.kt
index eb0090b63f0..f7549e4ad0a 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/JetFindUsagesProvider.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/JetFindUsagesProvider.kt
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.psi.*
 
 public class JetFindUsagesProvider : FindUsagesProvider {
     public override fun canFindUsagesFor(psiElement: PsiElement): Boolean =
-            psiElement is JetNamedDeclaration
+            psiElement is KtNamedDeclaration
 
     public override fun getWordsScanner() = null
 
@@ -32,14 +32,14 @@ public class JetFindUsagesProvider : FindUsagesProvider {
 
     public override fun getType(element: PsiElement): String {
         return when(element) {
-            is JetNamedFunction -> "function"
-            is JetClass -> "class"
-            is JetParameter -> "parameter"
-            is JetProperty -> if (element.isLocal()) "variable" else "property"
-            is JetMultiDeclarationEntry -> "variable"
-            is JetTypeParameter -> "type parameter"
-            is JetSecondaryConstructor -> "constructor"
-            is JetObjectDeclaration -> "object"
+            is KtNamedFunction -> "function"
+            is KtClass -> "class"
+            is KtParameter -> "parameter"
+            is KtProperty -> if (element.isLocal()) "variable" else "property"
+            is KtMultiDeclarationEntry -> "variable"
+            is KtTypeParameter -> "type parameter"
+            is KtSecondaryConstructor -> "constructor"
+            is KtObjectDeclaration -> "object"
             else -> ""
         }
     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt
index b462e7c2f1b..5fe26ce85b4 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.findUsages.UsageTypeEnum.*
 import org.jetbrains.kotlin.idea.references.*
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypeAndBranch
@@ -33,31 +33,31 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 public object UsageTypeUtils {
     public fun getUsageType(element: PsiElement?): UsageTypeEnum? {
         when (element) {
-            is JetForExpression -> return IMPLICIT_ITERATION
-            is JetMultiDeclaration -> return READ
-            is JetPropertyDelegate -> return PROPERTY_DELEGATION
-            is JetStringTemplateExpression -> return USAGE_IN_STRING_LITERAL
+            is KtForExpression -> return IMPLICIT_ITERATION
+            is KtMultiDeclaration -> return READ
+            is KtPropertyDelegate -> return PROPERTY_DELEGATION
+            is KtStringTemplateExpression -> return USAGE_IN_STRING_LITERAL
         }
 
-        val refExpr = element?.getNonStrictParentOfType<JetReferenceExpression>()
+        val refExpr = element?.getNonStrictParentOfType<KtReferenceExpression>()
         if (refExpr == null) return null
 
         val context = refExpr.analyze()
 
         fun getCommonUsageType(): UsageTypeEnum? {
             return when {
-                refExpr.getNonStrictParentOfType<JetImportDirective>() != null ->
+                refExpr.getNonStrictParentOfType<KtImportDirective>() != null ->
                     CLASS_IMPORT
-                refExpr.getParentOfTypeAndBranch<JetCallableReferenceExpression>(){ getCallableReference() } != null ->
+                refExpr.getParentOfTypeAndBranch<KtCallableReferenceExpression>(){ getCallableReference() } != null ->
                     CALLABLE_REFERENCE
                 else -> null
             }
         }
 
         fun getClassUsageType(): UsageTypeEnum? {
-            if (refExpr.getNonStrictParentOfType<JetTypeProjection>() != null) return TYPE_PARAMETER
+            if (refExpr.getNonStrictParentOfType<KtTypeProjection>() != null) return TYPE_PARAMETER
 
-            val property = refExpr.getNonStrictParentOfType<JetProperty>()
+            val property = refExpr.getNonStrictParentOfType<KtProperty>()
             if (property != null) {
                 when {
                     property.getTypeReference().isAncestor(refExpr) ->
@@ -68,7 +68,7 @@ public object UsageTypeUtils {
                 }
             }
 
-            val function = refExpr.getNonStrictParentOfType<JetFunction>()
+            val function = refExpr.getNonStrictParentOfType<KtFunction>()
             if (function != null) {
                 when {
                     function.getTypeReference().isAncestor(refExpr) ->
@@ -79,40 +79,40 @@ public object UsageTypeUtils {
             }
 
             return when {
-                refExpr.getParentOfTypeAndBranch<JetTypeParameter>(){ getExtendsBound() } != null
-                || refExpr.getParentOfTypeAndBranch<JetTypeConstraint>(){ getBoundTypeReference() } != null ->
+                refExpr.getParentOfTypeAndBranch<KtTypeParameter>(){ getExtendsBound() } != null
+                || refExpr.getParentOfTypeAndBranch<KtTypeConstraint>(){ getBoundTypeReference() } != null ->
                     TYPE_CONSTRAINT
 
-                refExpr is JetDelegationSpecifier
-                || refExpr.getParentOfTypeAndBranch<JetDelegationSpecifier>(){ getTypeReference() } != null ->
+                refExpr is KtDelegationSpecifier
+                || refExpr.getParentOfTypeAndBranch<KtDelegationSpecifier>(){ getTypeReference() } != null ->
                     SUPER_TYPE
 
-                refExpr.getParentOfTypeAndBranch<JetTypedef>(){ getTypeReference() } != null ->
+                refExpr.getParentOfTypeAndBranch<KtTypedef>(){ getTypeReference() } != null ->
                     TYPE_DEFINITION
 
-                refExpr.getParentOfTypeAndBranch<JetParameter>(){ getTypeReference() } != null ->
+                refExpr.getParentOfTypeAndBranch<KtParameter>(){ getTypeReference() } != null ->
                     VALUE_PARAMETER_TYPE
 
-                refExpr.getParentOfTypeAndBranch<JetIsExpression>(){ getTypeReference() } != null
-                || refExpr.getParentOfTypeAndBranch<JetWhenConditionIsPattern>(){ getTypeReference() } != null ->
+                refExpr.getParentOfTypeAndBranch<KtIsExpression>(){ getTypeReference() } != null
+                || refExpr.getParentOfTypeAndBranch<KtWhenConditionIsPattern>(){ getTypeReference() } != null ->
                     IS
 
-                with(refExpr.getParentOfTypeAndBranch<JetBinaryExpressionWithTypeRHS>(){ getRight() }) {
+                with(refExpr.getParentOfTypeAndBranch<KtBinaryExpressionWithTypeRHS>(){ getRight() }) {
                     val opType = this?.getOperationReference()?.getReferencedNameElementType()
-                    opType == JetTokens.AS_KEYWORD || opType == JetTokens.AS_SAFE
+                    opType == KtTokens.AS_KEYWORD || opType == KtTokens.AS_SAFE
                 } ->
                     CLASS_CAST_TO
 
-                with(refExpr.getNonStrictParentOfType<JetDotQualifiedExpression>()) {
+                with(refExpr.getNonStrictParentOfType<KtDotQualifiedExpression>()) {
                     if (this == null) false
                     else if (getReceiverExpression() == refExpr) true
                     else
                         getSelectorExpression() == refExpr
-                        && getParentOfTypeAndBranch<JetDotQualifiedExpression>(strict = true) { getReceiverExpression() } != null
+                        && getParentOfTypeAndBranch<KtDotQualifiedExpression>(strict = true) { getReceiverExpression() } != null
                 } ->
                     CLASS_OBJECT_ACCESS
 
-                refExpr.getParentOfTypeAndBranch<JetSuperExpression>(){ getSuperTypeQualifier() } != null ->
+                refExpr.getParentOfTypeAndBranch<KtSuperExpression>(){ getSuperTypeQualifier() } != null ->
                     SUPER_TYPE_QUALIFIER
 
                 else -> null
@@ -120,13 +120,13 @@ public object UsageTypeUtils {
         }
 
         fun getVariableUsageType(): UsageTypeEnum? {
-            if (refExpr.getParentOfTypeAndBranch<JetDelegatorByExpressionSpecifier>(){ getDelegateExpression() } != null) {
+            if (refExpr.getParentOfTypeAndBranch<KtDelegatorByExpressionSpecifier>(){ getDelegateExpression() } != null) {
                 return DELEGATE
             }
 
-            if (refExpr.getParent() is JetValueArgumentName) return NAMED_ARGUMENT
+            if (refExpr.getParent() is KtValueArgumentName) return NAMED_ARGUMENT
 
-            val dotQualifiedExpression = refExpr.getNonStrictParentOfType<JetDotQualifiedExpression>()
+            val dotQualifiedExpression = refExpr.getNonStrictParentOfType<KtDotQualifiedExpression>()
 
             if (dotQualifiedExpression != null) {
                 val parent = dotQualifiedExpression.getParent()
@@ -134,7 +134,7 @@ public object UsageTypeUtils {
                     dotQualifiedExpression.getReceiverExpression().isAncestor(refExpr) ->
                         return RECEIVER
 
-                    parent is JetDotQualifiedExpression && parent.getReceiverExpression().isAncestor(refExpr) ->
+                    parent is KtDotQualifiedExpression && parent.getReceiverExpression().isAncestor(refExpr) ->
                         return RECEIVER
                 }
             }
@@ -147,32 +147,32 @@ public object UsageTypeUtils {
 
         fun getFunctionUsageType(descriptor: FunctionDescriptor): UsageTypeEnum? {
             when (refExpr.mainReference) {
-                is JetArrayAccessReference -> {
+                is KtArrayAccessReference -> {
                     return when {
                         context[BindingContext.INDEXED_LVALUE_GET, refExpr] != null -> IMPLICIT_GET
                         context[BindingContext.INDEXED_LVALUE_SET, refExpr] != null -> IMPLICIT_SET
                         else -> null
                     }
                 }
-                is JetInvokeFunctionReference -> return IMPLICIT_INVOKE
+                is KtInvokeFunctionReference -> return IMPLICIT_INVOKE
             }
 
             return when {
-                refExpr.getParentOfTypeAndBranch<JetDelegationSpecifier>(){ getTypeReference() } != null ->
+                refExpr.getParentOfTypeAndBranch<KtDelegationSpecifier>(){ getTypeReference() } != null ->
                     SUPER_TYPE
 
                 descriptor is ConstructorDescriptor
-                && refExpr.getParentOfTypeAndBranch<JetAnnotationEntry>(){ getTypeReference() } != null ->
+                && refExpr.getParentOfTypeAndBranch<KtAnnotationEntry>(){ getTypeReference() } != null ->
                     ANNOTATION
 
-                with(refExpr.getParentOfTypeAndBranch<JetCallExpression>(){ getCalleeExpression() }) {
-                    this?.getCalleeExpression() is JetSimpleNameExpression
+                with(refExpr.getParentOfTypeAndBranch<KtCallExpression>(){ getCalleeExpression() }) {
+                    this?.getCalleeExpression() is KtSimpleNameExpression
                 } ->
                     if (descriptor is ConstructorDescriptor) CLASS_NEW_OPERATOR else FUNCTION_CALL
 
-                refExpr.getParentOfTypeAndBranch<JetBinaryExpression>(){ getOperationReference() } != null,
-                refExpr.getParentOfTypeAndBranch<JetUnaryExpression>(){ getOperationReference() } != null,
-                refExpr.getParentOfTypeAndBranch<JetWhenConditionInRange>(){ getOperationReference() } != null ->
+                refExpr.getParentOfTypeAndBranch<KtBinaryExpression>(){ getOperationReference() } != null,
+                refExpr.getParentOfTypeAndBranch<KtUnaryExpression>(){ getOperationReference() } != null,
+                refExpr.getParentOfTypeAndBranch<KtWhenConditionInRange>(){ getOperationReference() } != null ->
                     FUNCTION_CALL
 
                 else -> null
@@ -181,8 +181,8 @@ public object UsageTypeUtils {
 
         fun getPackageUsageType(): UsageTypeEnum? {
             return when {
-                refExpr.getNonStrictParentOfType<JetPackageDirective>() != null -> PACKAGE_DIRECTIVE
-                refExpr.getNonStrictParentOfType<JetQualifiedExpression>() != null -> PACKAGE_MEMBER_ACCESS
+                refExpr.getNonStrictParentOfType<KtPackageDirective>() != null -> PACKAGE_DIRECTIVE
+                refExpr.getNonStrictParentOfType<KtQualifiedExpression>() != null -> PACKAGE_MEMBER_ACCESS
                 else -> getClassUsageType()
             }
         }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DebugInfoAnnotator.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DebugInfoAnnotator.java
index b69a99d1308..fb5209d881f 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DebugInfoAnnotator.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DebugInfoAnnotator.java
@@ -25,9 +25,9 @@ import org.jetbrains.kotlin.checkers.DebugInfoUtil;
 import org.jetbrains.kotlin.idea.actions.internal.KotlinInternalMode;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil;
-import org.jetbrains.kotlin.psi.JetCodeFragment;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetReferenceExpression;
+import org.jetbrains.kotlin.psi.KtCodeFragment;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtReferenceExpression;
 import org.jetbrains.kotlin.resolve.BindingContext;
 
 /**
@@ -45,26 +45,26 @@ public class DebugInfoAnnotator implements Annotator {
             return;
         }
 
-        if (element instanceof JetFile && !(element instanceof JetCodeFragment)) {
-            JetFile file = (JetFile) element;
+        if (element instanceof KtFile && !(element instanceof KtCodeFragment)) {
+            KtFile file = (KtFile) element;
             try {
                 BindingContext bindingContext = ResolutionUtils.analyzeFully(file);
                 DebugInfoUtil.markDebugAnnotations(file, bindingContext, new DebugInfoUtil.DebugInfoReporter() {
                     @Override
-                    public void reportElementWithErrorType(@NotNull JetReferenceExpression expression) {
+                    public void reportElementWithErrorType(@NotNull KtReferenceExpression expression) {
                         holder.createErrorAnnotation(expression, "[DEBUG] Resolved to error element")
                                 .setTextAttributes(JetHighlightingColors.RESOLVED_TO_ERROR);
                     }
 
                     @Override
-                    public void reportMissingUnresolved(@NotNull JetReferenceExpression expression) {
+                    public void reportMissingUnresolved(@NotNull KtReferenceExpression expression) {
                         holder.createErrorAnnotation(expression,
                                                      "[DEBUG] Reference is not resolved to anything, but is not marked unresolved")
                                 .setTextAttributes(JetHighlightingColors.DEBUG_INFO);
                     }
 
                     @Override
-                    public void reportUnresolvedWithTarget(@NotNull JetReferenceExpression expression, @NotNull String target) {
+                    public void reportUnresolvedWithTarget(@NotNull KtReferenceExpression expression, @NotNull String target) {
                         holder.createErrorAnnotation(expression, "[DEBUG] Reference marked as unresolved is actually resolved to " + target)
                                 .setTextAttributes(JetHighlightingColors.DEBUG_INFO);
                     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DuplicateJvmSignatureAnnotator.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DuplicateJvmSignatureAnnotator.java
index 2d4def1e6e8..c05b3a529d0 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DuplicateJvmSignatureAnnotator.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DuplicateJvmSignatureAnnotator.java
@@ -27,22 +27,22 @@ import org.jetbrains.kotlin.idea.caches.resolve.GetModuleInfoKt;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector;
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil;
-import org.jetbrains.kotlin.psi.JetDeclaration;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtElement;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
 
 public class DuplicateJvmSignatureAnnotator implements Annotator {
     @Override
     public void annotate(@NotNull PsiElement element, @NotNull AnnotationHolder holder) {
-        if (!(element instanceof JetFile) && !(element instanceof JetDeclaration)) return;
+        if (!(element instanceof KtFile) && !(element instanceof KtDeclaration)) return;
         if (!ProjectRootsUtil.isInProjectSource(element)) return;
 
         PsiFile file = element.getContainingFile();
-        if (!(file instanceof JetFile) || TargetPlatformDetector.getPlatform((JetFile) file) != JvmPlatform.INSTANCE$) return;
+        if (!(file instanceof KtFile) || TargetPlatformDetector.getPlatform((KtFile) file) != JvmPlatform.INSTANCE$) return;
 
-        Diagnostics otherDiagnostics = ResolutionUtils.analyzeFully((JetElement) element).getDiagnostics();
+        Diagnostics otherDiagnostics = ResolutionUtils.analyzeFully((KtElement) element).getDiagnostics();
         GlobalSearchScope moduleScope = GetModuleInfoKt.getModuleInfo(element).contentScope();
         Diagnostics diagnostics = DuplicateJvmSignatureUtilKt.getJvmSignatureDiagnostics(element, otherDiagnostics, moduleScope);
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/FunctionsHighlightingVisitor.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/FunctionsHighlightingVisitor.java
index 19dbb66b3f7..56ba4dbaea3 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/FunctionsHighlightingVisitor.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/FunctionsHighlightingVisitor.java
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.tasks.DynamicCallsKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 
 public class FunctionsHighlightingVisitor extends AfterAnalysisHighlightingVisitor {
@@ -37,7 +37,7 @@ public class FunctionsHighlightingVisitor extends AfterAnalysisHighlightingVisit
     }
 
     @Override
-    public void visitNamedFunction(@NotNull JetNamedFunction function) {
+    public void visitNamedFunction(@NotNull KtNamedFunction function) {
         PsiElement nameIdentifier = function.getNameIdentifier();
         if (nameIdentifier != null) {
             NameHighlighter.highlightName(holder, nameIdentifier, JetHighlightingColors.FUNCTION_DECLARATION);
@@ -47,13 +47,13 @@ public class FunctionsHighlightingVisitor extends AfterAnalysisHighlightingVisit
     }
 
     @Override
-    public void visitDelegationToSuperCallSpecifier(@NotNull JetDelegatorToSuperCall call) {
-        JetConstructorCalleeExpression calleeExpression = call.getCalleeExpression();
-        JetTypeReference typeRef = calleeExpression.getTypeReference();
+    public void visitDelegationToSuperCallSpecifier(@NotNull KtDelegatorToSuperCall call) {
+        KtConstructorCalleeExpression calleeExpression = call.getCalleeExpression();
+        KtTypeReference typeRef = calleeExpression.getTypeReference();
         if (typeRef != null) {
-            JetTypeElement typeElement = typeRef.getTypeElement();
-            if (typeElement instanceof JetUserType) {
-                JetSimpleNameExpression nameExpression = ((JetUserType)typeElement).getReferenceExpression();
+            KtTypeElement typeElement = typeRef.getTypeElement();
+            if (typeElement instanceof KtUserType) {
+                KtSimpleNameExpression nameExpression = ((KtUserType)typeElement).getReferenceExpression();
                 if (nameExpression != null) {
                     NameHighlighter.highlightName(holder, nameExpression, JetHighlightingColors.CONSTRUCTOR_CALL);
                 }
@@ -63,10 +63,10 @@ public class FunctionsHighlightingVisitor extends AfterAnalysisHighlightingVisit
     }
 
     @Override
-    public void visitCallExpression(@NotNull JetCallExpression expression) {
-        JetExpression callee = expression.getCalleeExpression();
+    public void visitCallExpression(@NotNull KtCallExpression expression) {
+        KtExpression callee = expression.getCalleeExpression();
         ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(expression, bindingContext);
-        if (callee instanceof JetReferenceExpression && resolvedCall != null) {
+        if (callee instanceof KtReferenceExpression && resolvedCall != null) {
             CallableDescriptor calleeDescriptor = resolvedCall.getResultingDescriptor();
 
             if (DynamicCallsKt.isDynamic(calleeDescriptor)) {
@@ -103,13 +103,13 @@ public class FunctionsHighlightingVisitor extends AfterAnalysisHighlightingVisit
             return false;
         }
 
-        JetType defaultType = ((ClassDescriptor) parent).getDefaultType();
+        KtType defaultType = ((ClassDescriptor) parent).getDefaultType();
 
         if (KotlinBuiltIns.isFunctionOrExtensionFunctionType(defaultType)) {
             return true;
         }
 
-        for (JetType supertype : TypeUtils.getAllSupertypes(defaultType)) {
+        for (KtType supertype : TypeUtils.getAllSupertypes(defaultType)) {
             if (KotlinBuiltIns.isFunctionOrExtensionFunctionType(supertype)) {
                 return true;
             }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/HighlightingVisitor.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/HighlightingVisitor.java
index b53d7f0c768..6cb6f57f433 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/HighlightingVisitor.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/HighlightingVisitor.java
@@ -17,9 +17,9 @@
 package org.jetbrains.kotlin.idea.highlighter;
 
 import com.intellij.lang.annotation.AnnotationHolder;
-import org.jetbrains.kotlin.psi.JetVisitorVoid;
+import org.jetbrains.kotlin.psi.KtVisitorVoid;
 
-public abstract class HighlightingVisitor extends JetVisitorVoid {
+public abstract class HighlightingVisitor extends KtVisitorVoid {
     protected AnnotationHolder holder;
 
     protected HighlightingVisitor(AnnotationHolder holder) {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/HtmlTabledDescriptorRenderer.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/HtmlTabledDescriptorRenderer.java
index 37401032643..fcab2300152 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/HtmlTabledDescriptorRenderer.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/HtmlTabledDescriptorRenderer.java
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.diagnostics.rendering.TabledDescriptorRenderer.Table
 import org.jetbrains.kotlin.idea.highlighter.renderersUtil.RenderersUtilKt;
 import org.jetbrains.kotlin.renderer.*;
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collections;
 import java.util.Iterator;
@@ -43,7 +43,7 @@ public class HtmlTabledDescriptorRenderer extends TabledDescriptorRenderer {
 
     @NotNull
     @Override
-    public Renderer<JetType> getTypeRenderer() {
+    public Renderer<KtType> getTypeRenderer() {
         return IdeRenderers.HTML_RENDER_TYPE;
     }
 
@@ -117,8 +117,8 @@ public class HtmlTabledDescriptorRenderer extends TabledDescriptorRenderer {
     }
 
     private void renderFunctionArguments(
-            @Nullable JetType receiverType,
-            @NotNull List<JetType> argumentTypes,
+            @Nullable KtType receiverType,
+            @NotNull List<KtType> argumentTypes,
             Predicate<ConstraintPosition> isErrorPosition,
             StringBuilder result
     ) {
@@ -141,8 +141,8 @@ public class HtmlTabledDescriptorRenderer extends TabledDescriptorRenderer {
 
         td(result, RenderersUtilKt.renderStrong("("));
         int i = 0;
-        for (Iterator<JetType> iterator = argumentTypes.iterator(); iterator.hasNext(); ) {
-            JetType argumentType = iterator.next();
+        for (Iterator<KtType> iterator = argumentTypes.iterator(); iterator.hasNext(); ) {
+            KtType argumentType = iterator.next();
             boolean error = false;
             if (isErrorPosition.apply(VALUE_PARAMETER_POSITION.position(i))) {
                 error = true;
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt
index f8be48844a6..6c9fa4a12d6 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.resolve.MemberComparator
 import org.jetbrains.kotlin.resolve.calls.inference.InferenceErrorData
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ConflictingJvmDeclarationsData
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 public object IdeRenderers {
     public val HTML_AMBIGUOUS_CALLS: Renderer<Collection<ResolvedCall<*>>> = Renderer {
@@ -36,7 +36,7 @@ public object IdeRenderers {
                 .joinToString("") { "<li>" + DescriptorRenderer.HTML.render(it) + "</li>" }
     }
 
-    public val HTML_RENDER_TYPE: Renderer<JetType> = Renderer {
+    public val HTML_RENDER_TYPE: Renderer<KtType> = Renderer {
         DescriptorRenderer.HTML.renderType(it)
     }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetHighlighter.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetHighlighter.java
index 1af8042c365..f122723110d 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetHighlighter.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetHighlighter.java
@@ -24,7 +24,7 @@ import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.kdoc.lexer.KDocTokens;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -49,45 +49,45 @@ public class JetHighlighter extends SyntaxHighlighterBase {
         keys1 = new HashMap<IElementType, TextAttributesKey>();
         keys2 = new HashMap<IElementType, TextAttributesKey>();
 
-        fillMap(keys1, JetTokens.KEYWORDS, JetHighlightingColors.KEYWORD);
+        fillMap(keys1, KtTokens.KEYWORDS, JetHighlightingColors.KEYWORD);
 
-        keys1.put(JetTokens.AS_SAFE, JetHighlightingColors.KEYWORD);
-        keys1.put(JetTokens.INTEGER_LITERAL, JetHighlightingColors.NUMBER);
-        keys1.put(JetTokens.FLOAT_LITERAL, JetHighlightingColors.NUMBER);
+        keys1.put(KtTokens.AS_SAFE, JetHighlightingColors.KEYWORD);
+        keys1.put(KtTokens.INTEGER_LITERAL, JetHighlightingColors.NUMBER);
+        keys1.put(KtTokens.FLOAT_LITERAL, JetHighlightingColors.NUMBER);
 
         fillMap(keys1,
-                TokenSet.andNot(JetTokens.OPERATIONS,
+                TokenSet.andNot(KtTokens.OPERATIONS,
                                 TokenSet.orSet(
-                                        TokenSet.create(JetTokens.IDENTIFIER, JetTokens.AT),
-                                        JetTokens.KEYWORDS)),
+                                        TokenSet.create(KtTokens.IDENTIFIER, KtTokens.AT),
+                                        KtTokens.KEYWORDS)),
                 JetHighlightingColors.OPERATOR_SIGN);
 
-        keys1.put(JetTokens.LPAR, JetHighlightingColors.PARENTHESIS);
-        keys1.put(JetTokens.RPAR, JetHighlightingColors.PARENTHESIS);
-        keys1.put(JetTokens.LBRACE, JetHighlightingColors.BRACES);
-        keys1.put(JetTokens.RBRACE, JetHighlightingColors.BRACES);
-        keys1.put(JetTokens.LBRACKET, JetHighlightingColors.BRACKETS);
-        keys1.put(JetTokens.RBRACKET, JetHighlightingColors.BRACKETS);
-        keys1.put(JetTokens.COMMA, JetHighlightingColors.COMMA);
-        keys1.put(JetTokens.SEMICOLON, JetHighlightingColors.SEMICOLON);
-        keys1.put(JetTokens.DOT, JetHighlightingColors.DOT);
-        keys1.put(JetTokens.ARROW, JetHighlightingColors.ARROW);
+        keys1.put(KtTokens.LPAR, JetHighlightingColors.PARENTHESIS);
+        keys1.put(KtTokens.RPAR, JetHighlightingColors.PARENTHESIS);
+        keys1.put(KtTokens.LBRACE, JetHighlightingColors.BRACES);
+        keys1.put(KtTokens.RBRACE, JetHighlightingColors.BRACES);
+        keys1.put(KtTokens.LBRACKET, JetHighlightingColors.BRACKETS);
+        keys1.put(KtTokens.RBRACKET, JetHighlightingColors.BRACKETS);
+        keys1.put(KtTokens.COMMA, JetHighlightingColors.COMMA);
+        keys1.put(KtTokens.SEMICOLON, JetHighlightingColors.SEMICOLON);
+        keys1.put(KtTokens.DOT, JetHighlightingColors.DOT);
+        keys1.put(KtTokens.ARROW, JetHighlightingColors.ARROW);
 
-        keys1.put(JetTokens.OPEN_QUOTE, JetHighlightingColors.STRING);
-        keys1.put(JetTokens.CLOSING_QUOTE, JetHighlightingColors.STRING);
-        keys1.put(JetTokens.REGULAR_STRING_PART, JetHighlightingColors.STRING);
-        keys1.put(JetTokens.LONG_TEMPLATE_ENTRY_END, JetHighlightingColors.STRING_ESCAPE);
-        keys1.put(JetTokens.LONG_TEMPLATE_ENTRY_START, JetHighlightingColors.STRING_ESCAPE);
-        keys1.put(JetTokens.SHORT_TEMPLATE_ENTRY_START, JetHighlightingColors.STRING_ESCAPE);
+        keys1.put(KtTokens.OPEN_QUOTE, JetHighlightingColors.STRING);
+        keys1.put(KtTokens.CLOSING_QUOTE, JetHighlightingColors.STRING);
+        keys1.put(KtTokens.REGULAR_STRING_PART, JetHighlightingColors.STRING);
+        keys1.put(KtTokens.LONG_TEMPLATE_ENTRY_END, JetHighlightingColors.STRING_ESCAPE);
+        keys1.put(KtTokens.LONG_TEMPLATE_ENTRY_START, JetHighlightingColors.STRING_ESCAPE);
+        keys1.put(KtTokens.SHORT_TEMPLATE_ENTRY_START, JetHighlightingColors.STRING_ESCAPE);
 
-        keys1.put(JetTokens.ESCAPE_SEQUENCE, JetHighlightingColors.STRING_ESCAPE);
+        keys1.put(KtTokens.ESCAPE_SEQUENCE, JetHighlightingColors.STRING_ESCAPE);
 
-        keys1.put(JetTokens.CHARACTER_LITERAL, JetHighlightingColors.STRING);
+        keys1.put(KtTokens.CHARACTER_LITERAL, JetHighlightingColors.STRING);
 
-        keys1.put(JetTokens.EOL_COMMENT, JetHighlightingColors.LINE_COMMENT);
-        keys1.put(JetTokens.SHEBANG_COMMENT, JetHighlightingColors.LINE_COMMENT);
-        keys1.put(JetTokens.BLOCK_COMMENT, JetHighlightingColors.BLOCK_COMMENT);
-        keys1.put(JetTokens.DOC_COMMENT, JetHighlightingColors.DOC_COMMENT);
+        keys1.put(KtTokens.EOL_COMMENT, JetHighlightingColors.LINE_COMMENT);
+        keys1.put(KtTokens.SHEBANG_COMMENT, JetHighlightingColors.LINE_COMMENT);
+        keys1.put(KtTokens.BLOCK_COMMENT, JetHighlightingColors.BLOCK_COMMENT);
+        keys1.put(KtTokens.DOC_COMMENT, JetHighlightingColors.DOC_COMMENT);
 
         fillMap(keys1, KDocTokens.KDOC_HIGHLIGHT_TOKENS, JetHighlightingColors.DOC_COMMENT);
         keys1.put(KDocTokens.TAG_NAME, JetHighlightingColors.KDOC_TAG);
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetHighlightingLexer.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetHighlightingLexer.java
index 2ae54d4d0dc..cc5b4c0c6fa 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetHighlightingLexer.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetHighlightingLexer.java
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.idea.highlighter;
 import com.intellij.lexer.LayeredLexer;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.kotlin.kdoc.lexer.KDocLexer;
-import org.jetbrains.kotlin.lexer.JetLexer;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KotlinLexer;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
 public class JetHighlightingLexer extends LayeredLexer {
     public JetHighlightingLexer() {
-        super(new JetLexer());
+        super(new KotlinLexer());
 
-        registerSelfStoppingLayer(new KDocLexer(), new IElementType[]{JetTokens.DOC_COMMENT}, IElementType.EMPTY_ARRAY);
+        registerSelfStoppingLayer(new KDocLexer(), new IElementType[]{KtTokens.DOC_COMMENT}, IElementType.EMPTY_ARRAY);
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetPsiChecker.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetPsiChecker.kt
index 1a61690c63c..fe9ff69a860 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetPsiChecker.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetPsiChecker.kt
@@ -43,10 +43,10 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyzeFullyAndGetResult
 import org.jetbrains.kotlin.idea.quickfix.QuickFixes
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
-import org.jetbrains.kotlin.psi.JetCodeFragment
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetParameter
-import org.jetbrains.kotlin.psi.JetReferenceExpression
+import org.jetbrains.kotlin.psi.KtCodeFragment
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtParameter
+import org.jetbrains.kotlin.psi.KtReferenceExpression
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import java.lang.reflect.*
@@ -55,9 +55,9 @@ import java.util.*
 public open class JetPsiChecker : Annotator, HighlightRangeExtension {
 
     override fun annotate(element: PsiElement, holder: AnnotationHolder) {
-        if (!(ProjectRootsUtil.isInProjectOrLibraryContent(element) || element.getContainingFile() is JetCodeFragment)) return
+        if (!(ProjectRootsUtil.isInProjectOrLibraryContent(element) || element.getContainingFile() is KtCodeFragment)) return
 
-        val file = element.getContainingFile() as JetFile
+        val file = element.getContainingFile() as KtFile
 
         val analysisResult = file.analyzeFullyAndGetResult()
         if (analysisResult.isError()) {
@@ -72,13 +72,13 @@ public open class JetPsiChecker : Annotator, HighlightRangeExtension {
     }
 
     override fun isForceHighlightParents(file: PsiFile): Boolean {
-        return file is JetFile
+        return file is KtFile
     }
 
-    open protected fun shouldSuppressUnusedParameter(parameter: JetParameter): Boolean = false
+    open protected fun shouldSuppressUnusedParameter(parameter: KtParameter): Boolean = false
 
     fun annotateElement(element: PsiElement, holder: AnnotationHolder, diagnostics: Diagnostics) {
-        if (ProjectRootsUtil.isInProjectSource(element) || element.getContainingFile() is JetCodeFragment) {
+        if (ProjectRootsUtil.isInProjectSource(element) || element.getContainingFile() is KtCodeFragment) {
             val elementAnnotator = ElementAnnotator(element, holder)
             for (diagnostic in diagnostics.forElement(element)) {
                 elementAnnotator.registerDiagnosticAnnotations(diagnostic)
@@ -100,7 +100,7 @@ public open class JetPsiChecker : Annotator, HighlightRangeExtension {
                 Severity.ERROR -> {
                     when (factory) {
                         in Errors.UNRESOLVED_REFERENCE_DIAGNOSTICS -> {
-                            val referenceExpression = element as JetReferenceExpression
+                            val referenceExpression = element as KtReferenceExpression
                             val reference = referenceExpression.mainReference
                             if (reference is MultiRangeReference) {
                                 AnnotationPresentationInfo(diagnostic,
@@ -127,7 +127,7 @@ public open class JetPsiChecker : Annotator, HighlightRangeExtension {
                     }
                 }
                 Severity.WARNING -> {
-                    if (factory == Errors.UNUSED_PARAMETER && shouldSuppressUnusedParameter(element as JetParameter)) {
+                    if (factory == Errors.UNUSED_PARAMETER && shouldSuppressUnusedParameter(element as KtParameter)) {
                         return
                     }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinBeforeResolveHighlightingPass.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinBeforeResolveHighlightingPass.kt
index 0d5a469c4e2..d6c5b05b09a 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinBeforeResolveHighlightingPass.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinBeforeResolveHighlightingPass.kt
@@ -34,10 +34,10 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiRecursiveElementVisitor
 import org.jetbrains.kotlin.idea.kdoc.KDocHighlightingVisitor
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
 public class KotlinBeforeResolveHighlightingPass(
-        private val file: JetFile,
+        private val file: KtFile,
         document: Document
 ) : TextEditorHighlightingPass(file.project, document), DumbAware {
 
@@ -74,7 +74,7 @@ public class KotlinBeforeResolveHighlightingPass(
         }
 
         override fun createHighlightingPass(file: PsiFile, editor: Editor): TextEditorHighlightingPass? {
-            if (file !is JetFile) return null
+            if (file !is KtFile) return null
             return KotlinBeforeResolveHighlightingPass(file, editor.document)
         }
     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinProblemHighlightFilter.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinProblemHighlightFilter.kt
index ab3cceec4ef..81a009f12d8 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinProblemHighlightFilter.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinProblemHighlightFilter.kt
@@ -18,13 +18,13 @@ package org.jetbrains.kotlin.idea.highlighter
 
 import com.intellij.codeInsight.daemon.ProblemHighlightFilter
 import com.intellij.psi.PsiFile
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import com.intellij.ide.projectView.impl.ProjectRootsUtil
 
 class KotlinProblemHighlightFilter : ProblemHighlightFilter() {
 
     override fun shouldHighlight(psiFile: PsiFile): Boolean {
-        return psiFile.getFileType() != JetFileType.INSTANCE || !ProjectRootsUtil.isOutsideSourceRoot(psiFile)
+        return psiFile.getFileType() != KotlinFileType.INSTANCE || !ProjectRootsUtil.isOutsideSourceRoot(psiFile)
     }
 
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinSuppressableWarningProblemGroup.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinSuppressableWarningProblemGroup.kt
index 12923f6e952..0e94f413c15 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinSuppressableWarningProblemGroup.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinSuppressableWarningProblemGroup.kt
@@ -54,7 +54,7 @@ fun createSuppressWarningActions(element: PsiElement, diagnosticFactory: Diagnos
     var current: PsiElement? = element
     var suppressAtStatementAllowed = true
     while (current != null) {
-        if (current is JetDeclaration && current !is JetMultiDeclaration) {
+        if (current is KtDeclaration && current !is KtMultiDeclaration) {
             val declaration = current
             val kind = DeclarationKindDetector.detect(declaration)
             if (kind != null) {
@@ -62,10 +62,10 @@ fun createSuppressWarningActions(element: PsiElement, diagnosticFactory: Diagnos
             }
             suppressAtStatementAllowed = false
         }
-        else if (current is JetExpression && suppressAtStatementAllowed) {
+        else if (current is KtExpression && suppressAtStatementAllowed) {
             // Add suppress action at first statement
-            if (current.parent is JetBlockExpression || current.parent is JetMultiDeclaration) {
-                val kind = if (current.parent is JetBlockExpression) "statement" else "initializer"
+            if (current.parent is KtBlockExpression || current.parent is KtMultiDeclaration) {
+                val kind = if (current.parent is KtBlockExpression) "statement" else "initializer"
                 actions.add(KotlinSuppressIntentionAction(current, diagnosticFactory,
                                                           AnnotationHostKind(kind, "", true)))
                 suppressAtStatementAllowed = false
@@ -77,33 +77,33 @@ fun createSuppressWarningActions(element: PsiElement, diagnosticFactory: Diagnos
     return actions
 }
 
-private object DeclarationKindDetector : JetVisitor<AnnotationHostKind?, Unit?>() {
+private object DeclarationKindDetector : KtVisitor<AnnotationHostKind?, Unit?>() {
 
-    fun detect(declaration: JetDeclaration) = declaration.accept(this, null)
+    fun detect(declaration: KtDeclaration) = declaration.accept(this, null)
 
-    override fun visitDeclaration(d: JetDeclaration, data: Unit?) = null
+    override fun visitDeclaration(d: KtDeclaration, data: Unit?) = null
 
-    override fun visitClass(d: JetClass, data: Unit?) = detect(d, if (d.isInterface()) "interface" else "class")
+    override fun visitClass(d: KtClass, data: Unit?) = detect(d, if (d.isInterface()) "interface" else "class")
 
-    override fun visitNamedFunction(d: JetNamedFunction, data: Unit?) = detect(d, "fun")
+    override fun visitNamedFunction(d: KtNamedFunction, data: Unit?) = detect(d, "fun")
 
-    override fun visitProperty(d: JetProperty, data: Unit?) = detect(d, d.getValOrVarKeyword().getText()!!)
+    override fun visitProperty(d: KtProperty, data: Unit?) = detect(d, d.getValOrVarKeyword().getText()!!)
 
-    override fun visitMultiDeclaration(d: JetMultiDeclaration, data: Unit?) = detect(d, d.getValOrVarKeyword()?.getText() ?: "val",
+    override fun visitMultiDeclaration(d: KtMultiDeclaration, data: Unit?) = detect(d, d.getValOrVarKeyword()?.getText() ?: "val",
                                                                                   name = d.getEntries().map { it.getName()!! }.join(", ", "(", ")"))
 
-    override fun visitTypeParameter(d: JetTypeParameter, data: Unit?) = detect(d, "type parameter", newLineNeeded = false)
+    override fun visitTypeParameter(d: KtTypeParameter, data: Unit?) = detect(d, "type parameter", newLineNeeded = false)
 
-    override fun visitEnumEntry(d: JetEnumEntry, data: Unit?) = detect(d, "enum entry")
+    override fun visitEnumEntry(d: KtEnumEntry, data: Unit?) = detect(d, "enum entry")
 
-    override fun visitParameter(d: JetParameter, data: Unit?) = detect(d, "parameter", newLineNeeded = false)
+    override fun visitParameter(d: KtParameter, data: Unit?) = detect(d, "parameter", newLineNeeded = false)
 
-    override fun visitObjectDeclaration(d: JetObjectDeclaration, data: Unit?): AnnotationHostKind? {
-        if (d.isCompanion()) return detect(d, "companion object", name = "${d.getName()} of ${d.getStrictParentOfType<JetClass>()?.getName()}")
-        if (d.getParent() is JetObjectLiteralExpression) return null
+    override fun visitObjectDeclaration(d: KtObjectDeclaration, data: Unit?): AnnotationHostKind? {
+        if (d.isCompanion()) return detect(d, "companion object", name = "${d.getName()} of ${d.getStrictParentOfType<KtClass>()?.getName()}")
+        if (d.getParent() is KtObjectLiteralExpression) return null
         return detect(d, "object")
     }
 
-    private fun detect(declaration: JetDeclaration, kind: String, name: String = declaration.getName() ?: "<anonymous>", newLineNeeded: Boolean = true)
+    private fun detect(declaration: KtDeclaration, kind: String, name: String = declaration.getName() ?: "<anonymous>", newLineNeeded: Boolean = true)
         = AnnotationHostKind(kind, name, newLineNeeded)
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/LabelsHighlightingVisitor.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/LabelsHighlightingVisitor.java
index 71edda42f4e..edf6760e185 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/LabelsHighlightingVisitor.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/LabelsHighlightingVisitor.java
@@ -18,11 +18,11 @@ package org.jetbrains.kotlin.idea.highlighter;
 
 import com.intellij.lang.annotation.AnnotationHolder;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetExpressionWithLabel;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
-import org.jetbrains.kotlin.psi.JetVisitorVoid;
+import org.jetbrains.kotlin.psi.KtExpressionWithLabel;
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
+import org.jetbrains.kotlin.psi.KtVisitorVoid;
 
-class LabelsHighlightingVisitor extends JetVisitorVoid {
+class LabelsHighlightingVisitor extends KtVisitorVoid {
     private final AnnotationHolder holder;
 
     LabelsHighlightingVisitor(AnnotationHolder holder) {
@@ -30,8 +30,8 @@ class LabelsHighlightingVisitor extends JetVisitorVoid {
     }
 
     @Override
-    public void visitExpressionWithLabel(@NotNull JetExpressionWithLabel expression) {
-        JetSimpleNameExpression targetLabel = expression.getTargetLabel();
+    public void visitExpressionWithLabel(@NotNull KtExpressionWithLabel expression) {
+        KtSimpleNameExpression targetLabel = expression.getTargetLabel();
         if (targetLabel != null) {
             NameHighlighter.highlightName(holder, targetLabel, JetHighlightingColors.LABEL);
         }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/PropertiesHighlightingVisitor.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/PropertiesHighlightingVisitor.java
index 44cac62acee..dd3e6190872 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/PropertiesHighlightingVisitor.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/PropertiesHighlightingVisitor.java
@@ -23,11 +23,11 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
 import org.jetbrains.kotlin.descriptors.VariableDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor;
-import org.jetbrains.kotlin.lexer.JetTokens;
-import org.jetbrains.kotlin.psi.JetParameter;
-import org.jetbrains.kotlin.psi.JetProperty;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
-import org.jetbrains.kotlin.psi.JetThisExpression;
+import org.jetbrains.kotlin.lexer.KtTokens;
+import org.jetbrains.kotlin.psi.KtParameter;
+import org.jetbrains.kotlin.psi.KtProperty;
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
+import org.jetbrains.kotlin.psi.KtThisExpression;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.calls.tasks.DynamicCallsKt;
@@ -38,8 +38,8 @@ class PropertiesHighlightingVisitor extends AfterAnalysisHighlightingVisitor {
     }
 
     @Override
-    public void visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression) {
-        if (expression.getParent() instanceof JetThisExpression) {
+    public void visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression) {
+        if (expression.getParent() instanceof KtThisExpression) {
             return;
         }
         DeclarationDescriptor target = bindingContext.get(BindingContext.REFERENCE_TARGET, expression);
@@ -52,13 +52,13 @@ class PropertiesHighlightingVisitor extends AfterAnalysisHighlightingVisitor {
         }
 
         highlightProperty(expression, (PropertyDescriptor) target, false);
-        if (expression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER) {
+        if (expression.getReferencedNameElementType() == KtTokens.FIELD_IDENTIFIER) {
             NameHighlighter.highlightName(holder, expression, JetHighlightingColors.BACKING_FIELD_ACCESS);
         }
     }
 
     @Override
-    public void visitProperty(@NotNull JetProperty property) {
+    public void visitProperty(@NotNull KtProperty property) {
         PsiElement nameIdentifier = property.getNameIdentifier();
         if (nameIdentifier == null) return;
         VariableDescriptor propertyDescriptor = bindingContext.get(BindingContext.VARIABLE, property);
@@ -71,7 +71,7 @@ class PropertiesHighlightingVisitor extends AfterAnalysisHighlightingVisitor {
     }
 
     @Override
-    public void visitParameter(@NotNull JetParameter parameter) {
+    public void visitParameter(@NotNull KtParameter parameter) {
         PsiElement nameIdentifier = parameter.getNameIdentifier();
         if (nameIdentifier == null) return;
         PropertyDescriptor propertyDescriptor = bindingContext.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, parameter);
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/SoftKeywordsHighlightingVisitor.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/SoftKeywordsHighlightingVisitor.java
index 4f2ef9de49e..d5f324033bc 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/SoftKeywordsHighlightingVisitor.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/SoftKeywordsHighlightingVisitor.java
@@ -23,12 +23,12 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.impl.source.tree.LeafPsiElement;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.lexer.JetTokens;
-import org.jetbrains.kotlin.psi.JetFunctionLiteral;
-import org.jetbrains.kotlin.psi.JetFunctionLiteralExpression;
-import org.jetbrains.kotlin.psi.JetVisitorVoid;
+import org.jetbrains.kotlin.lexer.KtTokens;
+import org.jetbrains.kotlin.psi.KtFunctionLiteral;
+import org.jetbrains.kotlin.psi.KtFunctionLiteralExpression;
+import org.jetbrains.kotlin.psi.KtVisitorVoid;
 
-class SoftKeywordsHighlightingVisitor extends JetVisitorVoid {
+class SoftKeywordsHighlightingVisitor extends KtVisitorVoid {
     private final AnnotationHolder holder;
 
     SoftKeywordsHighlightingVisitor(AnnotationHolder holder) {
@@ -39,23 +39,23 @@ class SoftKeywordsHighlightingVisitor extends JetVisitorVoid {
     public void visitElement(PsiElement element) {
         if (element instanceof LeafPsiElement) {
             IElementType elementType = ((LeafPsiElement)element).getElementType();
-            if (JetTokens.SOFT_KEYWORDS.contains(elementType)) {
+            if (KtTokens.SOFT_KEYWORDS.contains(elementType)) {
                 TextAttributesKey attributes = JetHighlightingColors.KEYWORD;
-                if (JetTokens.MODIFIER_KEYWORDS.contains(elementType)) {
+                if (KtTokens.MODIFIER_KEYWORDS.contains(elementType)) {
                     attributes = JetHighlightingColors.BUILTIN_ANNOTATION;
                 }
                 holder.createInfoAnnotation(element, null).setTextAttributes(attributes);
             }
-            if (JetTokens.SAFE_ACCESS.equals(elementType)) {
+            if (KtTokens.SAFE_ACCESS.equals(elementType)) {
                 holder.createInfoAnnotation(element, null).setTextAttributes(JetHighlightingColors.SAFE_ACCESS);
             }
         }
     }
 
     @Override
-    public void visitFunctionLiteralExpression(@NotNull JetFunctionLiteralExpression expression) {
+    public void visitFunctionLiteralExpression(@NotNull KtFunctionLiteralExpression expression) {
         if (ApplicationManager.getApplication().isUnitTestMode()) return;
-        JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
+        KtFunctionLiteral functionLiteral = expression.getFunctionLiteral();
         holder.createInfoAnnotation(functionLiteral.getLBrace(), null).setTextAttributes(JetHighlightingColors.FUNCTION_LITERAL_BRACES_AND_ARROW);
         PsiElement closingBrace = functionLiteral.getRBrace();
         if (closingBrace != null) {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/TypeKindHighlightingVisitor.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/TypeKindHighlightingVisitor.java
index 5b930e92b6c..dead67f2f65 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/TypeKindHighlightingVisitor.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/TypeKindHighlightingVisitor.java
@@ -22,10 +22,10 @@ import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetDynamicType;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
-import org.jetbrains.kotlin.psi.JetTypeParameter;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtDynamicType;
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
+import org.jetbrains.kotlin.psi.KtTypeParameter;
 import org.jetbrains.kotlin.psi.psiUtil.JetPsiUtilKt;
 import org.jetbrains.kotlin.resolve.BindingContext;
 
@@ -35,7 +35,7 @@ class TypeKindHighlightingVisitor extends AfterAnalysisHighlightingVisitor {
     }
 
     @Override
-    public void visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression) {
+    public void visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression) {
         if (NameHighlighter.namesHighlightingEnabled) {
             DeclarationDescriptor referenceTarget = bindingContext.get(BindingContext.REFERENCE_TARGET, expression);
             if (referenceTarget instanceof ConstructorDescriptor) {
@@ -57,13 +57,13 @@ class TypeKindHighlightingVisitor extends AfterAnalysisHighlightingVisitor {
         }
     }
 
-    private void highlightAnnotation(@NotNull JetSimpleNameExpression expression) {
+    private void highlightAnnotation(@NotNull KtSimpleNameExpression expression) {
         TextRange toHighlight = JetPsiUtilKt.getCalleeHighlightingRange(expression);
         NameHighlighter.highlightName(holder, toHighlight, JetHighlightingColors.ANNOTATION);
     }
 
     @Override
-    public void visitTypeParameter(@NotNull JetTypeParameter parameter) {
+    public void visitTypeParameter(@NotNull KtTypeParameter parameter) {
         PsiElement identifier = parameter.getNameIdentifier();
         if (identifier != null) {
             highlightName(identifier, JetHighlightingColors.TYPE_PARAMETER);
@@ -72,7 +72,7 @@ class TypeKindHighlightingVisitor extends AfterAnalysisHighlightingVisitor {
     }
 
     @Override
-    public void visitClassOrObject(@NotNull JetClassOrObject classOrObject) {
+    public void visitClassOrObject(@NotNull KtClassOrObject classOrObject) {
         PsiElement identifier = classOrObject.getNameIdentifier();
         ClassDescriptor classDescriptor = bindingContext.get(BindingContext.CLASS, classOrObject);
         if (identifier != null && classDescriptor != null) {
@@ -82,7 +82,7 @@ class TypeKindHighlightingVisitor extends AfterAnalysisHighlightingVisitor {
     }
 
     @Override
-    public void visitDynamicType(@NotNull JetDynamicType type) {
+    public void visitDynamicType(@NotNull KtDynamicType type) {
         // Do nothing: 'dynamic' is highlighted as a keyword
     }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/VariablesHighlightingVisitor.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/VariablesHighlightingVisitor.java
index a9a8a4e4ab3..846f106336b 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/VariablesHighlightingVisitor.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/VariablesHighlightingVisitor.java
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.calls.tasks.DynamicCallsKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.expressions.CaptureKind;
 
 import static org.jetbrains.kotlin.resolve.BindingContext.*;
@@ -38,7 +38,7 @@ class VariablesHighlightingVisitor extends AfterAnalysisHighlightingVisitor {
     }
 
     @Override
-    public void visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression) {
+    public void visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression) {
         DeclarationDescriptor target = bindingContext.get(REFERENCE_TARGET, expression);
         if (target == null) {
             return;
@@ -56,20 +56,20 @@ class VariablesHighlightingVisitor extends AfterAnalysisHighlightingVisitor {
     }
 
     @Override
-    public void visitProperty(@NotNull JetProperty property) {
+    public void visitProperty(@NotNull KtProperty property) {
         visitVariableDeclaration(property);
         super.visitProperty(property);
     }
 
     @Override
-    public void visitParameter(@NotNull JetParameter parameter) {
+    public void visitParameter(@NotNull KtParameter parameter) {
         visitVariableDeclaration(parameter);
         super.visitParameter(parameter);
     }
 
     @Override
-    public void visitExpression(@NotNull JetExpression expression) {
-        JetType smartCast = bindingContext.get(SMARTCAST, expression);
+    public void visitExpression(@NotNull KtExpression expression) {
+        KtType smartCast = bindingContext.get(SMARTCAST, expression);
         if (smartCast != null) {
             holder.createInfoAnnotation(expression, "Smart cast to " + DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(smartCast)).setTextAttributes(
                 JetHighlightingColors.SMART_CAST_VALUE);
@@ -77,7 +77,7 @@ class VariablesHighlightingVisitor extends AfterAnalysisHighlightingVisitor {
         super.visitExpression(expression);
     }
 
-    private void visitVariableDeclaration(JetNamedDeclaration declaration) {
+    private void visitVariableDeclaration(KtNamedDeclaration declaration) {
         DeclarationDescriptor declarationDescriptor = bindingContext.get(DECLARATION_TO_DESCRIPTOR, declaration);
         PsiElement nameIdentifier = declaration.getNameIdentifier();
         if (nameIdentifier != null && declarationDescriptor != null) {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/inspections/IntentionBasedInspection.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/inspections/IntentionBasedInspection.kt
index f8ced35d7c1..54378018303 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/inspections/IntentionBasedInspection.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/inspections/IntentionBasedInspection.kt
@@ -32,9 +32,9 @@ import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiFile
 import com.intellij.util.SmartList
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 
-public abstract class IntentionBasedInspection<TElement : JetElement>(
+public abstract class IntentionBasedInspection<TElement : KtElement>(
         public val intentions: List<IntentionBasedInspection.IntentionData<TElement>>,
         protected val problemText: String?,
         protected val elementType: Class<TElement>
@@ -43,7 +43,7 @@ public abstract class IntentionBasedInspection<TElement : JetElement>(
     constructor(intention: JetSelfTargetingRangeIntention<TElement>, additionalChecker: (TElement) -> Boolean = { true })
     : this(listOf(IntentionData(intention, additionalChecker)), null, intention.elementType)
 
-    public data class IntentionData<TElement : JetElement>(
+    public data class IntentionData<TElement : KtElement>(
             val intention: JetSelfTargetingRangeIntention<TElement>,
             val additionalChecker: (TElement) -> Boolean = { true }
     )
@@ -88,7 +88,7 @@ public abstract class IntentionBasedInspection<TElement : JetElement>(
         get() = ProblemHighlightType.GENERIC_ERROR_OR_WARNING
 
     /* we implement IntentionAction to provide isAvailable which will be used to hide outdated items and make sure we never call 'invoke' for such item */
-    private class IntentionBasedQuickFix<TElement : JetElement>(
+    private class IntentionBasedQuickFix<TElement : KtElement>(
             private val intention: JetSelfTargetingRangeIntention<TElement>,
             private val text: String,
             private val additionalChecker: (TElement) -> Boolean,
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/JetSelfTargetingIntention.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/JetSelfTargetingIntention.kt
index 147e8a931db..2b7ca836611 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/JetSelfTargetingIntention.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/JetSelfTargetingIntention.kt
@@ -29,12 +29,12 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.psiUtil.containsInside
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 import java.util.HashMap
 
-public abstract class JetSelfTargetingIntention<TElement : JetElement>(
+public abstract class JetSelfTargetingIntention<TElement : KtElement>(
         public val elementType: Class<TElement>,
         private var text: String,
         private val familyName: String = text
@@ -109,7 +109,7 @@ public abstract class JetSelfTargetingIntention<TElement : JetElement>(
     companion object {
         private val intentionBasedInspections = HashMap<Class<out JetSelfTargetingIntention<*>>, IntentionBasedInspection<*>?>()
 
-        fun <TElement : JetElement> findInspection(intentionClass: Class<out JetSelfTargetingIntention<TElement>>): IntentionBasedInspection<TElement>? {
+        fun <TElement : KtElement> findInspection(intentionClass: Class<out JetSelfTargetingIntention<TElement>>): IntentionBasedInspection<TElement>? {
             if (intentionBasedInspections.containsKey(intentionClass)) {
                 @Suppress("UNCHECKED_CAST")
                 return intentionBasedInspections[intentionClass] as IntentionBasedInspection<TElement>?
@@ -129,7 +129,7 @@ public abstract class JetSelfTargetingIntention<TElement : JetElement>(
     }
 }
 
-public abstract class JetSelfTargetingRangeIntention<TElement : JetElement>(
+public abstract class JetSelfTargetingRangeIntention<TElement : KtElement>(
         elementType: Class<TElement>,
         text: String,
         familyName: String = text
@@ -143,7 +143,7 @@ public abstract class JetSelfTargetingRangeIntention<TElement : JetElement>(
     }
 }
 
-public abstract class JetSelfTargetingOffsetIndependentIntention<TElement : JetElement>(
+public abstract class JetSelfTargetingOffsetIndependentIntention<TElement : KtElement>(
         elementType: Class<TElement>,
         text: String,
         familyName: String = text
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/OperatorToFunctionIntention.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/OperatorToFunctionIntention.kt
index b7255380a96..03f9e677a7d 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/OperatorToFunctionIntention.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/OperatorToFunctionIntention.kt
@@ -20,51 +20,51 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElementSelector
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
-public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpression>(javaClass(), "Replace overloaded operator with function call") {
+public class OperatorToFunctionIntention : JetSelfTargetingIntention<KtExpression>(javaClass(), "Replace overloaded operator with function call") {
     companion object {
-        private fun isApplicablePrefix(element: JetPrefixExpression, caretOffset: Int): Boolean {
+        private fun isApplicablePrefix(element: KtPrefixExpression, caretOffset: Int): Boolean {
             val opRef = element.getOperationReference()
             if (!opRef.getTextRange().containsOffset(caretOffset)) return false
             return when (opRef.getReferencedNameElementType()) {
-                JetTokens.PLUS, JetTokens.MINUS, JetTokens.PLUSPLUS, JetTokens.MINUSMINUS, JetTokens.EXCL -> true
+                KtTokens.PLUS, KtTokens.MINUS, KtTokens.PLUSPLUS, KtTokens.MINUSMINUS, KtTokens.EXCL -> true
                 else -> false
             }
         }
 
-        private fun isApplicablePostfix(element: JetPostfixExpression, caretOffset: Int): Boolean {
+        private fun isApplicablePostfix(element: KtPostfixExpression, caretOffset: Int): Boolean {
             val opRef = element.getOperationReference()
             if (!opRef.getTextRange().containsOffset(caretOffset)) return false
             if (element.getBaseExpression() == null) return false
             return when (opRef.getReferencedNameElementType()) {
-                JetTokens.PLUSPLUS, JetTokens.MINUSMINUS -> true
+                KtTokens.PLUSPLUS, KtTokens.MINUSMINUS -> true
                 else -> false
             }
         }
 
-        private fun isApplicableBinary(element: JetBinaryExpression, caretOffset: Int): Boolean {
+        private fun isApplicableBinary(element: KtBinaryExpression, caretOffset: Int): Boolean {
             val opRef = element.getOperationReference()
             if (!opRef.getTextRange().containsOffset(caretOffset)) return false
             return when (opRef.getReferencedNameElementType()) {
-                JetTokens.PLUS, JetTokens.MINUS, JetTokens.MUL, JetTokens.DIV, JetTokens.PERC, JetTokens.RANGE, JetTokens.IN_KEYWORD, JetTokens.NOT_IN, JetTokens.PLUSEQ, JetTokens.MINUSEQ, JetTokens.MULTEQ, JetTokens.DIVEQ, JetTokens.PERCEQ, JetTokens.EQEQ, JetTokens.EXCLEQ, JetTokens.GT, JetTokens.LT, JetTokens.GTEQ, JetTokens.LTEQ -> true
-                JetTokens.EQ -> element.getLeft() is JetArrayAccessExpression
+                KtTokens.PLUS, KtTokens.MINUS, KtTokens.MUL, KtTokens.DIV, KtTokens.PERC, KtTokens.RANGE, KtTokens.IN_KEYWORD, KtTokens.NOT_IN, KtTokens.PLUSEQ, KtTokens.MINUSEQ, KtTokens.MULTEQ, KtTokens.DIVEQ, KtTokens.PERCEQ, KtTokens.EQEQ, KtTokens.EXCLEQ, KtTokens.GT, KtTokens.LT, KtTokens.GTEQ, KtTokens.LTEQ -> true
+                KtTokens.EQ -> element.getLeft() is KtArrayAccessExpression
                 else -> false
             }
         }
 
-        private fun isApplicableArrayAccess(element: JetArrayAccessExpression, caretOffset: Int): Boolean {
+        private fun isApplicableArrayAccess(element: KtArrayAccessExpression, caretOffset: Int): Boolean {
             val lbracket = element.getLeftBracket() ?: return false
             val rbracket = element.getRightBracket() ?: return false
             return lbracket.getTextRange().containsOffset(caretOffset) || rbracket.getTextRange().containsOffset(caretOffset)
         }
 
-        private fun isApplicableCall(element: JetCallExpression, caretOffset: Int): Boolean {
+        private fun isApplicableCall(element: KtCallExpression, caretOffset: Int): Boolean {
             val lbrace = (element.getValueArgumentList()?.getLeftParenthesis()
                           ?: element.getFunctionLiteralArguments().firstOrNull()?.getFunctionLiteral()?.getLeftCurlyBrace()
                           ?: return false) as PsiElement
@@ -73,55 +73,55 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpressi
             val resolvedCall = element.getResolvedCall(element.analyze())
             val descriptor = resolvedCall?.getResultingDescriptor()
             if (descriptor is FunctionDescriptor && descriptor.getName() == OperatorNameConventions.INVOKE) {
-                if (element.getParent() is JetDotQualifiedExpression &&
+                if (element.getParent() is KtDotQualifiedExpression &&
                     element.getCalleeExpression()?.getText() == OperatorNameConventions.INVOKE.asString()) return false
                 return element.getValueArgumentList() != null || element.getFunctionLiteralArguments().isNotEmpty()
             }
             return false
         }
 
-        private fun convertPrefix(element: JetPrefixExpression): JetExpression {
+        private fun convertPrefix(element: KtPrefixExpression): KtExpression {
             val op = element.getOperationReference().getReferencedNameElementType()
             val base = element.getBaseExpression()!!.getText()
 
             val call = when (op) {
-                JetTokens.PLUS -> "plus()"
-                JetTokens.MINUS -> "minus()"
-                JetTokens.PLUSPLUS -> "inc()"
-                JetTokens.MINUSMINUS -> "dec()"
-                JetTokens.EXCL -> "not()"
+                KtTokens.PLUS -> "plus()"
+                KtTokens.MINUS -> "minus()"
+                KtTokens.PLUSPLUS -> "inc()"
+                KtTokens.MINUSMINUS -> "dec()"
+                KtTokens.EXCL -> "not()"
                 else -> return element
             }
 
             val transformation = "$base.$call"
-            val transformed = JetPsiFactory(element).createExpression(transformation)
-            return element.replace(transformed) as JetExpression
+            val transformed = KtPsiFactory(element).createExpression(transformation)
+            return element.replace(transformed) as KtExpression
         }
 
-        private fun convertPostFix(element: JetPostfixExpression): JetExpression {
+        private fun convertPostFix(element: KtPostfixExpression): KtExpression {
             val op = element.getOperationReference().getReferencedNameElementType()
             val base = element.getBaseExpression()!!.getText()
 
             val call = when (op) {
-                JetTokens.PLUSPLUS -> "inc()"
-                JetTokens.MINUSMINUS -> "dec()"
+                KtTokens.PLUSPLUS -> "inc()"
+                KtTokens.MINUSMINUS -> "dec()"
                 else -> return element
             }
 
             val transformation = "$base.$call"
-            val transformed = JetPsiFactory(element).createExpression(transformation)
-            return element.replace(transformed) as JetExpression
+            val transformed = KtPsiFactory(element).createExpression(transformation)
+            return element.replace(transformed) as KtExpression
         }
 
-        private fun convertBinary(element: JetBinaryExpression): JetExpression {
+        private fun convertBinary(element: KtBinaryExpression): KtExpression {
             val op = element.getOperationReference().getReferencedNameElementType()
             val left = element.getLeft()!!
             val right = element.getRight()!!
             val leftText = left.getText()
             val rightText = right.getText()
 
-            if (op == JetTokens.EQ) {
-                if (left is JetArrayAccessExpression) {
+            if (op == KtTokens.EQ) {
+                if (left is KtArrayAccessExpression) {
                     convertArrayAccess(left)
                 }
                 return element
@@ -133,42 +133,42 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpressi
             val elemType = context.getType(left)
 
             val transformation = when (op) {
-                JetTokens.PLUS -> "$leftText.plus($rightText)"
-                JetTokens.MINUS -> "$leftText.minus($rightText)"
-                JetTokens.MUL -> "$leftText.times($rightText)"
-                JetTokens.DIV -> "$leftText.div($rightText)"
-                JetTokens.PERC -> "$leftText.mod($rightText)"
-                JetTokens.RANGE -> "$leftText.rangeTo($rightText)"
-                JetTokens.IN_KEYWORD -> "$rightText.contains($leftText)"
-                JetTokens.NOT_IN -> "!$rightText.contains($leftText)"
-                JetTokens.PLUSEQ -> if (functionName == "plusAssign") "$leftText.plusAssign($rightText)" else "$leftText = $leftText.plus($rightText)"
-                JetTokens.MINUSEQ -> if (functionName == "minusAssign") "$leftText.minusAssign($rightText)" else "$leftText = $leftText.minus($rightText)"
-                JetTokens.MULTEQ -> if (functionName == "multAssign") "$leftText.multAssign($rightText)" else "$leftText = $leftText.mult($rightText)"
-                JetTokens.DIVEQ -> if (functionName == "divAssign") "$leftText.divAssign($rightText)" else "$leftText = $leftText.div($rightText)"
-                JetTokens.PERCEQ -> if (functionName == "modAssign") "$leftText.modAssign($rightText)" else "$leftText = $leftText.mod($rightText)"
-                JetTokens.EQEQ -> if (elemType?.isMarkedNullable() ?: true) "$leftText?.equals($rightText) ?: $rightText.identityEquals(null)" else "$leftText.equals($rightText)"
-                JetTokens.EXCLEQ -> if (elemType?.isMarkedNullable() ?: true) "!($leftText?.equals($rightText) ?: $rightText.identityEquals(null))" else "!$leftText.equals($rightText)"
-                JetTokens.GT -> "$leftText.compareTo($rightText) > 0"
-                JetTokens.LT -> "$leftText.compareTo($rightText) < 0"
-                JetTokens.GTEQ -> "$leftText.compareTo($rightText) >= 0"
-                JetTokens.LTEQ -> "$leftText.compareTo($rightText) <= 0"
+                KtTokens.PLUS -> "$leftText.plus($rightText)"
+                KtTokens.MINUS -> "$leftText.minus($rightText)"
+                KtTokens.MUL -> "$leftText.times($rightText)"
+                KtTokens.DIV -> "$leftText.div($rightText)"
+                KtTokens.PERC -> "$leftText.mod($rightText)"
+                KtTokens.RANGE -> "$leftText.rangeTo($rightText)"
+                KtTokens.IN_KEYWORD -> "$rightText.contains($leftText)"
+                KtTokens.NOT_IN -> "!$rightText.contains($leftText)"
+                KtTokens.PLUSEQ -> if (functionName == "plusAssign") "$leftText.plusAssign($rightText)" else "$leftText = $leftText.plus($rightText)"
+                KtTokens.MINUSEQ -> if (functionName == "minusAssign") "$leftText.minusAssign($rightText)" else "$leftText = $leftText.minus($rightText)"
+                KtTokens.MULTEQ -> if (functionName == "multAssign") "$leftText.multAssign($rightText)" else "$leftText = $leftText.mult($rightText)"
+                KtTokens.DIVEQ -> if (functionName == "divAssign") "$leftText.divAssign($rightText)" else "$leftText = $leftText.div($rightText)"
+                KtTokens.PERCEQ -> if (functionName == "modAssign") "$leftText.modAssign($rightText)" else "$leftText = $leftText.mod($rightText)"
+                KtTokens.EQEQ -> if (elemType?.isMarkedNullable() ?: true) "$leftText?.equals($rightText) ?: $rightText.identityEquals(null)" else "$leftText.equals($rightText)"
+                KtTokens.EXCLEQ -> if (elemType?.isMarkedNullable() ?: true) "!($leftText?.equals($rightText) ?: $rightText.identityEquals(null))" else "!$leftText.equals($rightText)"
+                KtTokens.GT -> "$leftText.compareTo($rightText) > 0"
+                KtTokens.LT -> "$leftText.compareTo($rightText) < 0"
+                KtTokens.GTEQ -> "$leftText.compareTo($rightText) >= 0"
+                KtTokens.LTEQ -> "$leftText.compareTo($rightText) <= 0"
                 else -> return element
             }
 
-            val transformed = JetPsiFactory(element).createExpression(transformation)
+            val transformed = KtPsiFactory(element).createExpression(transformation)
 
-            return element.replace(transformed) as JetExpression
+            return element.replace(transformed) as KtExpression
         }
 
-        private fun convertArrayAccess(element: JetArrayAccessExpression): JetExpression {
+        private fun convertArrayAccess(element: KtArrayAccessExpression): KtExpression {
             val parent = element.getParent()
             val array = element.getArrayExpression()!!.getText()
             val indices = element.getIndicesNode()
             val indicesText = indices.getText()?.removeSurrounding("[","]") ?: throw AssertionError("Indices node of ArrayExpression shouldn't be null: JetArrayAccessExpression = ${element.getText()}")
 
             val transformation : String
-            val replaced : JetElement
-            if (parent is JetBinaryExpression && parent.getOperationReference().getReferencedNameElementType() == JetTokens.EQ) {
+            val replaced : KtElement
+            if (parent is KtBinaryExpression && parent.getOperationReference().getReferencedNameElementType() == KtTokens.EQ) {
                 // part of an assignment
                 val right = parent.getRight()!!.getText()
                 transformation = "$array.set($indicesText, $right)"
@@ -179,11 +179,11 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpressi
                 replaced = element
             }
 
-            val transformed = JetPsiFactory(element).createExpression(transformation)
-            return replaced.replace(transformed) as JetExpression
+            val transformed = KtPsiFactory(element).createExpression(transformation)
+            return replaced.replace(transformed) as KtExpression
         }
 
-        private fun convertCall(element: JetCallExpression): JetExpression {
+        private fun convertCall(element: KtCallExpression): KtExpression {
             val callee = element.getCalleeExpression()!!
             val arguments = element.getValueArgumentList()
             val argumentString = arguments?.getText()?.removeSurrounding("(", ")")
@@ -191,18 +191,18 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpressi
             val calleeText = callee.getText()
             val transformation = "$calleeText.${OperatorNameConventions.INVOKE.asString()}" +
                                  (if (argumentString == null) "" else "($argumentString)")
-            val transformed = JetPsiFactory(element).createExpression(transformation)
+            val transformed = KtPsiFactory(element).createExpression(transformation)
             funcLitArgs.forEach { transformed.add(it) }
-            return callee.getParent()!!.replace(transformed) as JetExpression
+            return callee.getParent()!!.replace(transformed) as KtExpression
         }
 
-        public fun convert(element: JetExpression): Pair<JetExpression, JetSimpleNameExpression> {
+        public fun convert(element: KtExpression): Pair<KtExpression, KtSimpleNameExpression> {
             val result = when (element) {
-                is JetPrefixExpression -> convertPrefix(element)
-                is JetPostfixExpression -> convertPostFix(element)
-                is JetBinaryExpression -> convertBinary(element)
-                is JetArrayAccessExpression -> convertArrayAccess(element)
-                is JetCallExpression -> convertCall(element)
+                is KtPrefixExpression -> convertPrefix(element)
+                is KtPostfixExpression -> convertPostFix(element)
+                is KtBinaryExpression -> convertBinary(element)
+                is KtArrayAccessExpression -> convertArrayAccess(element)
+                is KtCallExpression -> convertCall(element)
                 else -> throw IllegalArgumentException(element.toString())
             }
 
@@ -211,34 +211,34 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpressi
             return result to callName
         }
 
-        private fun findCallName(result: JetExpression): JetSimpleNameExpression? {
+        private fun findCallName(result: KtExpression): KtSimpleNameExpression? {
             return when (result) {
-                is JetBinaryExpression -> {
-                    if (JetPsiUtil.isAssignment(result))
+                is KtBinaryExpression -> {
+                    if (KtPsiUtil.isAssignment(result))
                         findCallName(result.getRight()!!)
                     else
                         findCallName(result.getLeft()!!)
                 }
 
-                is JetUnaryExpression -> findCallName(result.getBaseExpression()!!)
+                is KtUnaryExpression -> findCallName(result.getBaseExpression()!!)
 
-                else -> result.getQualifiedElementSelector() as JetSimpleNameExpression?
+                else -> result.getQualifiedElementSelector() as KtSimpleNameExpression?
             }
         }
     }
 
-    override fun isApplicableTo(element: JetExpression, caretOffset: Int): Boolean {
+    override fun isApplicableTo(element: KtExpression, caretOffset: Int): Boolean {
         return when (element) {
-            is JetPrefixExpression -> isApplicablePrefix(element, caretOffset)
-            is JetPostfixExpression -> isApplicablePostfix(element, caretOffset)
-            is JetBinaryExpression -> isApplicableBinary(element, caretOffset)
-            is JetArrayAccessExpression -> isApplicableArrayAccess(element, caretOffset)
-            is JetCallExpression -> isApplicableCall(element, caretOffset)
+            is KtPrefixExpression -> isApplicablePrefix(element, caretOffset)
+            is KtPostfixExpression -> isApplicablePostfix(element, caretOffset)
+            is KtBinaryExpression -> isApplicableBinary(element, caretOffset)
+            is KtArrayAccessExpression -> isApplicableArrayAccess(element, caretOffset)
+            is KtCallExpression -> isApplicableCall(element, caretOffset)
             else -> false
         }
     }
 
-    override fun applyTo(element: JetExpression, editor: Editor) {
+    override fun applyTo(element: KtExpression, editor: Editor) {
         convert(element)
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocElementFactory.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocElementFactory.kt
index e82c801f970..41edb3bdb2a 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocElementFactory.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocElementFactory.kt
@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.idea.kdoc
 
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.kdoc.psi.api.KDoc
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetFunction
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtFunction
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocName
 import org.jetbrains.kotlin.psi.psiUtil.getChildOfType
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.psi.psiUtil.getChildOfType
 class KDocElementFactory(val project: Project) {
     public fun createKDocFromText(text: String): KDoc {
         val fileText = text + " fun foo { }"
-        val function = JetPsiFactory(project).createDeclaration<JetFunction>(fileText)
+        val function = KtPsiFactory(project).createDeclaration<KtFunction>(fileText)
         return PsiTreeUtil.findChildOfType(function, javaClass<KDoc>())!!
     }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocFinder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocFinder.kt
index 3276ca80f61..4cfe871aa3a 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocFinder.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocFinder.kt
@@ -20,8 +20,8 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.kdoc.parser.KDocKnownTag
 import org.jetbrains.kotlin.kdoc.psi.api.KDoc
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocTag
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetPrimaryConstructor
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtPrimaryConstructor
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 import org.jetbrains.kotlin.resolve.source.PsiSourceElement
 
@@ -30,11 +30,11 @@ object KDocFinder {
         if (declaration is DeclarationDescriptorWithSource) {
             var psiDeclaration = (declaration.getSource() as? PsiSourceElement)?.psi?.getNavigationElement()
             // KDoc for primary constructor is located inside of its class KDoc
-            if (psiDeclaration is JetPrimaryConstructor) {
+            if (psiDeclaration is KtPrimaryConstructor) {
                 psiDeclaration = psiDeclaration.getContainingClassOrObject()
             }
 
-            if (psiDeclaration is JetDeclaration) {
+            if (psiDeclaration is KtDeclaration) {
                 val kdoc = psiDeclaration.getDocComment()
                 if (kdoc != null) {
                     if (declaration is ConstructorDescriptor) {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocReference.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocReference.kt
index d945774ad43..9d6d1a31248 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocReference.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocReference.kt
@@ -22,12 +22,12 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.caches.resolve.getFileTopLevelScope
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
-import org.jetbrains.kotlin.idea.references.JetMultiReference
+import org.jetbrains.kotlin.idea.references.KtMultiReference
 import org.jetbrains.kotlin.kdoc.parser.KDocKnownTag
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocLink
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocName
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocTag
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.FunctionDescriptorUtil
@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.resolve.scopes.utils.asJetScope
 import org.jetbrains.kotlin.resolve.scopes.utils.memberScopeAsFileScope
 import org.jetbrains.kotlin.resolve.source.PsiSourceElement
 
-public class KDocReference(element: KDocName): JetMultiReference<KDocName>(element) {
+public class KDocReference(element: KDocName): KtMultiReference<KDocName>(element) {
     override fun getTargetDescriptors(context: BindingContext): Collection<DeclarationDescriptor> {
         val declaration = getElement().getContainingDoc().getOwner()
         if (declaration == null) {
@@ -127,7 +127,7 @@ private fun resolveParamLink(fromDescriptor: DeclarationDescriptor, qualifiedNam
     return getParamDescriptors(fromDescriptor).filter { it.getName().asString() == name }
 }
 
-private fun getPackageInnerScope(descriptor: PackageFragmentDescriptor): JetScope {
+private fun getPackageInnerScope(descriptor: PackageFragmentDescriptor): KtScope {
     return descriptor.getContainingDeclaration().getPackage(descriptor.fqName).memberScope
 }
 
@@ -176,7 +176,7 @@ public fun getResolutionScope(resolutionFacade: ResolutionFacade, descriptor: De
 private fun getOuterScope(descriptor: DeclarationDescriptorWithSource, resolutionFacade: ResolutionFacade): LexicalScope {
     val parent = descriptor.getContainingDeclaration()
     if (parent is PackageFragmentDescriptor) {
-        val containingFile = (descriptor.getSource() as? PsiSourceElement)?.psi?.getContainingFile() as? JetFile
+        val containingFile = (descriptor.getSource() as? PsiSourceElement)?.psi?.getContainingFile() as? KtFile
         if (containingFile != null) {
             return resolutionFacade.getFileTopLevelScope(containingFile)
         }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/IdeaLocalDescriptorResolver.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/IdeaLocalDescriptorResolver.kt
index 8c6442edb1d..de408b5ec52 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/IdeaLocalDescriptorResolver.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/IdeaLocalDescriptorResolver.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.idea.project
 
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.lazy.LocalDescriptorResolver
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.resolve.lazy.NoDescriptorForDeclarationException
 public class IdeaLocalDescriptorResolver(
         private val resolveElementCache: ResolveElementCache
 ): LocalDescriptorResolver {
-    override fun resolveLocalDeclaration(declaration: JetDeclaration): DeclarationDescriptor {
+    override fun resolveLocalDeclaration(declaration: KtDeclaration): DeclarationDescriptor {
         val context = resolveElementCache.resolveToElement(declaration, BodyResolveMode.FULL)
         return context.get(BindingContext.DECLARATION_TO_DESCRIPTOR, declaration)
             ?: throw NoDescriptorForDeclarationException(declaration)
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt
index 1397faa9bf8..7fe8f556ba1 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt
@@ -16,8 +16,8 @@
 
 package org.jetbrains.kotlin.idea.project
 
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.resolve.TargetPlatform
 
-val JetElement.platform: TargetPlatform
+val KtElement.platform: TargetPlatform
     get() = TargetPlatformDetector.getPlatform(getContainingJetFile())
\ No newline at end of file
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ProjectStructureUtil.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ProjectStructureUtil.java
index 163e6a900e7..e2b5257e0a1 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ProjectStructureUtil.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ProjectStructureUtil.java
@@ -35,10 +35,10 @@ import com.intellij.psi.util.CachedValuesManager;
 import com.intellij.util.Processor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.idea.framework.JsLibraryStdDetectionUtil;
 import org.jetbrains.kotlin.idea.versions.KotlinRuntimeLibraryCoreUtil;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 
 import java.util.HashSet;
 import java.util.Set;
@@ -51,7 +51,7 @@ public class ProjectStructureUtil {
     private ProjectStructureUtil() {
     }
 
-    public static boolean isJsKotlinModule(@NotNull JetFile file) {
+    public static boolean isJsKotlinModule(@NotNull KtFile file) {
         Module module = ModuleUtilCore.findModuleForPsiElement(file);
         return module != null && isJsKotlinModule(module);
     }
@@ -158,10 +158,10 @@ public class ProjectStructureUtil {
     }
 
     public static boolean hasKotlinFilesInSources(@NotNull Module module) {
-        return FileTypeIndex.containsFileOfType(JetFileType.INSTANCE, module.getModuleScope(false));
+        return FileTypeIndex.containsFileOfType(KotlinFileType.INSTANCE, module.getModuleScope(false));
     }
 
     public static boolean hasKotlinFilesOnlyInTests(@NotNull Module module) {
-        return !hasKotlinFilesInSources(module) && FileTypeIndex.containsFileOfType(JetFileType.INSTANCE, module.getModuleScope(true));
+        return !hasKotlinFilesInSources(module) && FileTypeIndex.containsFileOfType(KotlinFileType.INSTANCE, module.getModuleScope(true));
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt
index 97deca442f6..e089a7a3891 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt
@@ -51,16 +51,16 @@ public class ResolveElementCache(
         private val targetPlatform: TargetPlatform,
         private val codeFragmentAnalyzer: CodeFragmentAnalyzer
 ) : BodyResolveCache {
-    private class CachedFullResolve(val bindingContext: BindingContext, resolveElement: JetElement) {
+    private class CachedFullResolve(val bindingContext: BindingContext, resolveElement: KtElement) {
         private val modificationStamp: Long? = modificationStamp(resolveElement)
 
-        fun isUpToDate(resolveElement: JetElement) = modificationStamp == modificationStamp(resolveElement)
+        fun isUpToDate(resolveElement: KtElement) = modificationStamp == modificationStamp(resolveElement)
 
-        private fun modificationStamp(resolveElement: JetElement): Long? {
+        private fun modificationStamp(resolveElement: KtElement): Long? {
             val file = resolveElement.containingFile
             return if (!file.isPhysical) // for non-physical file we don't get OUT_OF_CODE_BLOCK_MODIFICATION_COUNT increased and must reset data on any modification of the file
                 file.modificationStamp
-            else if (resolveElement is JetDeclaration && KotlinCodeBlockModificationListener.isBlockDeclaration(resolveElement))
+            else if (resolveElement is KtDeclaration && KotlinCodeBlockModificationListener.isBlockDeclaration(resolveElement))
                 resolveElement.getModificationStamp()
             else
                 null
@@ -68,22 +68,22 @@ public class ResolveElementCache(
     }
 
     // drop whole cache after change "out of code block"
-    private val fullResolveCache: CachedValue<MutableMap<JetElement, CachedFullResolve>> = CachedValuesManager.getManager(project).createCachedValue(
-            object : CachedValueProvider<MutableMap<JetElement, CachedFullResolve>> {
-                override fun compute(): CachedValueProvider.Result<MutableMap<JetElement, CachedFullResolve>> {
-                    return CachedValueProvider.Result.create(ContainerUtil.createConcurrentSoftValueMap<JetElement, CachedFullResolve>(),
+    private val fullResolveCache: CachedValue<MutableMap<KtElement, CachedFullResolve>> = CachedValuesManager.getManager(project).createCachedValue(
+            object : CachedValueProvider<MutableMap<KtElement, CachedFullResolve>> {
+                override fun compute(): CachedValueProvider.Result<MutableMap<KtElement, CachedFullResolve>> {
+                    return CachedValueProvider.Result.create(ContainerUtil.createConcurrentSoftValueMap<KtElement, CachedFullResolve>(),
                                                              PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT,
                                                              resolveSession.exceptionTracker)
                 }
             },
             false)
 
-    private class CachedPartialResolve(val bindingContext: BindingContext, file: JetFile) {
+    private class CachedPartialResolve(val bindingContext: BindingContext, file: KtFile) {
         private val modificationStamp: Long? = modificationStamp(file)
 
-        fun isUpToDate(file: JetFile) = modificationStamp == modificationStamp(file)
+        fun isUpToDate(file: KtFile) = modificationStamp == modificationStamp(file)
 
-        private fun modificationStamp(file: JetFile): Long? {
+        private fun modificationStamp(file: KtFile): Long? {
             return if (!file.isPhysical) // for non-physical file we don't get MODIFICATION_COUNT increased and must reset data on any modification of the file
                 file.modificationStamp
             else
@@ -91,10 +91,10 @@ public class ResolveElementCache(
         }
     }
 
-    private val partialBodyResolveCache: CachedValue<MutableMap<JetExpression, CachedPartialResolve>> = CachedValuesManager.getManager(project).createCachedValue(
-            object : CachedValueProvider<MutableMap<JetExpression, CachedPartialResolve>> {
-                override fun compute(): CachedValueProvider.Result<MutableMap<JetExpression, CachedPartialResolve>> {
-                    return CachedValueProvider.Result.create(ContainerUtil.createConcurrentSoftValueMap<JetExpression, CachedPartialResolve>(),
+    private val partialBodyResolveCache: CachedValue<MutableMap<KtExpression, CachedPartialResolve>> = CachedValuesManager.getManager(project).createCachedValue(
+            object : CachedValueProvider<MutableMap<KtExpression, CachedPartialResolve>> {
+                override fun compute(): CachedValueProvider.Result<MutableMap<KtExpression, CachedPartialResolve>> {
+                    return CachedValueProvider.Result.create(ContainerUtil.createConcurrentSoftValueMap<KtExpression, CachedPartialResolve>(),
                                                              PsiModificationTracker.MODIFICATION_COUNT,
                                                              resolveSession.exceptionTracker)
                 }
@@ -109,11 +109,11 @@ public class ResolveElementCache(
         }
     }
 
-    override fun resolveFunctionBody(function: JetNamedFunction)
+    override fun resolveFunctionBody(function: KtNamedFunction)
             = getElementAdditionalResolve(function, function, BodyResolveMode.FULL)
 
 
-    fun getElementAdditionalResolve(resolveElement: JetElement, contextElement: JetElement, bodyResolveMode: BodyResolveMode): BindingContext {
+    fun getElementAdditionalResolve(resolveElement: KtElement, contextElement: KtElement, bodyResolveMode: BodyResolveMode): BindingContext {
         // check if full additional resolve already performed and is up-to-date
         val fullResolveMap = fullResolveCache.value
         val cachedFullResolve = fullResolveMap[resolveElement]
@@ -134,7 +134,7 @@ public class ResolveElementCache(
             }
 
             BodyResolveMode.PARTIAL -> {
-                if (resolveElement !is JetDeclaration) {
+                if (resolveElement !is KtDeclaration) {
                     return getElementAdditionalResolve(resolveElement, contextElement, BodyResolveMode.FULL)
                 }
 
@@ -165,7 +165,7 @@ public class ResolveElementCache(
             }
 
             BodyResolveMode.PARTIAL_FOR_COMPLETION -> {
-                if (resolveElement !is JetDeclaration) {
+                if (resolveElement !is KtDeclaration) {
                     return getElementAdditionalResolve(resolveElement, contextElement, BodyResolveMode.FULL)
                 }
 
@@ -175,12 +175,12 @@ public class ResolveElementCache(
         }
     }
 
-    public fun resolveToElement(element: JetElement, bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL): BindingContext {
+    public fun resolveToElement(element: KtElement, bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL): BindingContext {
         var contextElement = element
 
         val elementOfAdditionalResolve = findElementOfAdditionalResolve(contextElement)
 
-        if (elementOfAdditionalResolve is JetParameter) {
+        if (elementOfAdditionalResolve is KtParameter) {
             // Parameters for function literal could be met inside other parameters. We can't make resolveToDescriptors for internal elements.
             contextElement = elementOfAdditionalResolve
         }
@@ -188,8 +188,8 @@ public class ResolveElementCache(
             return getElementAdditionalResolve(elementOfAdditionalResolve, contextElement, bodyResolveMode)
         }
 
-        val declaration = contextElement.getParentOfType<JetDeclaration>(false)
-        if (declaration != null && declaration !is JetClassInitializer) {
+        val declaration = contextElement.getParentOfType<KtDeclaration>(false)
+        if (declaration != null && declaration !is KtClassInitializer) {
             // Activate descriptor resolution
             resolveSession.resolveToDescriptor(declaration)
         }
@@ -197,37 +197,37 @@ public class ResolveElementCache(
         return resolveSession.getBindingContext()
     }
 
-    private fun findElementOfAdditionalResolve(element: JetElement): JetElement? {
-        val elementOfAdditionalResolve = JetPsiUtil.getTopmostParentOfTypes(
+    private fun findElementOfAdditionalResolve(element: KtElement): KtElement? {
+        val elementOfAdditionalResolve = KtPsiUtil.getTopmostParentOfTypes(
                 element,
-                javaClass<JetNamedFunction>(),
-                javaClass<JetClassInitializer>(),
-                javaClass<JetSecondaryConstructor>(),
-                javaClass<JetProperty>(),
-                javaClass<JetParameter>(),
-                javaClass<JetDelegationSpecifierList>(),
-                javaClass<JetInitializerList>(),
-                javaClass<JetImportList>(),
-                javaClass<JetAnnotationEntry>(),
-                javaClass<JetTypeParameter>(),
-                javaClass<JetTypeConstraint>(),
-                javaClass<JetPackageDirective>(),
-                javaClass<JetCodeFragment>()) as JetElement?
+                javaClass<KtNamedFunction>(),
+                javaClass<KtClassInitializer>(),
+                javaClass<KtSecondaryConstructor>(),
+                javaClass<KtProperty>(),
+                javaClass<KtParameter>(),
+                javaClass<KtDelegationSpecifierList>(),
+                javaClass<KtInitializerList>(),
+                javaClass<KtImportList>(),
+                javaClass<KtAnnotationEntry>(),
+                javaClass<KtTypeParameter>(),
+                javaClass<KtTypeConstraint>(),
+                javaClass<KtPackageDirective>(),
+                javaClass<KtCodeFragment>()) as KtElement?
 
         when (elementOfAdditionalResolve) {
             null -> {
                 // Case of JetAnnotationEntry on top level class
-                if (element is JetAnnotationEntry) {
+                if (element is KtAnnotationEntry) {
                     return element
                 }
 
                 return null
             }
 
-            is JetPackageDirective -> return element
+            is KtPackageDirective -> return element
 
-            is JetParameter -> {
-                val klass = elementOfAdditionalResolve.getParentOfType<JetClass>(strict = true)
+            is KtParameter -> {
+                val klass = elementOfAdditionalResolve.getParentOfType<KtClass>(strict = true)
                 if (klass != null && elementOfAdditionalResolve.getParent() == klass.getPrimaryConstructorParameterList()) {
                     return klass
                 }
@@ -239,17 +239,17 @@ public class ResolveElementCache(
         }
     }
 
-    private fun performElementAdditionalResolve(resolveElement: JetElement, contextElement: JetElement, bodyResolveMode: BodyResolveMode): Pair<BindingContext, StatementFilter> {
+    private fun performElementAdditionalResolve(resolveElement: KtElement, contextElement: KtElement, bodyResolveMode: BodyResolveMode): Pair<BindingContext, StatementFilter> {
         val file = resolveElement.getContainingJetFile()
 
         var statementFilterUsed = StatementFilter.NONE
 
         fun createStatementFilter(): StatementFilter {
-            assert(resolveElement is JetDeclaration)
+            assert(resolveElement is KtDeclaration)
             if (bodyResolveMode != BodyResolveMode.FULL) {
                 statementFilterUsed = PartialBodyResolveFilter(
                         contextElement,
-                        resolveElement as JetDeclaration,
+                        resolveElement as KtDeclaration,
                         probablyNothingCallableNames(),
                         bodyResolveMode == BodyResolveMode.PARTIAL_FOR_COMPLETION)
             }
@@ -257,36 +257,36 @@ public class ResolveElementCache(
         }
 
         val trace: BindingTrace = when (resolveElement) {
-            is JetNamedFunction -> functionAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter())
+            is KtNamedFunction -> functionAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter())
 
-            is JetClassInitializer -> initializerAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter())
+            is KtClassInitializer -> initializerAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter())
 
-            is JetSecondaryConstructor -> secondaryConstructorAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter())
+            is KtSecondaryConstructor -> secondaryConstructorAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter())
 
-            is JetProperty -> propertyAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter())
+            is KtProperty -> propertyAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter())
 
-            is JetDelegationSpecifierList -> delegationSpecifierAdditionalResolve(resolveSession, resolveElement, resolveElement.getParent() as JetClassOrObject, file)
+            is KtDelegationSpecifierList -> delegationSpecifierAdditionalResolve(resolveSession, resolveElement, resolveElement.getParent() as KtClassOrObject, file)
 
-            is JetInitializerList -> delegationSpecifierAdditionalResolve(resolveSession, resolveElement, resolveElement.getParent() as JetEnumEntry, file)
+            is KtInitializerList -> delegationSpecifierAdditionalResolve(resolveSession, resolveElement, resolveElement.getParent() as KtEnumEntry, file)
 
-            is JetImportList -> {
+            is KtImportList -> {
                 val scope = resolveSession.getFileScopeProvider().getFileScope(resolveElement.getContainingJetFile())
                 scope.forceResolveAllImports()
                 resolveSession.trace
             }
 
-            is JetAnnotationEntry -> annotationAdditionalResolve(resolveSession, resolveElement)
+            is KtAnnotationEntry -> annotationAdditionalResolve(resolveSession, resolveElement)
 
-            is JetClass -> constructorAdditionalResolve(resolveSession, resolveElement, file)
+            is KtClass -> constructorAdditionalResolve(resolveSession, resolveElement, file)
 
-            is JetTypeParameter -> typeParameterAdditionalResolve(resolveSession, resolveElement)
+            is KtTypeParameter -> typeParameterAdditionalResolve(resolveSession, resolveElement)
 
-            is JetTypeConstraint -> typeConstraintAdditionalResolve(resolveSession, resolveElement)
+            is KtTypeConstraint -> typeConstraintAdditionalResolve(resolveSession, resolveElement)
 
-            is JetCodeFragment -> codeFragmentAdditionalResolve(resolveSession, resolveElement, bodyResolveMode)
+            is KtCodeFragment -> codeFragmentAdditionalResolve(resolveSession, resolveElement, bodyResolveMode)
 
             else -> {
-                if (resolveElement.getParentOfType<JetPackageDirective>(true) != null) {
+                if (resolveElement.getParentOfType<KtPackageDirective>(true) != null) {
                     packageRefAdditionalResolve(resolveSession, resolveElement)
                 }
                 else {
@@ -302,22 +302,22 @@ public class ResolveElementCache(
         return Pair(trace.getBindingContext(), statementFilterUsed)
     }
 
-    private fun packageRefAdditionalResolve(resolveSession: ResolveSession, jetElement: JetElement): BindingTrace {
-        val trace = createDelegatingTrace(jetElement)
+    private fun packageRefAdditionalResolve(resolveSession: ResolveSession, ktElement: KtElement): BindingTrace {
+        val trace = createDelegatingTrace(ktElement)
 
-        if (jetElement is JetSimpleNameExpression) {
-            val header = jetElement.getParentOfType<JetPackageDirective>(true)!!
+        if (ktElement is KtSimpleNameExpression) {
+            val header = ktElement.getParentOfType<KtPackageDirective>(true)!!
 
-            if (trace.getBindingContext()[BindingContext.RESOLUTION_SCOPE, jetElement] == null) {
-                val scope = resolveSession.getModuleDescriptor().getPackage(header.getFqName(jetElement).parent()).memberScope
-                trace.record(BindingContext.RESOLUTION_SCOPE, jetElement, scope)
+            if (trace.getBindingContext()[BindingContext.RESOLUTION_SCOPE, ktElement] == null) {
+                val scope = resolveSession.getModuleDescriptor().getPackage(header.getFqName(ktElement).parent()).memberScope
+                trace.record(BindingContext.RESOLUTION_SCOPE, ktElement, scope)
             }
 
-            if (Name.isValidIdentifier(jetElement.getReferencedName())) {
-                if (trace.getBindingContext()[BindingContext.REFERENCE_TARGET, jetElement] == null) {
-                    val fqName = header.getFqName(jetElement)
+            if (Name.isValidIdentifier(ktElement.getReferencedName())) {
+                if (trace.getBindingContext()[BindingContext.REFERENCE_TARGET, ktElement] == null) {
+                    val fqName = header.getFqName(ktElement)
                     val packageDescriptor = resolveSession.getModuleDescriptor().getPackage(fqName)
-                    trace.record(BindingContext.REFERENCE_TARGET, jetElement, packageDescriptor)
+                    trace.record(BindingContext.REFERENCE_TARGET, ktElement, packageDescriptor)
                 }
             }
         }
@@ -325,8 +325,8 @@ public class ResolveElementCache(
         return trace
     }
 
-    private fun typeConstraintAdditionalResolve(analyzer: KotlinCodeAnalyzer, jetTypeConstraint: JetTypeConstraint): BindingTrace {
-        val declaration = jetTypeConstraint.getParentOfType<JetDeclaration>(true)!!
+    private fun typeConstraintAdditionalResolve(analyzer: KotlinCodeAnalyzer, jetTypeConstraint: KtTypeConstraint): BindingTrace {
+        val declaration = jetTypeConstraint.getParentOfType<KtDeclaration>(true)!!
         val descriptor = analyzer.resolveToDescriptor(declaration) as ClassDescriptor
 
         for (parameterDescriptor in descriptor.getTypeConstructor().getParameters()) {
@@ -336,7 +336,7 @@ public class ResolveElementCache(
         return resolveSession.trace
     }
 
-    private fun codeFragmentAdditionalResolve(resolveSession: ResolveSession, codeFragment: JetCodeFragment, bodyResolveMode: BodyResolveMode): BindingTrace {
+    private fun codeFragmentAdditionalResolve(resolveSession: ResolveSession, codeFragment: KtCodeFragment, bodyResolveMode: BodyResolveMode): BindingTrace {
         val trace = createDelegatingTrace(codeFragment)
 
         val contextResolveMode = if (bodyResolveMode == BodyResolveMode.PARTIAL)
@@ -348,18 +348,18 @@ public class ResolveElementCache(
         return trace
     }
 
-    private fun annotationAdditionalResolve(resolveSession: ResolveSession, jetAnnotationEntry: JetAnnotationEntry): BindingTrace {
-        val modifierList = jetAnnotationEntry.getParentOfType<JetModifierList>(true)
-        val declaration = modifierList?.getParentOfType<JetDeclaration>(true)
+    private fun annotationAdditionalResolve(resolveSession: ResolveSession, ktAnnotationEntry: KtAnnotationEntry): BindingTrace {
+        val modifierList = ktAnnotationEntry.getParentOfType<KtModifierList>(true)
+        val declaration = modifierList?.getParentOfType<KtDeclaration>(true)
         if (declaration != null) {
             doResolveAnnotations(getAnnotationsByDeclaration(resolveSession, modifierList!!, declaration))
         }
         else {
-            val fileAnnotationList = jetAnnotationEntry.getParentOfType<JetFileAnnotationList>(true)
+            val fileAnnotationList = ktAnnotationEntry.getParentOfType<KtFileAnnotationList>(true)
             if (fileAnnotationList != null) {
                 doResolveAnnotations(resolveSession.getFileAnnotations(fileAnnotationList.getContainingJetFile()))
             }
-            if (modifierList != null && modifierList.getParent() is JetFile) {
+            if (modifierList != null && modifierList.getParent() is KtFile) {
                 doResolveAnnotations(resolveSession.getDanglingAnnotations(modifierList.getContainingJetFile()))
             }
         }
@@ -371,31 +371,31 @@ public class ResolveElementCache(
         ForceResolveUtil.forceResolveAllContents(annotations)
     }
 
-    private fun getAnnotationsByDeclaration(resolveSession: ResolveSession, modifierList: JetModifierList, declaration: JetDeclaration): Annotations {
+    private fun getAnnotationsByDeclaration(resolveSession: ResolveSession, modifierList: KtModifierList, declaration: KtDeclaration): Annotations {
         var descriptor = resolveSession.resolveToDescriptor(declaration)
-        if (declaration is JetClass) {
+        if (declaration is KtClass) {
             if (modifierList == declaration.getPrimaryConstructorModifierList()) {
                 descriptor = (descriptor as ClassDescriptor).getUnsubstitutedPrimaryConstructor()
                              ?: error("No constructor found: ${declaration.getText()}")
             }
         }
 
-        if (declaration is JetClassOrObject && modifierList.getParent() == declaration.getBody() && descriptor is LazyClassDescriptor) {
+        if (declaration is KtClassOrObject && modifierList.getParent() == declaration.getBody() && descriptor is LazyClassDescriptor) {
             return descriptor.getDanglingAnnotations()
         }
 
         return descriptor.getAnnotations()
     }
 
-    private fun typeParameterAdditionalResolve(analyzer: KotlinCodeAnalyzer, typeParameter: JetTypeParameter): BindingTrace {
+    private fun typeParameterAdditionalResolve(analyzer: KotlinCodeAnalyzer, typeParameter: KtTypeParameter): BindingTrace {
         val descriptor = analyzer.resolveToDescriptor(typeParameter)
         ForceResolveUtil.forceResolveAllContents(descriptor)
 
         return resolveSession.trace
     }
 
-    private fun delegationSpecifierAdditionalResolve(resolveSession: ResolveSession, jetElement: JetElement, classOrObject: JetClassOrObject, file: JetFile): BindingTrace {
-        val trace = createDelegatingTrace(jetElement)
+    private fun delegationSpecifierAdditionalResolve(resolveSession: ResolveSession, ktElement: KtElement, classOrObject: KtClassOrObject, file: KtFile): BindingTrace {
+        val trace = createDelegatingTrace(ktElement)
         val descriptor = resolveSession.resolveToDescriptor(classOrObject) as LazyClassDescriptor
 
         // Activate resolving of supertypes
@@ -412,7 +412,7 @@ public class ResolveElementCache(
         return trace
     }
 
-    private fun propertyAdditionalResolve(resolveSession: ResolveSession, jetProperty: JetProperty, file: JetFile, statementFilter: StatementFilter): BindingTrace {
+    private fun propertyAdditionalResolve(resolveSession: ResolveSession, jetProperty: KtProperty, file: KtFile, statementFilter: StatementFilter): BindingTrace {
         val trace = createDelegatingTrace(jetProperty)
         val propertyResolutionScope = resolveSession.getDeclarationScopeProvider().getResolutionScopeForDeclaration(jetProperty)
 
@@ -444,7 +444,7 @@ public class ResolveElementCache(
         return trace
     }
 
-    private fun functionAdditionalResolve(resolveSession: ResolveSession, namedFunction: JetNamedFunction, file: JetFile, statementFilter: StatementFilter): BindingTrace {
+    private fun functionAdditionalResolve(resolveSession: ResolveSession, namedFunction: KtNamedFunction, file: KtFile, statementFilter: StatementFilter): BindingTrace {
         val trace = createDelegatingTrace(namedFunction)
 
         val scope = resolveSession.getDeclarationScopeProvider().getResolutionScopeForDeclaration(namedFunction)
@@ -457,7 +457,7 @@ public class ResolveElementCache(
         return trace
     }
 
-    private fun secondaryConstructorAdditionalResolve(resolveSession: ResolveSession, constructor: JetSecondaryConstructor, file: JetFile, statementFilter: StatementFilter): BindingTrace {
+    private fun secondaryConstructorAdditionalResolve(resolveSession: ResolveSession, constructor: KtSecondaryConstructor, file: KtFile, statementFilter: StatementFilter): BindingTrace {
         val trace = createDelegatingTrace(constructor)
 
         val scope = resolveSession.getDeclarationScopeProvider().getResolutionScopeForDeclaration(constructor)
@@ -470,7 +470,7 @@ public class ResolveElementCache(
         return trace
     }
 
-    private fun constructorAdditionalResolve(resolveSession: ResolveSession, klass: JetClass, file: JetFile): BindingTrace {
+    private fun constructorAdditionalResolve(resolveSession: ResolveSession, klass: KtClass, file: KtFile): BindingTrace {
         val trace = createDelegatingTrace(klass)
         val scope = resolveSession.getDeclarationScopeProvider().getResolutionScopeForDeclaration(klass)
 
@@ -484,10 +484,10 @@ public class ResolveElementCache(
         return trace
     }
 
-    private fun initializerAdditionalResolve(resolveSession: ResolveSession, classInitializer: JetClassInitializer, file: JetFile, statementFilter: StatementFilter): BindingTrace {
+    private fun initializerAdditionalResolve(resolveSession: ResolveSession, classInitializer: KtClassInitializer, file: KtFile, statementFilter: StatementFilter): BindingTrace {
         val trace = createDelegatingTrace(classInitializer)
 
-        val classOrObject = classInitializer.getParentOfType<JetClassOrObject>(true)!!
+        val classOrObject = classInitializer.getParentOfType<KtClassOrObject>(true)!!
         val classOrObjectDescriptor = resolveSession.resolveToDescriptor(classOrObject) as LazyClassDescriptor
 
         val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter)
@@ -499,7 +499,7 @@ public class ResolveElementCache(
     private fun createBodyResolver(
             resolveSession: ResolveSession,
             trace: BindingTrace,
-            file: JetFile,
+            file: KtFile,
             statementFilter: StatementFilter
     ): BodyResolver {
         val globalContext = SimpleGlobalContext(resolveSession.storageManager, resolveSession.getExceptionTracker())
@@ -513,30 +513,30 @@ public class ResolveElementCache(
     }
 
     // All additional resolve should be done to separate trace
-    private fun createDelegatingTrace(resolveElement: JetElement): BindingTrace {
+    private fun createDelegatingTrace(resolveElement: KtElement): BindingTrace {
         return resolveSession.storageManager.createSafeTrace(
                 DelegatingBindingTrace(resolveSession.getBindingContext(), "trace to resolve element", resolveElement))
     }
 
     private class BodyResolveContextForLazy(
             private val topDownAnalysisMode: TopDownAnalysisMode,
-            private val declaringScopes: Function1<JetDeclaration, LexicalScope?>
+            private val declaringScopes: Function1<KtDeclaration, LexicalScope?>
     ) : BodiesResolveContext {
-        override fun getFiles(): Collection<JetFile> = setOf()
+        override fun getFiles(): Collection<KtFile> = setOf()
 
-        override fun getDeclaredClasses(): MutableMap<JetClassOrObject, ClassDescriptorWithResolutionScopes> = hashMapOf()
+        override fun getDeclaredClasses(): MutableMap<KtClassOrObject, ClassDescriptorWithResolutionScopes> = hashMapOf()
 
-        override fun getAnonymousInitializers(): MutableMap<JetClassInitializer, ClassDescriptorWithResolutionScopes> = hashMapOf()
+        override fun getAnonymousInitializers(): MutableMap<KtClassInitializer, ClassDescriptorWithResolutionScopes> = hashMapOf()
 
-        override fun getSecondaryConstructors(): MutableMap<JetSecondaryConstructor, ConstructorDescriptor> = hashMapOf()
+        override fun getSecondaryConstructors(): MutableMap<KtSecondaryConstructor, ConstructorDescriptor> = hashMapOf()
 
-        override fun getProperties(): MutableMap<JetProperty, PropertyDescriptor> = hashMapOf()
+        override fun getProperties(): MutableMap<KtProperty, PropertyDescriptor> = hashMapOf()
 
-        override fun getFunctions(): MutableMap<JetNamedFunction, SimpleFunctionDescriptor> = hashMapOf()
+        override fun getFunctions(): MutableMap<KtNamedFunction, SimpleFunctionDescriptor> = hashMapOf()
 
-        override fun getDeclaringScope(declaration: JetDeclaration): LexicalScope? = declaringScopes(declaration)
+        override fun getDeclaringScope(declaration: KtDeclaration): LexicalScope? = declaringScopes(declaration)
 
-        override fun getScripts(): MutableMap<JetScript, ScriptDescriptor> = hashMapOf()
+        override fun getScripts(): MutableMap<KtScript, ScriptDescriptor> = hashMapOf()
 
         override fun getOuterDataFlowInfo(): DataFlowInfo = DataFlowInfo.EMPTY
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/TargetPlatformDetector.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/TargetPlatformDetector.java
index 0a42b074ce5..65312035e0d 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/TargetPlatformDetector.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/TargetPlatformDetector.java
@@ -22,7 +22,7 @@ import com.intellij.openapi.roots.ProjectFileIndex;
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.js.resolve.JsPlatform;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.TargetPlatform;
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
 
@@ -34,7 +34,7 @@ public class TargetPlatformDetector {
     }
 
     @NotNull
-    public static TargetPlatform getPlatform(@NotNull JetFile file) {
+    public static TargetPlatform getPlatform(@NotNull KtFile file) {
         VirtualFile virtualFile = file.getOriginalFile().getVirtualFile();
         if (virtualFile == null) {
             return getDefaultPlatform();
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/JetIntentionActionsFactory.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/JetIntentionActionsFactory.kt
index 843d9880993..65ad9587a3a 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/JetIntentionActionsFactory.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/JetIntentionActionsFactory.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.quickfix
 
 import com.intellij.codeInsight.intention.IntentionAction
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.psi.JetCodeFragment
+import org.jetbrains.kotlin.psi.KtCodeFragment
 import java.util.Collections
 
 // TODO: Replace with trait when all subclasses are translated to Kotlin
@@ -27,7 +27,7 @@ public abstract class JetIntentionActionsFactory {
     protected abstract fun doCreateActions(diagnostic: Diagnostic): List<IntentionAction>
 
     public fun createActions(diagnostic: Diagnostic): List<IntentionAction> {
-        if (diagnostic.getPsiElement().getContainingFile() is JetCodeFragment && !isApplicableForCodeFragment()) {
+        if (diagnostic.getPsiElement().getContainingFile() is KtCodeFragment && !isApplicableForCodeFragment()) {
             return emptyList()
         }
         return doCreateActions(diagnostic)
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/KotlinSuppressIntentionAction.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/KotlinSuppressIntentionAction.kt
index 1f9a2f3eb14..e1b59ae539b 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/KotlinSuppressIntentionAction.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/KotlinSuppressIntentionAction.kt
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.idea.util.JetPsiPrecedences
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 
 public class KotlinSuppressIntentionAction(
-        private val suppressAt: JetExpression,
+        private val suppressAt: KtExpression,
         private val diagnosticFactory: DiagnosticFactory<*>,
         private val kind: AnnotationHostKind
 ) : SuppressIntentionAction() {
@@ -41,24 +41,24 @@ public class KotlinSuppressIntentionAction(
 
     override fun invoke(project: Project, editor: Editor?, element: PsiElement) {
         val id = "\"${diagnosticFactory.getName()}\""
-        if (suppressAt is JetModifierListOwner) {
+        if (suppressAt is KtModifierListOwner) {
             suppressAtModifierListOwner(suppressAt, id)
         }
-        else if (suppressAt is JetAnnotatedExpression) {
+        else if (suppressAt is KtAnnotatedExpression) {
             suppressAtAnnotatedExpression(CaretBox(suppressAt, editor), id)
         }
-        else if (suppressAt is JetExpression) {
+        else if (suppressAt is KtExpression) {
             suppressAtExpression(CaretBox(suppressAt, editor), id)
         }
     }
 
-    private fun suppressAtModifierListOwner(suppressAt: JetModifierListOwner, id: String) {
+    private fun suppressAtModifierListOwner(suppressAt: KtModifierListOwner, id: String) {
         val modifierList = suppressAt.getModifierList()
-        val psiFactory = JetPsiFactory(suppressAt)
+        val psiFactory = KtPsiFactory(suppressAt)
         if (modifierList == null) {
             // create a modifier list from scratch
             val newModifierList = psiFactory.createModifierList(suppressAnnotationText(id))
-            val replaced = JetPsiUtil.replaceModifierList(suppressAt, newModifierList)
+            val replaced = KtPsiUtil.replaceModifierList(suppressAt, newModifierList)
             val whiteSpace = psiFactory.createWhiteSpace(kind)
             suppressAt.addAfter(whiteSpace, replaced)
         }
@@ -78,7 +78,7 @@ public class KotlinSuppressIntentionAction(
         }
     }
 
-    private fun suppressAtAnnotatedExpression(suppressAt: CaretBox<JetAnnotatedExpression>, id: String) {
+    private fun suppressAtAnnotatedExpression(suppressAt: CaretBox<KtAnnotatedExpression>, id: String) {
         val entry = findSuppressAnnotation(suppressAt.expression)
         if (entry != null) {
             // already annotated with @suppress
@@ -89,18 +89,18 @@ public class KotlinSuppressIntentionAction(
         }
     }
 
-    private fun suppressAtExpression(caretBox: CaretBox<JetExpression>, id: String) {
+    private fun suppressAtExpression(caretBox: CaretBox<KtExpression>, id: String) {
         val suppressAt = caretBox.expression
-        assert(suppressAt !is JetDeclaration) { "Declarations should have been checked for above" }
+        assert(suppressAt !is KtDeclaration) { "Declarations should have been checked for above" }
 
         val parentheses = JetPsiPrecedences.getPrecedence(suppressAt) > JetPsiPrecedences.PRECEDENCE_OF_PREFIX_EXPRESSION
         val placeholderText = "PLACEHOLDER_ID"
         val inner = if (parentheses) "($placeholderText)" else placeholderText
-        val annotatedExpression = JetPsiFactory(suppressAt).createExpression(suppressAnnotationText(id) + "\n" + inner)
+        val annotatedExpression = KtPsiFactory(suppressAt).createExpression(suppressAnnotationText(id) + "\n" + inner)
 
         val copy = suppressAt.copy()!!
 
-        val afterReplace = suppressAt.replace(annotatedExpression) as JetAnnotatedExpression
+        val afterReplace = suppressAt.replace(annotatedExpression) as KtAnnotatedExpression
         val toReplace = afterReplace.findElementAt(afterReplace.getTextLength() - 2)!!
         assert (toReplace.getText() == placeholderText)
         val result = toReplace.replace(copy)!!
@@ -108,10 +108,10 @@ public class KotlinSuppressIntentionAction(
         caretBox.positionCaretInCopy(result)
     }
 
-    private fun addArgumentToSuppressAnnotation(entry: JetAnnotationEntry, id: String) {
+    private fun addArgumentToSuppressAnnotation(entry: KtAnnotationEntry, id: String) {
         // add new arguments to an existing entry
         val args = entry.getValueArgumentList()
-        val psiFactory = JetPsiFactory(entry)
+        val psiFactory = KtPsiFactory(entry)
         val newArgList = psiFactory.createCallArguments("($id)")
         if (args == null) {
             // new argument list
@@ -128,7 +128,7 @@ public class KotlinSuppressIntentionAction(
 
     private fun suppressAnnotationText(id: String) = "@Suppress($id)"
 
-    private fun findSuppressAnnotation(annotated: JetAnnotated): JetAnnotationEntry? {
+    private fun findSuppressAnnotation(annotated: KtAnnotated): KtAnnotationEntry? {
         val context = annotated.analyze()
         for (entry in annotated.getAnnotationEntries()) {
             val annotationDescriptor = context.get(BindingContext.ANNOTATION, entry)
@@ -142,11 +142,11 @@ public class KotlinSuppressIntentionAction(
 
 public class AnnotationHostKind(val kind: String, val name: String, val newLineNeeded: Boolean)
 
-private fun JetPsiFactory.createWhiteSpace(kind: AnnotationHostKind): PsiElement {
+private fun KtPsiFactory.createWhiteSpace(kind: AnnotationHostKind): PsiElement {
     return if (kind.newLineNeeded) createNewLine() else createWhiteSpace()
 }
 
-private class CaretBox<out E: JetExpression>(
+private class CaretBox<out E: KtExpression>(
         val expression: E,
         private val editor: Editor?
 ) {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/generateUtil.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/generateUtil.kt
index 12a05139f8c..bcb8c9b9901 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/generateUtil.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/generateUtil.kt
@@ -44,9 +44,9 @@ public fun moveCaretIntoGeneratedElement(editor: Editor, element: PsiElement) {
 private fun moveCaretIntoGeneratedElementDocumentUnblocked(editor: Editor, element: PsiElement): Boolean {
     // Inspired by GenerateMembersUtils.positionCaret()
 
-    if (element is JetDeclarationWithBody && element.hasBody()) {
+    if (element is KtDeclarationWithBody && element.hasBody()) {
         val expression = element.getBodyExpression()
-        if (expression is JetBlockExpression) {
+        if (expression is KtBlockExpression) {
             val lBrace = expression.getLBrace()
             val rBrace = expression.getRBrace()
 
@@ -68,7 +68,7 @@ private fun moveCaretIntoGeneratedElementDocumentUnblocked(editor: Editor, eleme
         }
     }
 
-    if (element is JetWithExpressionInitializer && element.hasInitializer()) {
+    if (element is KtWithExpressionInitializer && element.hasInitializer()) {
         val expression = element.getInitializer()
         if (expression == null) throw AssertionError()
 
@@ -85,7 +85,7 @@ private fun moveCaretIntoGeneratedElementDocumentUnblocked(editor: Editor, eleme
         return true
     }
 
-    if (element is JetProperty) {
+    if (element is KtProperty) {
         for (accessor in element.getAccessors()) {
             if (moveCaretIntoGeneratedElementDocumentUnblocked(editor, accessor)) {
                 return true
@@ -101,7 +101,7 @@ public fun Editor.moveCaret(offset: Int, scrollType: ScrollType = ScrollType.REL
     getScrollingModel().scrollToCaret(scrollType)
 }
 
-private fun findInsertAfterAnchor(editor: Editor?, body: JetClassBody): PsiElement? {
+private fun findInsertAfterAnchor(editor: Editor?, body: KtClassBody): PsiElement? {
     val afterAnchor = body.lBrace ?: return null
 
     val offset = editor?.caretModel?.offset ?: body.startOffset
@@ -129,7 +129,7 @@ private fun removeAfterOffset(offset: Int, whiteSpace: PsiWhiteSpace): PsiElemen
             beforeWhiteSpaceText += "\n"
         }
 
-        val factory = JetPsiFactory(whiteSpace.project)
+        val factory = KtPsiFactory(whiteSpace.project)
 
         val insertAfter = whiteSpace.prevSibling
         whiteSpace.delete()
@@ -143,9 +143,9 @@ private fun removeAfterOffset(offset: Int, whiteSpace: PsiWhiteSpace): PsiElemen
     return whiteSpace
 }
 
-public fun <T : JetDeclaration> insertMembersAfter(
+public fun <T : KtDeclaration> insertMembersAfter(
         editor: Editor?,
-        classOrObject: JetClassOrObject,
+        classOrObject: KtClassOrObject,
         members: Collection<T>,
         anchor: PsiElement? = null
 ): List<T> {
@@ -170,6 +170,6 @@ public fun <T : JetDeclaration> insertMembersAfter(
     }
 }
 
-public fun <T : JetDeclaration> insertMember(editor: Editor, classOrObject: JetClassOrObject, declaration: T): T {
+public fun <T : KtDeclaration> insertMember(editor: Editor, classOrObject: KtClassOrObject, declaration: T): T {
     return insertMembersAfter(editor, classOrObject, listOf(declaration)).single()
 }
\ No newline at end of file
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/refactoring/fqName/fqNameUtil.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/refactoring/fqName/fqNameUtil.kt
index 0504689f9cc..f47209fb6aa 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/refactoring/fqName/fqNameUtil.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/refactoring/fqName/fqNameUtil.kt
@@ -22,7 +22,7 @@ import com.intellij.psi.PsiMember
 import com.intellij.psi.PsiPackage
 import org.jetbrains.kotlin.asJava.namedUnwrappedElement
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.resolve.ImportPath
 
 /**
@@ -37,7 +37,7 @@ public fun PsiElement.getKotlinFqName(): FqName? {
             val prefix = element.getContainingClass()?.getQualifiedName()
             FqName(if (prefix != null) "$prefix.$name" else name)
         }
-        is JetNamedDeclaration -> element.getFqName()
+        is KtNamedDeclaration -> element.getFqName()
         else -> null
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.kt
index 33336eba8f4..9bd83442393 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.kt
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.frontend.di.createLazyResolveSession
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 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.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
@@ -40,7 +40,7 @@ import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.descriptorUtil.classId
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 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.serialization.deserialization.findClassAcrossModuleDependencies
 import java.io.File
 import java.net.URL
@@ -49,7 +49,7 @@ public class BuiltInsReferenceResolver(val project: Project, val startupManager:
 
     @Volatile private var moduleDescriptor: ModuleDescriptor? = null
 
-    @Volatile public var builtInsSources: Set<JetFile>? = null
+    @Volatile public var builtInsSources: Set<KtFile>? = null
         private set
 
     @Volatile private var builtinsPackageFragment: PackageFragmentDescriptor? = null
@@ -85,18 +85,18 @@ public class BuiltInsReferenceResolver(val project: Project, val startupManager:
         }
     }
 
-    private fun getJetBuiltInsFiles(): Set<JetFile> {
-        return getBuiltInsDirUrls().flatMapTo(hashSetOf<JetFile>()) { getBuiltInSourceFiles(it) }
+    private fun getJetBuiltInsFiles(): Set<KtFile> {
+        return getBuiltInsDirUrls().flatMapTo(hashSetOf<KtFile>()) { getBuiltInSourceFiles(it) }
     }
 
-    private fun getBuiltInSourceFiles(url: URL): Set<JetFile> {
+    private fun getBuiltInSourceFiles(url: URL): Set<KtFile> {
         val fromUrl = VfsUtilCore.convertFromUrl(url)
         val vf = VirtualFileManager.getInstance().findFileByUrl(fromUrl)
         assert(vf != null) { "Virtual file not found by URL: $url" }
 
         val psiDirectory = PsiManager.getInstance(project).findDirectory(vf!!)
         assert(psiDirectory != null) { "No PsiDirectory for $vf" }
-        return psiDirectory!!.getFiles().filterIsInstance<JetFile>().toHashSet()
+        return psiDirectory!!.getFiles().filterIsInstance<KtFile>().toHashSet()
     }
 
     private fun findCurrentDescriptorForMember(originalDescriptor: MemberDescriptor): DeclarationDescriptor? {
@@ -166,7 +166,7 @@ public class BuiltInsReferenceResolver(val project: Project, val startupManager:
             return url != null && VfsUtilCore.isUnder(url, builtInDirUrls)
         }
 
-        private fun getMemberScope(parent: DeclarationDescriptor?): JetScope? = when(parent) {
+        private fun getMemberScope(parent: DeclarationDescriptor?): KtScope? = when(parent) {
             is ClassDescriptor -> parent.getDefaultType().getMemberScope()
             is PackageFragmentDescriptor -> parent.getMemberScope()
             else -> null
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReferenceContributor.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KotlinReferenceContributor.kt
similarity index 60%
rename from idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReferenceContributor.kt
rename to idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KotlinReferenceContributor.kt
index e8d9613845a..f63c45b2b83 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReferenceContributor.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KotlinReferenceContributor.kt
@@ -21,18 +21,18 @@ import com.intellij.psi.*
 import com.intellij.util.ProcessingContext
 import org.jetbrains.kotlin.idea.kdoc.KDocReference
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocName
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 
-public class JetReferenceContributor() : PsiReferenceContributor() {
+public class KotlinReferenceContributor() : PsiReferenceContributor() {
     public override fun registerReferenceProviders(registrar: PsiReferenceRegistrar) {
         with(registrar) {
-            registerProvider(javaClass<JetSimpleNameExpression>()) {
-                JetSimpleNameReference(it)
+            registerProvider(javaClass<KtSimpleNameExpression>()) {
+                KtSimpleNameReference(it)
             }
 
-            registerMultiProvider(javaClass<JetNameReferenceExpression>()) {
-                if (it.getReferencedNameElementType() != JetTokens.IDENTIFIER) return@registerMultiProvider emptyArray()
+            registerMultiProvider(javaClass<KtNameReferenceExpression>()) {
+                if (it.getReferencedNameElementType() != KtTokens.IDENTIFIER) return@registerMultiProvider emptyArray()
 
                 when (it.readWriteAccess(useResolveForReadWrite = false)) {
                     ReferenceAccess.READ -> arrayOf(SyntheticPropertyAccessorReference.Getter(it))
@@ -41,28 +41,28 @@ public class JetReferenceContributor() : PsiReferenceContributor() {
                 }
             }
 
-            registerProvider(javaClass<JetConstructorDelegationReferenceExpression>()) {
-                JetConstructorDelegationReference(it)
+            registerProvider(javaClass<KtConstructorDelegationReferenceExpression>()) {
+                KtConstructorDelegationReference(it)
             }
 
-            registerProvider(javaClass<JetCallExpression>()) {
-                JetInvokeFunctionReference(it)
+            registerProvider(javaClass<KtCallExpression>()) {
+                KtInvokeFunctionReference(it)
             }
 
-            registerProvider(javaClass<JetArrayAccessExpression>()) {
-                JetArrayAccessReference(it)
+            registerProvider(javaClass<KtArrayAccessExpression>()) {
+                KtArrayAccessReference(it)
             }
 
-            registerProvider(javaClass<JetForExpression>()) {
-                JetForLoopInReference(it)
+            registerProvider(javaClass<KtForExpression>()) {
+                KtForLoopInReference(it)
             }
 
-            registerProvider(javaClass<JetPropertyDelegate>()) {
-                JetPropertyDelegationMethodsReference(it)
+            registerProvider(javaClass<KtPropertyDelegate>()) {
+                KtPropertyDelegationMethodsReference(it)
             }
 
-            registerProvider(javaClass<JetMultiDeclaration>()) {
-                JetMultiDeclarationReference(it)
+            registerProvider(javaClass<KtMultiDeclaration>()) {
+                KtMultiDeclarationReference(it)
             }
 
             registerProvider(javaClass<KDocName>()) {
@@ -71,11 +71,11 @@ public class JetReferenceContributor() : PsiReferenceContributor() {
         }
     }
 
-    private fun <E : JetElement> PsiReferenceRegistrar.registerProvider(elementClass: Class<E>, factory: (E) -> JetReference) {
+    private fun <E : KtElement> PsiReferenceRegistrar.registerProvider(elementClass: Class<E>, factory: (E) -> KtReference) {
         registerMultiProvider(elementClass, { arrayOf(factory(it)) })
     }
 
-    private fun <E : JetElement> PsiReferenceRegistrar.registerMultiProvider(elementClass: Class<E>, factory: (E) -> Array<PsiReference>) {
+    private fun <E : KtElement> PsiReferenceRegistrar.registerMultiProvider(elementClass: Class<E>, factory: (E) -> Array<PsiReference>) {
         registerReferenceProvider(PlatformPatterns.psiElement(elementClass), object: PsiReferenceProvider() {
             override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
                 @Suppress("UNCHECKED_CAST")
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetArrayAccessReference.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtArrayAccessReference.java
similarity index 85%
rename from idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetArrayAccessReference.java
rename to idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtArrayAccessReference.java
index f07f838dc56..be2c34ecaa1 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetArrayAccessReference.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtArrayAccessReference.java
@@ -25,9 +25,9 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
-import org.jetbrains.kotlin.lexer.JetTokens;
-import org.jetbrains.kotlin.psi.JetArrayAccessExpression;
-import org.jetbrains.kotlin.psi.JetContainerNode;
+import org.jetbrains.kotlin.lexer.KtTokens;
+import org.jetbrains.kotlin.psi.KtArrayAccessExpression;
+import org.jetbrains.kotlin.psi.KtContainerNode;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 
@@ -38,9 +38,9 @@ import java.util.List;
 import static org.jetbrains.kotlin.resolve.BindingContext.INDEXED_LVALUE_GET;
 import static org.jetbrains.kotlin.resolve.BindingContext.INDEXED_LVALUE_SET;
 
-public class JetArrayAccessReference extends JetSimpleReference<JetArrayAccessExpression> implements MultiRangeReference {
+public class KtArrayAccessReference extends KtSimpleReference<KtArrayAccessExpression> implements MultiRangeReference {
 
-    public JetArrayAccessReference(@NotNull JetArrayAccessExpression expression) {
+    public KtArrayAccessReference(@NotNull KtArrayAccessExpression expression) {
         super(expression);
     }
 
@@ -71,13 +71,13 @@ public class JetArrayAccessReference extends JetSimpleReference<JetArrayAccessEx
     public List<TextRange> getRanges() {
         List<TextRange> list = new ArrayList<TextRange>();
 
-        JetContainerNode indices = getExpression().getIndicesNode();
-        TextRange textRange = indices.getNode().findChildByType(JetTokens.LBRACKET).getTextRange();
+        KtContainerNode indices = getExpression().getIndicesNode();
+        TextRange textRange = indices.getNode().findChildByType(KtTokens.LBRACKET).getTextRange();
         TextRange lBracketRange = textRange.shiftRight(-getExpression().getTextOffset());
 
         list.add(lBracketRange);
 
-        ASTNode rBracket = indices.getNode().findChildByType(JetTokens.RBRACKET);
+        ASTNode rBracket = indices.getNode().findChildByType(KtTokens.RBRACKET);
         if (rBracket != null) {
             textRange = rBracket.getTextRange();
             TextRange rBracketRange = textRange.shiftRight(-getExpression().getTextOffset());
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetConstructorDelegationReference.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtConstructorDelegationReference.java
similarity index 73%
rename from idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetConstructorDelegationReference.java
rename to idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtConstructorDelegationReference.java
index 209b22acf9f..ac1acdaddff 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetConstructorDelegationReference.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtConstructorDelegationReference.java
@@ -17,10 +17,10 @@
 package org.jetbrains.kotlin.idea.references;
 
 import com.intellij.openapi.util.TextRange;
-import org.jetbrains.kotlin.psi.JetConstructorDelegationReferenceExpression;
+import org.jetbrains.kotlin.psi.KtConstructorDelegationReferenceExpression;
 
-public class JetConstructorDelegationReference extends JetSimpleReference<JetConstructorDelegationReferenceExpression> {
-    public JetConstructorDelegationReference(JetConstructorDelegationReferenceExpression expression) {
+public class KtConstructorDelegationReference extends KtSimpleReference<KtConstructorDelegationReferenceExpression> {
+    public KtConstructorDelegationReference(KtConstructorDelegationReferenceExpression expression) {
         super(expression);
     }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetForLoopInReference.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtForLoopInReference.kt
similarity index 90%
rename from idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetForLoopInReference.kt
rename to idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtForLoopInReference.kt
index 8050c113b41..ae40e92a34f 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetForLoopInReference.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtForLoopInReference.kt
@@ -18,11 +18,11 @@ package org.jetbrains.kotlin.idea.references
 
 import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.psi.JetForExpression
+import org.jetbrains.kotlin.psi.KtForExpression
 import org.jetbrains.kotlin.resolve.BindingContext
-import java.util.Collections
+import java.util.*
 
-public class JetForLoopInReference(element: JetForExpression) : JetMultiReference<JetForExpression>(element) {
+public class KtForLoopInReference(element: KtForExpression) : KtMultiReference<KtForExpression>(element) {
 
     override fun getRangeInElement(): TextRange {
         val inKeywordNode = expression.getInKeywordNode()
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetInvokeFunctionReference.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtInvokeFunctionReference.java
similarity index 84%
rename from idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetInvokeFunctionReference.java
rename to idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtInvokeFunctionReference.java
index 3b8c5702ebc..6ecd4dc9cf6 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetInvokeFunctionReference.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtInvokeFunctionReference.java
@@ -23,7 +23,7 @@ import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
@@ -35,9 +35,9 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
-public class JetInvokeFunctionReference extends JetSimpleReference<JetCallExpression> implements MultiRangeReference {
+public class KtInvokeFunctionReference extends KtSimpleReference<KtCallExpression> implements MultiRangeReference {
 
-    public JetInvokeFunctionReference(@NotNull JetCallExpression expression) {
+    public KtInvokeFunctionReference(@NotNull KtCallExpression expression) {
         super(expression);
     }
 
@@ -64,16 +64,16 @@ public class JetInvokeFunctionReference extends JetSimpleReference<JetCallExpres
     @Override
     public List<TextRange> getRanges() {
         List<TextRange> list = new ArrayList<TextRange>();
-        JetValueArgumentList valueArgumentList = getExpression().getValueArgumentList();
+        KtValueArgumentList valueArgumentList = getExpression().getValueArgumentList();
         if (valueArgumentList != null) {
             if (valueArgumentList.getArguments().size() > 0) {
                 ASTNode valueArgumentListNode = valueArgumentList.getNode();
-                ASTNode lPar = valueArgumentListNode.findChildByType(JetTokens.LPAR);
+                ASTNode lPar = valueArgumentListNode.findChildByType(KtTokens.LPAR);
                 if (lPar != null) {
                     list.add(getRange(lPar));
                 }
 
-                ASTNode rPar = valueArgumentListNode.findChildByType(JetTokens.RPAR);
+                ASTNode rPar = valueArgumentListNode.findChildByType(KtTokens.RPAR);
                 if (rPar != null) {
                     list.add(getRange(rPar));
                 }
@@ -83,9 +83,9 @@ public class JetInvokeFunctionReference extends JetSimpleReference<JetCallExpres
             }
         }
 
-        List<JetFunctionLiteralArgument> functionLiteralArguments = getExpression().getFunctionLiteralArguments();
-        for (JetFunctionLiteralArgument functionLiteralArgument : functionLiteralArguments) {
-            JetFunctionLiteralExpression functionLiteralExpression = functionLiteralArgument.getFunctionLiteral();
+        List<KtFunctionLiteralArgument> functionLiteralArguments = getExpression().getFunctionLiteralArguments();
+        for (KtFunctionLiteralArgument functionLiteralArgument : functionLiteralArguments) {
+            KtFunctionLiteralExpression functionLiteralExpression = functionLiteralArgument.getFunctionLiteral();
             list.add(getRange(functionLiteralExpression.getLeftCurlyBrace()));
             ASTNode rightCurlyBrace = functionLiteralExpression.getRightCurlyBrace();
             if (rightCurlyBrace != null) {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetMultiDeclarationReference.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtMultiDeclarationReference.kt
similarity index 92%
rename from idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetMultiDeclarationReference.kt
rename to idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtMultiDeclarationReference.kt
index a601e098e63..0431491e010 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetMultiDeclarationReference.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtMultiDeclarationReference.kt
@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.idea.references
 
-import org.jetbrains.kotlin.psi.JetMultiDeclaration
+import org.jetbrains.kotlin.psi.KtMultiDeclaration
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import com.intellij.openapi.util.TextRange
@@ -25,7 +25,7 @@ import com.intellij.util.IncorrectOperationException
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 
-class JetMultiDeclarationReference(element: JetMultiDeclaration) : JetMultiReference<JetMultiDeclaration>(element) {
+class KtMultiDeclarationReference(element: KtMultiDeclaration) : KtMultiReference<KtMultiDeclaration>(element) {
     override fun getTargetDescriptors(context: BindingContext): Collection<DeclarationDescriptor> {
         return expression.getEntries().map { entry ->
             context.get(BindingContext.COMPONENT_RESOLVED_CALL, entry)?.getCandidateDescriptor()
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetPropertyDelegationMethodsReference.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtPropertyDelegationMethodsReference.kt
similarity index 86%
rename from idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetPropertyDelegationMethodsReference.kt
rename to idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtPropertyDelegationMethodsReference.kt
index 780a3cb8a3a..e3e8de66a4c 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetPropertyDelegationMethodsReference.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtPropertyDelegationMethodsReference.kt
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.idea.references
 import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetPropertyDelegate
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtPropertyDelegate
 import org.jetbrains.kotlin.resolve.BindingContext
 import java.util.Collections
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 
-public class JetPropertyDelegationMethodsReference(element: JetPropertyDelegate) : JetMultiReference<JetPropertyDelegate>(element) {
+public class KtPropertyDelegationMethodsReference(element: KtPropertyDelegate) : KtMultiReference<KtPropertyDelegate>(element) {
 
     override fun getRangeInElement(): TextRange {
         val byKeywordNode = expression.getByKeywordNode()
@@ -34,7 +34,7 @@ public class JetPropertyDelegationMethodsReference(element: JetPropertyDelegate)
     }
 
     override fun getTargetDescriptors(context: BindingContext): Collection<DeclarationDescriptor> {
-        val property = expression.getStrictParentOfType<JetProperty>()
+        val property = expression.getStrictParentOfType<KtProperty>()
         if (property == null) {
             return Collections.emptyList()
         }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReference.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtReference.kt
similarity index 87%
rename from idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReference.kt
rename to idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtReference.kt
index b214b77f639..771d4eaa772 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReference.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtReference.kt
@@ -22,22 +22,22 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetReferenceExpression
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtReferenceExpression
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.bindingContextUtil.getReferenceTargets
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
-import java.util.Collections
+import java.util.*
 
-public interface JetReference : PsiPolyVariantReference {
+public interface KtReference : PsiPolyVariantReference {
     fun resolveToDescriptors(bindingContext: BindingContext): Collection<DeclarationDescriptor>
 
-    override fun getElement(): JetElement
+    override fun getElement(): KtElement
 }
 
-public abstract class AbstractJetReference<T : JetElement>(element: T)
-: PsiPolyVariantReferenceBase<T>(element), JetReference {
+public abstract class AbstractJetReference<T : KtElement>(element: T)
+: PsiPolyVariantReferenceBase<T>(element), KtReference {
 
     public val expression: T
         get() = getElement()
@@ -107,7 +107,7 @@ public abstract class AbstractJetReference<T : JetElement>(element: T)
 
     private fun getLabelTargets(context: BindingContext): Collection<PsiElement>? {
         val reference = expression
-        if (reference !is JetReferenceExpression) {
+        if (reference !is KtReferenceExpression) {
             return null
         }
         val labelTarget = context[BindingContext.LABEL_TARGET, reference]
@@ -120,8 +120,8 @@ public abstract class AbstractJetReference<T : JetElement>(element: T)
     override fun toString() = javaClass.getSimpleName() + ": " + expression.getText()
 }
 
-public abstract class JetSimpleReference<T : JetReferenceExpression>(expression: T) : AbstractJetReference<T>(expression) {
+public abstract class KtSimpleReference<T : KtReferenceExpression>(expression: T) : AbstractJetReference<T>(expression) {
     override fun getTargetDescriptors(context: BindingContext) = expression.getReferenceTargets(context)
 }
 
-public abstract class JetMultiReference<T : JetElement>(expression: T) : AbstractJetReference<T>(expression)
+public abstract class KtMultiReference<T : KtElement>(expression: T) : AbstractJetReference<T>(expression)
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetSimpleNameReference.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtSimpleNameReference.kt
similarity index 78%
rename from idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetSimpleNameReference.kt
rename to idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtSimpleNameReference.kt
index 23a9785aaa3..acb7994db22 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetSimpleNameReference.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtSimpleNameReference.kt
@@ -25,8 +25,8 @@ import org.jetbrains.kotlin.idea.codeInsight.shorten.addToShorteningWaitSet
 import org.jetbrains.kotlin.idea.intentions.OperatorToFunctionIntention
 import org.jetbrains.kotlin.idea.refactoring.fqName.getKotlinFqName
 import org.jetbrains.kotlin.idea.util.ShortenReferences
-import org.jetbrains.kotlin.lexer.JetToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.isOneSegmentFQN
@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 
-class JetSimpleNameReference(expression: JetSimpleNameExpression) : JetSimpleReference<JetSimpleNameExpression>(expression) {
+class KtSimpleNameReference(expression: KtSimpleNameExpression) : KtSimpleReference<KtSimpleNameExpression>(expression) {
     override fun isReferenceTo(element: PsiElement?): Boolean {
         if (element != null) {
             if (!canBeReferenceTo(element)) return false
@@ -63,10 +63,10 @@ class JetSimpleNameReference(expression: JetSimpleNameExpression) : JetSimpleRef
     }
 
     override fun canRename(): Boolean {
-        if (expression.getParentOfTypeAndBranch<JetWhenConditionInRange>(strict = true){ getOperationReference() } != null) return false
+        if (expression.getParentOfTypeAndBranch<KtWhenConditionInRange>(strict = true){ getOperationReference() } != null) return false
 
         val elementType = expression.getReferencedNameElementType()
-        if (elementType == JetTokens.PLUSPLUS || elementType == JetTokens.MINUSMINUS) return false
+        if (elementType == KtTokens.PLUSPLUS || elementType == KtTokens.MINUSMINUS) return false
 
         return true
     }
@@ -78,14 +78,14 @@ class JetSimpleNameReference(expression: JetSimpleNameExpression) : JetSimpleRef
         // Do not rename if the reference corresponds to synthesized component function
         val expressionText = expression.getText()
         if (expressionText != null && Name.isValidIdentifier(expressionText)) {
-            if (isComponentLike(Name.identifier(expressionText)) && resolve() is JetParameter) {
+            if (isComponentLike(Name.identifier(expressionText)) && resolve() is KtParameter) {
                 return expression
             }
         }
 
-        val psiFactory = JetPsiFactory(expression)
+        val psiFactory = KtPsiFactory(expression)
         val element = when (expression.getReferencedNameElementType()) {
-            JetTokens.FIELD_IDENTIFIER -> psiFactory.createFieldIdentifier(newElementName)
+            KtTokens.FIELD_IDENTIFIER -> psiFactory.createFieldIdentifier(newElementName)
 
             else -> {
                 Extensions.getArea(expression.getProject()).getExtensionPoint(SimpleNameReferenceExtension.EP_NAME).getExtensions()
@@ -98,8 +98,8 @@ class JetSimpleNameReference(expression: JetSimpleNameExpression) : JetSimpleRef
         val nameElement = expression.getReferencedNameElement()
 
         val elementType = nameElement.getNode().getElementType()
-        if (elementType is JetToken && OperatorConventions.getNameForOperationSymbol(elementType) != null) {
-            val opExpression = expression.getParent() as? JetOperationExpression
+        if (elementType is KtToken && OperatorConventions.getNameForOperationSymbol(elementType) != null) {
+            val opExpression = expression.getParent() as? KtOperationExpression
             if (opExpression != null) {
                 val (newExpression, newNameElement) = OperatorToFunctionIntention.convert(opExpression)
                 newNameElement.replace(element)
@@ -129,16 +129,16 @@ class JetSimpleNameReference(expression: JetSimpleNameExpression) : JetSimpleRef
         if (fqName.isRoot) return expression
 
         // not supported for infix calls and operators
-        if (expression !is JetNameReferenceExpression) return expression
-        if (expression.parent is JetThisExpression || expression.parent is JetSuperExpression) return expression // TODO: it's a bad design of PSI tree, we should change it
+        if (expression !is KtNameReferenceExpression) return expression
+        if (expression.parent is KtThisExpression || expression.parent is KtSuperExpression) return expression // TODO: it's a bad design of PSI tree, we should change it
 
-        val newExpression = expression.changeQualifiedName(fqName).getQualifiedElementSelector() as JetNameReferenceExpression
+        val newExpression = expression.changeQualifiedName(fqName).getQualifiedElementSelector() as KtNameReferenceExpression
         val newQualifiedElement = newExpression.getQualifiedElement()
 
         if (shorteningMode == ShorteningMode.NO_SHORTENING) return newExpression
 
         val needToShorten =
-                PsiTreeUtil.getParentOfType(expression, javaClass<JetImportDirective>(), javaClass<JetPackageDirective>()) == null
+                PsiTreeUtil.getParentOfType(expression, javaClass<KtImportDirective>(), javaClass<KtPackageDirective>()) == null
         if (needToShorten) {
             if (shorteningMode == ShorteningMode.FORCED_SHORTENING) {
                 ShortenReferences.DEFAULT.process(newQualifiedElement)
@@ -152,17 +152,17 @@ class JetSimpleNameReference(expression: JetSimpleNameExpression) : JetSimpleRef
     }
 
     /**
-     * Replace [[JetNameReferenceExpression]] (and its enclosing qualifier) with qualified element given by FqName
-     * Result is either the same as original element, or [[JetQualifiedExpression]], or [[JetUserType]]
+     * Replace [[KtNameReferenceExpression]] (and its enclosing qualifier) with qualified element given by FqName
+     * Result is either the same as original element, or [[KtQualifiedExpression]], or [[KtUserType]]
      * Note that FqName may not be empty
      */
-    private fun JetNameReferenceExpression.changeQualifiedName(fqName: FqName): JetElement {
+    private fun KtNameReferenceExpression.changeQualifiedName(fqName: FqName): KtElement {
         assert(!fqName.isRoot()) { "Can't set empty FqName for element $this" }
 
         val shortName = fqName.shortName().asString()
-        val psiFactory = JetPsiFactory(this)
-        val fqNameBase = (getParent() as? JetCallExpression)?.let { parent ->
-            val callCopy = parent.copy() as JetCallExpression
+        val psiFactory = KtPsiFactory(this)
+        val fqNameBase = (getParent() as? KtCallExpression)?.let { parent ->
+            val callCopy = parent.copy() as KtCallExpression
             callCopy.getCalleeExpression()!!.replace(psiFactory.createSimpleName(shortName)).getParent()!!.getText()
         } ?: shortName
 
@@ -170,12 +170,12 @@ class JetSimpleNameReference(expression: JetSimpleNameExpression) : JetSimpleRef
 
         val elementToReplace = getQualifiedElement()
         return when (elementToReplace) {
-            is JetUserType -> {
+            is KtUserType -> {
                 val typeText = "$text${elementToReplace.getTypeArgumentList()?.getText() ?: ""}"
                 elementToReplace.replace(psiFactory.createType(typeText).typeElement!!)
             }
             else -> elementToReplace.replace(psiFactory.createExpression(text))
-        } as JetElement
+        } as KtElement
     }
 
     override fun getCanonicalText(): String = expression.getText()
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/SyntheticPropertyAccessorReference.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/SyntheticPropertyAccessorReference.kt
index 0885f7de266..5a802922557 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/SyntheticPropertyAccessorReference.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/SyntheticPropertyAccessorReference.kt
@@ -22,13 +22,13 @@ import com.intellij.util.SmartList
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetNameReferenceExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtNameReferenceExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
 import org.jetbrains.kotlin.utils.addIfNotNull
 
-sealed class SyntheticPropertyAccessorReference(expression: JetNameReferenceExpression, private val getter: Boolean) : JetSimpleReference<JetNameReferenceExpression>(expression) {
+sealed class SyntheticPropertyAccessorReference(expression: KtNameReferenceExpression, private val getter: Boolean) : KtSimpleReference<KtNameReferenceExpression>(expression) {
     override fun getTargetDescriptors(context: BindingContext): Collection<DeclarationDescriptor> {
         val descriptors = super.getTargetDescriptors(context)
         if (descriptors.none { it is SyntheticJavaPropertyDescriptor }) return emptyList()
@@ -65,11 +65,11 @@ sealed class SyntheticPropertyAccessorReference(expression: JetNameReferenceExpr
         }
         if (newName == null) return expression //TODO: handle the case when get/set becomes ordinary method
 
-        val nameIdentifier = JetPsiFactory(expression).createNameIdentifier(newName.getIdentifier())
+        val nameIdentifier = KtPsiFactory(expression).createNameIdentifier(newName.getIdentifier())
         expression.getReferencedNameElement().replace(nameIdentifier)
         return expression
     }
 
-    public class Getter(expression: JetNameReferenceExpression) : SyntheticPropertyAccessorReference(expression, true)
-    public class Setter(expression: JetNameReferenceExpression) : SyntheticPropertyAccessorReference(expression, false)
+    public class Getter(expression: KtNameReferenceExpression) : SyntheticPropertyAccessorReference(expression, true)
+    public class Setter(expression: KtNameReferenceExpression) : SyntheticPropertyAccessorReference(expression, false)
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/referenceUtil.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/referenceUtil.kt
index 540fe98cb47..22ccf116da6 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/referenceUtil.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/referenceUtil.kt
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.idea.kdoc.KDocReference
 import org.jetbrains.kotlin.idea.util.CallTypeAndReceiver
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocName
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getAssignmentByLHS
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
@@ -49,7 +49,7 @@ public val PsiReference.unwrappedTargets: Set<PsiElement>
         fun PsiElement.adjust(): PsiElement? {
             val target = unwrapped?.getOriginalElement()
             return when {
-                target is JetPropertyAccessor -> target.getNonStrictParentOfType<JetProperty>()
+                target is KtPropertyAccessor -> target.getNonStrictParentOfType<KtProperty>()
                 else -> target
             }
         }
@@ -74,11 +74,11 @@ public fun PsiReference.matchesTarget(candidateTarget: PsiElement): Boolean {
 
     // Optimizations
     when (this) {
-        is JetInvokeFunctionReference -> {
-            if (candidateTarget !is JetNamedFunction) return false
+        is KtInvokeFunctionReference -> {
+            if (candidateTarget !is KtNamedFunction) return false
         }
-        is JetMultiDeclarationReference -> {
-            if (candidateTarget !is JetNamedFunction && candidateTarget !is JetParameter) return false
+        is KtMultiDeclarationReference -> {
+            if (candidateTarget !is KtNamedFunction && candidateTarget !is KtParameter) return false
         }
     }
 
@@ -87,27 +87,27 @@ public fun PsiReference.matchesTarget(candidateTarget: PsiElement): Boolean {
     // TODO: Investigate why PsiCompiledElement identity changes
     if (unwrappedCandidate is PsiCompiledElement && targets.any { it.isEquivalentTo(unwrappedCandidate) }) return true
 
-    if (this is JetReference) {
+    if (this is KtReference) {
         return targets.any {
             it.isConstructorOf(unwrappedCandidate)
-            || it is JetObjectDeclaration && it.isCompanion() && it.getNonStrictParentOfType<JetClass>() == unwrappedCandidate
+            || it is KtObjectDeclaration && it.isCompanion() && it.getNonStrictParentOfType<KtClass>() == unwrappedCandidate
         }
     }
     // TODO: Workaround for Kotlin constructor search in Java code. To be removed after refactoring of the search API
-    else if (this is PsiJavaCodeReferenceElement && unwrappedCandidate is JetConstructor<*>) {
+    else if (this is PsiJavaCodeReferenceElement && unwrappedCandidate is KtConstructor<*>) {
         var parent = getElement().getParent()
         if (parent is PsiAnonymousClass) {
             parent = parent.getParent()
         }
         if ((parent as? PsiNewExpression)?.resolveConstructor()?.unwrapped == unwrappedCandidate) return true
     }
-    if (this is PsiJavaCodeReferenceElement && candidateTarget is JetObjectDeclaration && unwrappedTargets.size() == 1) {
+    if (this is PsiJavaCodeReferenceElement && candidateTarget is KtObjectDeclaration && unwrappedTargets.size() == 1) {
         val referredClass = unwrappedTargets.first()
-        if (referredClass is JetClass && candidateTarget in referredClass.getCompanionObjects()) {
+        if (referredClass is KtClass && candidateTarget in referredClass.getCompanionObjects()) {
             if (getParent() is PsiImportStaticStatement) return true
 
             return getParent().getReference()?.unwrappedTargets?.any {
-                (it is JetProperty || it is JetNamedFunction) && it.getParent()?.getParent() == candidateTarget
+                (it is KtProperty || it is KtNamedFunction) && it.getParent()?.getParent() == candidateTarget
             } ?: false
         }
     }
@@ -118,9 +118,9 @@ private fun PsiElement.isConstructorOf(unwrappedCandidate: PsiElement) =
     // call to Java constructor
     (this is PsiMethod && isConstructor() && getContainingClass() == unwrappedCandidate) ||
     // call to Kotlin constructor
-    (this is JetConstructor<*> && getContainingClassOrObject() == unwrappedCandidate)
+    (this is KtConstructor<*> && getContainingClassOrObject() == unwrappedCandidate)
 
-fun AbstractJetReference<out JetExpression>.renameImplicitConventionalCall(newName: String?): JetExpression {
+fun AbstractJetReference<out KtExpression>.renameImplicitConventionalCall(newName: String?): KtExpression {
     if (newName == null) return expression
 
     val (newExpression, newNameElement) = OperatorToFunctionIntention.convert(expression)
@@ -128,21 +128,21 @@ fun AbstractJetReference<out JetExpression>.renameImplicitConventionalCall(newNa
     return newExpression
 }
 
-val JetSimpleNameExpression.mainReference: JetSimpleNameReference
+val KtSimpleNameExpression.mainReference: KtSimpleNameReference
     get() = getReferences().firstIsInstance()
 
-val JetReferenceExpression.mainReference: JetReference
-    get() = if (this is JetSimpleNameExpression) mainReference else getReferences().firstIsInstance<JetReference>()
+val KtReferenceExpression.mainReference: KtReference
+    get() = if (this is KtSimpleNameExpression) mainReference else getReferences().firstIsInstance<KtReference>()
 
 val KDocName.mainReference: KDocReference
     get() = getReferences().firstIsInstance()
 
-val JetElement.mainReference: JetReference?
+val KtElement.mainReference: KtReference?
     get() {
         return when {
-            this is JetReferenceExpression -> mainReference
+            this is KtReferenceExpression -> mainReference
             this is KDocName -> mainReference
-            else -> getReferences().firstIsInstanceOrNull<JetReference>()
+            else -> getReferences().firstIsInstanceOrNull<KtReference>()
         }
     }
 
@@ -152,12 +152,12 @@ public enum class ReferenceAccess {
     READ, WRITE, READ_WRITE
 }
 
-public fun JetExpression.readWriteAccess(useResolveForReadWrite: Boolean): ReferenceAccess {
+public fun KtExpression.readWriteAccess(useResolveForReadWrite: Boolean): ReferenceAccess {
     var expression = getQualifiedExpressionForSelectorOrThis()
     loop@ while (true) {
         val parent = expression.parent
         when (parent) {
-            is JetParenthesizedExpression, is JetAnnotatedExpression, is JetLabeledExpression -> expression = parent as JetExpression
+            is KtParenthesizedExpression, is KtAnnotatedExpression, is KtLabeledExpression -> expression = parent as KtExpression
             else -> break@loop
         }
     }
@@ -165,7 +165,7 @@ public fun JetExpression.readWriteAccess(useResolveForReadWrite: Boolean): Refer
     val assignment = expression.getAssignmentByLHS()
     if (assignment != null) {
         when (assignment.operationToken) {
-            JetTokens.EQ -> return ReferenceAccess.WRITE
+            KtTokens.EQ -> return ReferenceAccess.WRITE
 
             else -> {
                 if (!useResolveForReadWrite) return ReferenceAccess.READ_WRITE
@@ -181,17 +181,17 @@ public fun JetExpression.readWriteAccess(useResolveForReadWrite: Boolean): Refer
         }
     }
 
-    return if ((expression.parent as? JetUnaryExpression)?.operationToken in constant { setOf(JetTokens.PLUSPLUS, JetTokens.MINUSMINUS) })
+    return if ((expression.parent as? KtUnaryExpression)?.operationToken in constant { setOf(KtTokens.PLUSPLUS, KtTokens.MINUSMINUS) })
         ReferenceAccess.READ_WRITE
     else
         ReferenceAccess.READ
 }
 
-public fun JetReference.canBeResolvedViaImport(target: DeclarationDescriptor): Boolean {
+public fun KtReference.canBeResolvedViaImport(target: DeclarationDescriptor): Boolean {
     if (!target.canBeReferencedViaImport()) return false
     if (target.isExtension) return true // assume that any type of reference can use imports when resolved to extension
-    val referenceExpression = this.element as? JetNameReferenceExpression ?: return false
+    val referenceExpression = this.element as? KtNameReferenceExpression ?: return false
     if (CallTypeAndReceiver.detect(referenceExpression).receiver != null) return false
-    if (element.parent is JetThisExpression || element.parent is JetSuperExpression) return false // TODO: it's a bad design of PSI tree, we should change it
+    if (element.parent is KtThisExpression || element.parent is KtSuperExpression) return false // TODO: it's a bad design of PSI tree, we should change it
     return true
 }
\ No newline at end of file
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/KotlinIndexPatternBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/KotlinIndexPatternBuilder.kt
index 33d84f5b382..e0bb0b8b857 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/KotlinIndexPatternBuilder.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/KotlinIndexPatternBuilder.kt
@@ -22,25 +22,25 @@ import com.intellij.psi.impl.search.IndexPatternBuilder
 import com.intellij.psi.tree.IElementType
 import com.intellij.psi.tree.TokenSet
 import org.jetbrains.kotlin.kdoc.lexer.KDocTokens
-import org.jetbrains.kotlin.lexer.JetLexer
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.lexer.KotlinLexer
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtFile
 
 public class KotlinIndexPatternBuilder: IndexPatternBuilder {
-    private val TODO_COMMENT_TOKENS = TokenSet.orSet(JetTokens.COMMENTS, TokenSet.create(KDocTokens.KDOC))
+    private val TODO_COMMENT_TOKENS = TokenSet.orSet(KtTokens.COMMENTS, TokenSet.create(KDocTokens.KDOC))
 
     override fun getCommentTokenSet(file: PsiFile): TokenSet? {
-        return if (file is JetFile) TODO_COMMENT_TOKENS else null
+        return if (file is KtFile) TODO_COMMENT_TOKENS else null
     }
 
     override fun getIndexingLexer(file: PsiFile): Lexer? {
-        return if (file is JetFile) JetLexer() else null
+        return if (file is KtFile) KotlinLexer() else null
     }
 
     override fun getCommentStartDelta(tokenType: IElementType?): Int = 0
 
     override fun getCommentEndDelta(tokenType: IElementType?): Int = when(tokenType) {
-        JetTokens.BLOCK_COMMENT -> "*/".length()
+        KtTokens.BLOCK_COMMENT -> "*/".length()
         else -> 0
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/KotlinIndexers.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/KotlinIndexers.kt
index d2a044d758c..553cd80ab5b 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/KotlinIndexers.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/KotlinIndexers.kt
@@ -28,19 +28,19 @@ import com.intellij.psi.tree.IElementType
 import com.intellij.psi.tree.TokenSet
 import org.jetbrains.kotlin.idea.search.usagesSearch.ALL_SEARCHABLE_OPERATIONS
 import org.jetbrains.kotlin.kdoc.lexer.KDocTokens
-import org.jetbrains.kotlin.lexer.JetLexer
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KotlinLexer
+import org.jetbrains.kotlin.lexer.KtTokens
 import java.util.*
 
 val KOTLIN_NAMED_ARGUMENT_SEARCH_CONTEXT: Short = 0x20
 
-class KotlinFilterLexer(private val occurrenceConsumer: OccurrenceConsumer): BaseFilterLexer(JetLexer(), occurrenceConsumer) {
+class KotlinFilterLexer(private val occurrenceConsumer: OccurrenceConsumer): BaseFilterLexer(KotlinLexer(), occurrenceConsumer) {
     private val codeTokens = TokenSet.orSet(
             TokenSet.create(*ALL_SEARCHABLE_OPERATIONS.toTypedArray()),
-            TokenSet.create(JetTokens.IDENTIFIER, JetTokens.FIELD_IDENTIFIER)
+            TokenSet.create(KtTokens.IDENTIFIER, KtTokens.FIELD_IDENTIFIER)
     )
 
-    private val commentTokens = TokenSet.orSet(JetTokens.COMMENTS, TokenSet.create(KDocTokens.KDOC))
+    private val commentTokens = TokenSet.orSet(KtTokens.COMMENTS, TokenSet.create(KDocTokens.KDOC))
 
     private val MAX_PREV_TOKENS = 2
     private val prevTokens = ArrayDeque<IElementType>(MAX_PREV_TOKENS)
@@ -51,22 +51,22 @@ class KotlinFilterLexer(private val occurrenceConsumer: OccurrenceConsumer): Bas
         val tokenType = myDelegate.tokenType
 
         when (tokenType) {
-            JetTokens.EQ -> {
-                if (prevTokens.peekFirst() == JetTokens.IDENTIFIER) {
+            KtTokens.EQ -> {
+                if (prevTokens.peekFirst() == KtTokens.IDENTIFIER) {
                     val prevPrev = prevTokens.elementAtOrNull(1)
-                    if (prevPrev == JetTokens.COMMA || prevPrev == JetTokens.LPAR) {
+                    if (prevPrev == KtTokens.COMMA || prevPrev == KtTokens.LPAR) {
                         occurrenceConsumer.addOccurrence(bufferSequence, null, prevTokenStart, prevTokenEnd, KOTLIN_NAMED_ARGUMENT_SEARCH_CONTEXT.toInt())
                     }
                 }
             }
 
-            JetTokens.LPAR -> {
+            KtTokens.LPAR -> {
                 if (isMultiDeclarationPosition()) {
                     addOccurrenceInToken(UsageSearchContext.IN_CODE.toInt())
                 }
             }
 
-            JetTokens.IDENTIFIER -> {
+            KtTokens.IDENTIFIER -> {
                  if (myDelegate.tokenText.startsWith("`")) {
                      scanWordsInToken(UsageSearchContext.IN_CODE.toInt(), false, false)
                  }
@@ -77,7 +77,7 @@ class KotlinFilterLexer(private val occurrenceConsumer: OccurrenceConsumer): Bas
 
             in codeTokens -> addOccurrenceInToken(UsageSearchContext.IN_CODE.toInt())
 
-            in JetTokens.STRINGS -> scanWordsInToken(UsageSearchContext.IN_STRINGS + UsageSearchContext.IN_FOREIGN_LANGUAGES, false, true)
+            in KtTokens.STRINGS -> scanWordsInToken(UsageSearchContext.IN_STRINGS + UsageSearchContext.IN_FOREIGN_LANGUAGES, false, true)
 
             in commentTokens -> {
                 scanWordsInToken(UsageSearchContext.IN_COMMENTS.toInt(), false, false)
@@ -99,8 +99,8 @@ class KotlinFilterLexer(private val occurrenceConsumer: OccurrenceConsumer): Bas
 
     private fun isMultiDeclarationPosition(): Boolean {
         val first = prevTokens.peekFirst()
-        if (first == JetTokens.VAL_KEYWORD || first == JetTokens.VAR_KEYWORD) return true
-        return first == JetTokens.LPAR && prevTokens.elementAtOrNull(1) == JetTokens.FOR_KEYWORD
+        if (first == KtTokens.VAL_KEYWORD || first == KtTokens.VAR_KEYWORD) return true
+        return first == KtTokens.LPAR && prevTokens.elementAtOrNull(1) == KtTokens.FOR_KEYWORD
     }
 }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/declarationsSearch/classInheritorsSearch.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/declarationsSearch/classInheritorsSearch.kt
index 9e63deef69b..638f29d1e1b 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/declarationsSearch/classInheritorsSearch.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/declarationsSearch/classInheritorsSearch.kt
@@ -20,7 +20,7 @@ import com.intellij.psi.PsiClass
 import com.intellij.util.Query
 import com.intellij.psi.PsiModifier
 import com.intellij.psi.PsiAnonymousClass
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.asJava.LightClassUtil
 import com.intellij.psi.PsiElement
 import com.intellij.psi.search.searches.ClassInheritorsSearch
@@ -28,7 +28,7 @@ import com.intellij.util.EmptyQuery
 
 public fun HierarchySearchRequest<*>.searchInheritors(): Query<PsiClass> {
     val psiClass: PsiClass? = when (originalElement) {
-        is JetClassOrObject -> LightClassUtil.getPsiClass(originalElement)
+        is KtClassOrObject -> LightClassUtil.getPsiClass(originalElement)
         is PsiClass -> originalElement
         else -> null
     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/declarationsSearch/overridersSearch.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/declarationsSearch/overridersSearch.kt
index 290439ec19a..851d5302d98 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/declarationsSearch/overridersSearch.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/declarationsSearch/overridersSearch.kt
@@ -28,13 +28,13 @@ import com.intellij.util.Query
 import org.jetbrains.kotlin.asJava.toLightMethods
 import org.jetbrains.kotlin.idea.search.allScope
 import org.jetbrains.kotlin.idea.util.application.runReadAction
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.isOverridable
 import java.util.*
 
 fun PsiElement.isOverridableElement(): Boolean = when (this) {
     is PsiMethod -> PsiUtil.canBeOverriden(this)
-    is JetDeclaration -> isOverridable()
+    is KtDeclaration -> isOverridable()
     else -> false
 }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReadWriteAccessDetector.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReadWriteAccessDetector.kt
index 33670e004a6..81d2d81c116 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReadWriteAccessDetector.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReadWriteAccessDetector.kt
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 
 public class KotlinReadWriteAccessDetector : ReadWriteAccessDetector() {
-    override fun isReadWriteAccessible(element: PsiElement) = element is JetVariableDeclaration || element is JetParameter
+    override fun isReadWriteAccessible(element: PsiElement) = element is KtVariableDeclaration || element is KtParameter
 
     override fun isDeclarationWriteAccess(element: PsiElement) = isReadWriteAccessible(element)
 
@@ -40,9 +40,9 @@ public class KotlinReadWriteAccessDetector : ReadWriteAccessDetector() {
         val refTarget = reference.resolve()
         if (refTarget is KotlinLightMethod) {
             val origin = refTarget.getOrigin()
-            val declaration: JetNamedDeclaration = when (origin) {
-                is JetPropertyAccessor -> origin.getNonStrictParentOfType<JetProperty>()
-                is JetProperty, is JetParameter -> origin as JetNamedDeclaration
+            val declaration: KtNamedDeclaration = when (origin) {
+                is KtPropertyAccessor -> origin.getNonStrictParentOfType<KtProperty>()
+                is KtProperty, is KtParameter -> origin as KtNamedDeclaration
                 else -> null
             } ?: return ReadWriteAccessDetector.Access.ReadWrite
 
@@ -57,7 +57,7 @@ public class KotlinReadWriteAccessDetector : ReadWriteAccessDetector() {
     }
 
     override fun getExpressionAccess(expression: PsiElement): ReadWriteAccessDetector.Access {
-        if (expression !is JetExpression) { //TODO: there should be a more correct scheme of access type detection for cross-language references
+        if (expression !is KtExpression) { //TODO: there should be a more correct scheme of access type detection for cross-language references
             return JavaReadWriteAccessDetector().getExpressionAccess(expression)
         }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt
index 0d78c23f801..036c81fcbf6 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt
@@ -25,8 +25,8 @@ import com.intellij.psi.search.searches.ReferencesSearch
 import com.intellij.util.Processor
 import org.jetbrains.kotlin.asJava.*
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.idea.JetFileType
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.idea.KotlinFileType
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.idea.search.KOTLIN_NAMED_ARGUMENT_SEARCH_CONTEXT
 import org.jetbrains.kotlin.idea.search.allScope
 import org.jetbrains.kotlin.idea.search.usagesSearch.*
@@ -70,7 +70,7 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
 
         val effectiveSearchScope = runReadAction { queryParameters.effectiveSearchScope }
 
-        val refFilter: (PsiReference) -> Boolean = if (unwrappedElement is JetParameter)
+        val refFilter: (PsiReference) -> Boolean = if (unwrappedElement is KtParameter)
             ({ ref: PsiReference -> !ref.isNamedArgumentReference()/* they are processed later*/ })
         else
             ({true})
@@ -93,16 +93,16 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
                                                  resultProcessor)
         }
 
-        if (unwrappedElement is JetParameter) {
+        if (unwrappedElement is KtParameter) {
             runReadAction { searchNamedArguments(unwrappedElement, queryParameters) }
         }
 
-        if (!(unwrappedElement is JetElement && isOnlyKotlinSearch(effectiveSearchScope))) {
+        if (!(unwrappedElement is KtElement && isOnlyKotlinSearch(effectiveSearchScope))) {
             searchLightElements(queryParameters, element)
         }
     }
 
-    private fun searchNamedArguments(parameter: JetParameter, queryParameters: ReferencesSearch.SearchParameters) {
+    private fun searchNamedArguments(parameter: KtParameter, queryParameters: ReferencesSearch.SearchParameters) {
         val parameterName = parameter.name ?: return
         val function = parameter.ownerFunction ?: return
         if (function.nameAsName?.isSpecial ?: true) return
@@ -127,7 +127,7 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
     }
 
     private fun PsiReference.isNamedArgumentReference(): Boolean {
-        return this is JetSimpleNameReference && expression.parent is JetValueArgumentName
+        return this is KtSimpleNameReference && expression.parent is KtValueArgumentName
     }
 
     private class MyRequestResultProcessor(
@@ -155,7 +155,7 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
             if (isReferenceTo(element)) {
                 return true
             }
-            if (originalElement is JetNamedDeclaration) {
+            if (originalElement is KtNamedDeclaration) {
                 if (options.acceptCallableOverrides && isCallableOverrideUsage(originalElement)) {
                     return true
                 }
@@ -171,14 +171,14 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
     }
 
     companion object {
-        public fun processJetClassOrObject(element: JetClassOrObject, queryParameters: ReferencesSearch.SearchParameters) {
+        public fun processJetClassOrObject(element: KtClassOrObject, queryParameters: ReferencesSearch.SearchParameters) {
             val className = element.getName()
             if (className != null) {
                 val lightClass = runReadAction { LightClassUtil.getPsiClass(element) }
                 if (lightClass != null) {
                     searchNamedElement(queryParameters, lightClass, className)
 
-                    if (element is JetObjectDeclaration && element.isCompanion()) {
+                    if (element is KtObjectDeclaration && element.isCompanion()) {
                         val fieldForCompanionObject = runReadAction { LightClassUtil.getLightFieldForCompanionObject(element) }
                         if (fieldForCompanionObject != null) {
                             searchNamedElement(queryParameters, fieldForCompanionObject)
@@ -187,7 +187,7 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
                         val kotlinReferencesSearchOptions = (queryParameters as? KotlinReferencesSearchParameters)?.kotlinOptions
                         if (kotlinReferencesSearchOptions?.acceptCompanionObjectMembers == true) {
                             runReadAction {
-                                val originClass = element.getStrictParentOfType<JetClass>()
+                                val originClass = element.getStrictParentOfType<KtClass>()
                                 val originLightClass = LightClassUtil.getPsiClass(originClass)
                                 if (originLightClass != null) {
                                     val lightDeclarations: List<KotlinLightElement<*, *>?> =
@@ -208,12 +208,12 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
             }
         }
 
-        private fun findStaticMethodFromCompanionObject(function: JetFunction): PsiMethod? {
+        private fun findStaticMethodFromCompanionObject(function: KtFunction): PsiMethod? {
             val originObject = function.parents
-                .dropWhile { it is JetClassBody }
-                .firstOrNull() as? JetObjectDeclaration ?: return null
+                .dropWhile { it is KtClassBody }
+                .firstOrNull() as? KtObjectDeclaration ?: return null
             if (originObject.isCompanion()) {
-                val originClass = originObject.getStrictParentOfType<JetClass>()
+                val originClass = originObject.getStrictParentOfType<KtClass>()
                 val originLightClass = LightClassUtil.getPsiClass(originClass)
                 val allMethods = originLightClass?.allMethods
                 return allMethods?.find { it is KotlinLightMethod && it.getOrigin() == function }
@@ -221,7 +221,7 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
             return null
         }
 
-        private fun searchPropertyMethods(queryParameters: ReferencesSearch.SearchParameters, parameter: JetParameter) {
+        private fun searchPropertyMethods(queryParameters: ReferencesSearch.SearchParameters, parameter: KtParameter) {
             val propertyMethods = runReadAction { LightClassUtil.getLightClassPropertyMethods(parameter) }
             propertyMethods.allDeclarations.forEach { searchNamedElement(queryParameters, it) }
         }
@@ -239,9 +239,9 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
 
         private fun searchLightElements(queryParameters: ReferencesSearch.SearchParameters, element: PsiElement) {
             when (element) {
-                is JetClassOrObject -> processJetClassOrObject(element, queryParameters)
-                is JetNamedFunction, is JetSecondaryConstructor -> {
-                    val function = element as JetFunction
+                is KtClassOrObject -> processJetClassOrObject(element, queryParameters)
+                is KtNamedFunction, is KtSecondaryConstructor -> {
+                    val function = element as KtFunction
                     val name = runReadAction { function.getName() }
                     if (name != null) {
                         val methods = runReadAction { LightClassUtil.getLightClassMethods(function) }
@@ -256,17 +256,17 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
                     }
                 }
 
-                is JetProperty -> {
+                is KtProperty -> {
                     val propertyMethods = runReadAction { LightClassUtil.getLightClassPropertyMethods(element) }
                     propertyMethods.allDeclarations.forEach { searchNamedElement(queryParameters, it) }
                 }
 
-                is JetParameter -> {
+                is KtParameter -> {
                     searchPropertyMethods(queryParameters, element)
                     runReadAction {
                         val componentFunctionDescriptor = element.dataClassComponentFunction()
                         if (componentFunctionDescriptor != null) {
-                            val containingClass = LightClassUtil.getPsiClass(element.getStrictParentOfType<JetClassOrObject>())
+                            val containingClass = LightClassUtil.getPsiClass(element.getStrictParentOfType<KtClassOrObject>())
                             searchDataClassComponentUsages(queryParameters, containingClass, componentFunctionDescriptor)
                         }
                     }
@@ -274,14 +274,14 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
 
                 is KotlinLightMethod -> {
                     val declaration = element.getOrigin()
-                    if (declaration is JetProperty || (declaration is JetParameter && declaration.hasValOrVar())) {
+                    if (declaration is KtProperty || (declaration is KtParameter && declaration.hasValOrVar())) {
                         searchNamedElement(queryParameters, declaration as PsiNamedElement)
                     }
-                    else if (declaration is JetPropertyAccessor) {
-                        val property = declaration.getStrictParentOfType<JetProperty>()
+                    else if (declaration is KtPropertyAccessor) {
+                        val property = declaration.getStrictParentOfType<KtProperty>()
                         searchNamedElement(queryParameters, property)
                     }
-                    else if (declaration is JetFunction) {
+                    else if (declaration is KtFunction) {
                         val staticFromCompanionObject = runReadAction { findStaticMethodFromCompanionObject(declaration) }
                         if (staticFromCompanionObject != null) {
                             searchNamedElement(queryParameters, staticFromCompanionObject)
@@ -304,7 +304,7 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
 
         private fun isOnlyKotlinSearch(searchScope: SearchScope) =
                 searchScope is LocalSearchScope && runReadAction {
-                    searchScope.getScope().all { it.getContainingFile().getFileType() == JetFileType.INSTANCE }
+                    searchScope.getScope().all { it.getContainingFile().getFileType() == KotlinFileType.INSTANCE }
                 }
 
         private fun searchNamedElement(queryParameters: ReferencesSearch.SearchParameters,
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/conventions.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/conventions.kt
index daf5eb95221..80f43b6dcf0 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/conventions.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/conventions.kt
@@ -17,16 +17,16 @@
 package org.jetbrains.kotlin.idea.search.usagesSearch
 
 import com.google.common.collect.ImmutableSet
-import org.jetbrains.kotlin.lexer.JetToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver
 import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike
 import org.jetbrains.kotlin.types.expressions.OperatorConventions.*
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
-public val ALL_SEARCHABLE_OPERATIONS: ImmutableSet<JetToken> = ImmutableSet
-        .builder<JetToken>()
+public val ALL_SEARCHABLE_OPERATIONS: ImmutableSet<KtToken> = ImmutableSet
+        .builder<KtToken>()
         .addAll(UNARY_OPERATION_NAMES.keySet())
         .addAll(BINARY_OPERATION_NAMES.keySet())
         .addAll(ASSIGNMENT_OPERATIONS.keySet())
@@ -34,31 +34,31 @@ public val ALL_SEARCHABLE_OPERATIONS: ImmutableSet<JetToken> = ImmutableSet
         .addAll(EQUALS_OPERATIONS)
         .addAll(IDENTITY_EQUALS_OPERATIONS)
         .addAll(IN_OPERATIONS)
-        .add(JetTokens.LBRACKET)
-        .add(JetTokens.BY_KEYWORD)
+        .add(KtTokens.LBRACKET)
+        .add(KtTokens.BY_KEYWORD)
         .build()
 
 public val INDEXING_OPERATION_NAMES = setOf(OperatorNameConventions.GET, OperatorNameConventions.SET)
 
 public val DELEGATE_ACCESSOR_NAMES = setOf(Name.identifier("getValue"), Name.identifier("setValue"))
 
-public val IN_OPERATIONS_TO_SEARCH = setOf(JetTokens.IN_KEYWORD)
+public val IN_OPERATIONS_TO_SEARCH = setOf(KtTokens.IN_KEYWORD)
 
-public val COMPARISON_OPERATIONS_TO_SEARCH = setOf(JetTokens.LT, JetTokens.GT)
+public val COMPARISON_OPERATIONS_TO_SEARCH = setOf(KtTokens.LT, KtTokens.GT)
 
-public fun Name.getOperationSymbolsToSearch(): Set<JetToken> {
+public fun Name.getOperationSymbolsToSearch(): Set<KtToken> {
     when (this) {
         OperatorNameConventions.COMPARE_TO -> return COMPARISON_OPERATIONS_TO_SEARCH
         OperatorNameConventions.EQUALS -> return EQUALS_OPERATIONS
         OperatorNameConventions.IDENTITY_EQUALS -> return IDENTITY_EQUALS_OPERATIONS
         OperatorNameConventions.CONTAINS -> return IN_OPERATIONS_TO_SEARCH
         OperatorNameConventions.ITERATOR -> return IN_OPERATIONS_TO_SEARCH
-        in INDEXING_OPERATION_NAMES -> return setOf(JetTokens.LBRACKET)
-        in DELEGATE_ACCESSOR_NAMES -> return setOf(JetTokens.BY_KEYWORD)
-        DelegatedPropertyResolver.PROPERTY_DELEGATED_FUNCTION_NAME -> return setOf(JetTokens.BY_KEYWORD)
+        in INDEXING_OPERATION_NAMES -> return setOf(KtTokens.LBRACKET)
+        in DELEGATE_ACCESSOR_NAMES -> return setOf(KtTokens.BY_KEYWORD)
+        DelegatedPropertyResolver.PROPERTY_DELEGATED_FUNCTION_NAME -> return setOf(KtTokens.BY_KEYWORD)
     }
 
-    if (isComponentLike(this)) return setOf(JetTokens.LPAR)
+    if (isComponentLike(this)) return setOf(KtTokens.LPAR)
 
     val unaryOp = UNARY_OPERATION_NAMES_WITH_DEPRECATED_INVERTED[this]
     if (unaryOp != null) return setOf(unaryOp)
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/searchHelpers.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/searchHelpers.kt
index bfc6e31a1cc..afe00b90fb0 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/searchHelpers.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/searchHelpers.kt
@@ -22,8 +22,8 @@ import org.jetbrains.kotlin.asJava.LightClassUtil.PropertyAccessorsPsiMethods
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
-import org.jetbrains.kotlin.lexer.JetSingleValueToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtSingleValueToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
@@ -41,12 +41,12 @@ fun PsiNamedElement.getAccessorNames(readable: Boolean = true, writable: Boolean
         return result
     }
 
-    if (this !is JetDeclaration || JetPsiUtil.isLocal(this)) return Collections.emptyList()
+    if (this !is KtDeclaration || KtPsiUtil.isLocal(this)) return Collections.emptyList()
 
     when (this) {
-        is JetProperty ->
+        is KtProperty ->
             return LightClassUtil.getLightClassPropertyMethods(this).toNameList()
-        is JetParameter ->
+        is KtParameter ->
             if (hasValOrVar()) {
                 return LightClassUtil.getLightClassPropertyMethods(this).toNameList()
             }
@@ -56,8 +56,8 @@ fun PsiNamedElement.getAccessorNames(readable: Boolean = true, writable: Boolean
 }
 
 public fun PsiNamedElement.getClassNameForCompanionObject(): String? {
-    return if (this is JetObjectDeclaration && this.isCompanion()) {
-        getNonStrictParentOfType<JetClass>()?.getName()
+    return if (this is KtObjectDeclaration && this.isCompanion()) {
+        getNonStrictParentOfType<KtClass>()?.getName()
     } else {
         null
     }
@@ -67,17 +67,17 @@ public fun PsiNamedElement.getSpecialNamesToSearch(): List<String> {
     val name = getName()
     return when {
         name == null || !Name.isValidIdentifier(name) -> Collections.emptyList<String>()
-        this is JetParameter -> {
+        this is KtParameter -> {
             val componentFunctionName = this.dataClassComponentFunction()?.name
             if (componentFunctionName == null) return Collections.emptyList<String>()
 
-            return listOf(componentFunctionName.asString(), JetTokens.LPAR.getValue())
+            return listOf(componentFunctionName.asString(), KtTokens.LPAR.getValue())
         }
-        else -> Name.identifier(name).getOperationSymbolsToSearch().map { (it as JetSingleValueToken).getValue() }
+        else -> Name.identifier(name).getOperationSymbolsToSearch().map { (it as KtSingleValueToken).getValue() }
     }
 }
 
-fun JetParameter.dataClassComponentFunction(): FunctionDescriptor? {
+fun KtParameter.dataClassComponentFunction(): FunctionDescriptor? {
     if (!hasValOrVar()) return null
 
     // Forcing full resolve of owner class: otherwise DATA_CLASS_COMPONENT_FUNCTION won't be calculated.
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt
index e5a28fa08e8..e3272fd6231 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt
@@ -37,29 +37,29 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.OverrideResolver
 
-val JetDeclaration.descriptor: DeclarationDescriptor?
+val KtDeclaration.descriptor: DeclarationDescriptor?
     get() = this.analyze().get(BindingContext.DECLARATION_TO_DESCRIPTOR, this)
 
-val JetDeclaration.constructor: ConstructorDescriptor?
+val KtDeclaration.constructor: ConstructorDescriptor?
     get() {
         val context = this.analyze()
         return when (this) {
-            is JetClassOrObject -> context[BindingContext.CLASS, this]?.getUnsubstitutedPrimaryConstructor()
-            is JetFunction -> context[BindingContext.CONSTRUCTOR, this]
+            is KtClassOrObject -> context[BindingContext.CLASS, this]?.getUnsubstitutedPrimaryConstructor()
+            is KtFunction -> context[BindingContext.CONSTRUCTOR, this]
             else -> null
         }
     }
 
-val JetParameter.propertyDescriptor: PropertyDescriptor?
+val KtParameter.propertyDescriptor: PropertyDescriptor?
     get() = this.analyze().get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, this)
 
 fun PsiReference.checkUsageVsOriginalDescriptor(
         targetDescriptor: DeclarationDescriptor,
-        declarationToDescriptor: (JetDeclaration) -> DeclarationDescriptor? = {it.descriptor},
+        declarationToDescriptor: (KtDeclaration) -> DeclarationDescriptor? = {it.descriptor},
         checker: (usageDescriptor: DeclarationDescriptor, targetDescriptor: DeclarationDescriptor) -> Boolean
 ): Boolean {
     return unwrappedTargets
-            .filterIsInstance<JetDeclaration>()
+            .filterIsInstance<KtDeclaration>()
             .any {
                 val usageDescriptor = declarationToDescriptor(it)
                 usageDescriptor != null && checker(usageDescriptor, targetDescriptor)
@@ -67,38 +67,38 @@ fun PsiReference.checkUsageVsOriginalDescriptor(
 }
 
 fun PsiReference.isImportUsage(): Boolean =
-        getElement()!!.getNonStrictParentOfType<JetImportDirective>() != null
+        getElement()!!.getNonStrictParentOfType<KtImportDirective>() != null
 
-fun PsiReference.isConstructorUsage(jetClassOrObject: JetClassOrObject): Boolean = with (getElement()!!) {
+fun PsiReference.isConstructorUsage(ktClassOrObject: KtClassOrObject): Boolean = with (getElement()!!) {
     fun checkJavaUsage(): Boolean {
         val call = getNonStrictParentOfType<PsiConstructorCall>()
-        return call == getParent() && call?.resolveConstructor()?.getContainingClass()?.getNavigationElement() == jetClassOrObject
+        return call == getParent() && call?.resolveConstructor()?.getContainingClass()?.getNavigationElement() == ktClassOrObject
     }
 
     fun checkKotlinUsage(): Boolean {
-        if (this !is JetElement) return false
+        if (this !is KtElement) return false
 
         val descriptor = getConstructorCallDescriptor()
         if (descriptor !is ConstructorDescriptor) return false
 
         val declaration = DescriptorToSourceUtils.descriptorToDeclaration(descriptor.getContainingDeclaration())
-        return declaration == jetClassOrObject || (declaration is JetConstructor<*> && declaration.getContainingClassOrObject() == jetClassOrObject)
+        return declaration == ktClassOrObject || (declaration is KtConstructor<*> && declaration.getContainingClassOrObject() == ktClassOrObject)
     }
 
     checkJavaUsage() || checkKotlinUsage()
 }
 
-private fun JetElement.getConstructorCallDescriptor(): DeclarationDescriptor? {
+private fun KtElement.getConstructorCallDescriptor(): DeclarationDescriptor? {
     val bindingContext = this.analyze()
-    val constructorCalleeExpression = getNonStrictParentOfType<JetConstructorCalleeExpression>()
+    val constructorCalleeExpression = getNonStrictParentOfType<KtConstructorCalleeExpression>()
     if (constructorCalleeExpression != null) {
         return bindingContext.get(BindingContext.REFERENCE_TARGET, constructorCalleeExpression.getConstructorReferenceExpression())
     }
 
-    val callExpression = getNonStrictParentOfType<JetCallElement>()
+    val callExpression = getNonStrictParentOfType<KtCallElement>()
     if (callExpression != null) {
         val callee = callExpression.getCalleeExpression()
-        if (callee is JetReferenceExpression) {
+        if (callee is KtReferenceExpression) {
             return bindingContext.get(BindingContext.REFERENCE_TARGET, callee)
         }
     }
@@ -106,27 +106,27 @@ private fun JetElement.getConstructorCallDescriptor(): DeclarationDescriptor? {
     return null
 }
 
-public fun PsiElement.processDelegationCallConstructorUsages(scope: SearchScope, process: (JetCallElement) -> Boolean): Boolean {
+public fun PsiElement.processDelegationCallConstructorUsages(scope: SearchScope, process: (KtCallElement) -> Boolean): Boolean {
     if (!processDelegationCallKotlinConstructorUsages(scope, process)) return false
     return processDelegationCallJavaConstructorUsages(scope, process)
 }
 
-private fun PsiElement.processDelegationCallKotlinConstructorUsages(scope: SearchScope, process: (JetCallElement) -> Boolean): Boolean {
+private fun PsiElement.processDelegationCallKotlinConstructorUsages(scope: SearchScope, process: (KtCallElement) -> Boolean): Boolean {
     val element = unwrapped
     val klass = when (element) {
-        is JetConstructor<*> -> element.getContainingClassOrObject()
-        is JetClass -> element
+        is KtConstructor<*> -> element.getContainingClassOrObject()
+        is KtClass -> element
         else -> return true
     }
 
-    if (klass !is JetClass || element !is JetDeclaration) return true
+    if (klass !is KtClass || element !is KtDeclaration) return true
     val descriptor = element.constructor ?: return true
 
     if (!processClassDelegationCallsToSpecifiedConstructor(klass, descriptor, process)) return false
     return processInheritorsDelegatingCallToSpecifiedConstructor(klass, scope, descriptor, process)
 }
 
-private fun PsiElement.processDelegationCallJavaConstructorUsages(scope: SearchScope, process: (JetCallElement) -> Boolean): Boolean {
+private fun PsiElement.processDelegationCallJavaConstructorUsages(scope: SearchScope, process: (KtCallElement) -> Boolean): Boolean {
     if (this is KotlinLightElement<*, *>) return true
     // TODO: Temporary hack to avoid NPE while KotlinNoOriginLightMethod is around
     if (this is KotlinNoOriginLightMethod) return true
@@ -141,11 +141,11 @@ private fun processInheritorsDelegatingCallToSpecifiedConstructor(
         klass: PsiElement,
         scope: SearchScope,
         descriptor: ConstructorDescriptor,
-        process: (JetCallElement) -> Boolean
+        process: (KtCallElement) -> Boolean
 ): Boolean {
     return HierarchySearchRequest(klass, scope, false).searchInheritors().all {
         val unwrapped = it.unwrapped
-        if (unwrapped is JetClass) {
+        if (unwrapped is KtClass) {
             processClassDelegationCallsToSpecifiedConstructor(unwrapped, descriptor, process)
         } else
             true
@@ -153,7 +153,7 @@ private fun processInheritorsDelegatingCallToSpecifiedConstructor(
 }
 
 private fun processClassDelegationCallsToSpecifiedConstructor(
-        klass: JetClass, constructor: DeclarationDescriptor, process: (JetCallElement) -> Boolean
+        klass: KtClass, constructor: DeclarationDescriptor, process: (KtCallElement) -> Boolean
 ): Boolean {
     for (secondaryConstructor in klass.getSecondaryConstructors()) {
         val delegationCallDescriptor = secondaryConstructor.getDelegationCall().getConstructorCallDescriptor()
@@ -163,9 +163,9 @@ private fun processClassDelegationCallsToSpecifiedConstructor(
     }
     if (!klass.isEnum()) return true
     for (declaration in klass.declarations) {
-        if (declaration is JetEnumEntry) {
+        if (declaration is KtEnumEntry) {
             val delegationCall = declaration.getDelegationSpecifiers().firstOrNull()
-            if (delegationCall is JetDelegatorToSuperCall && constructor == delegationCall.calleeExpression.getConstructorCallDescriptor()) {
+            if (delegationCall is KtDelegatorToSuperCall && constructor == delegationCall.calleeExpression.getConstructorCallDescriptor()) {
                 if (!process(delegationCall)) return false
             }
         }
@@ -175,7 +175,7 @@ private fun processClassDelegationCallsToSpecifiedConstructor(
 
 // Check if reference resolves to extension function whose receiver is the same as declaration's parent (or its superclass)
 // Used in extension search
-fun PsiReference.isExtensionOfDeclarationClassUsage(declaration: JetNamedDeclaration): Boolean {
+fun PsiReference.isExtensionOfDeclarationClassUsage(declaration: KtNamedDeclaration): Boolean {
     val descriptor = declaration.descriptor ?: return false
     return checkUsageVsOriginalDescriptor(descriptor) { usageDescriptor, targetDescriptor ->
         when {
@@ -197,7 +197,7 @@ fun PsiReference.isExtensionOfDeclarationClassUsage(declaration: JetNamedDeclara
 
 // Check if reference resolves to the declaration with the same parent
 // Used in overload search
-fun PsiReference.isUsageInContainingDeclaration(declaration: JetNamedDeclaration): Boolean {
+fun PsiReference.isUsageInContainingDeclaration(declaration: KtNamedDeclaration): Boolean {
     val descriptor = declaration.descriptor ?: return false
     return checkUsageVsOriginalDescriptor(descriptor) { usageDescriptor, targetDescriptor ->
         usageDescriptor != targetDescriptor
@@ -205,9 +205,9 @@ fun PsiReference.isUsageInContainingDeclaration(declaration: JetNamedDeclaration
     }
 }
 
-fun PsiReference.isCallableOverrideUsage(declaration: JetNamedDeclaration): Boolean {
-    val toDescriptor: (JetDeclaration) -> DeclarationDescriptor? = { declaration ->
-        if (declaration is JetParameter) {
+fun PsiReference.isCallableOverrideUsage(declaration: KtNamedDeclaration): Boolean {
+    val toDescriptor: (KtDeclaration) -> DeclarationDescriptor? = { declaration ->
+        if (declaration is KtParameter) {
             // we don't treat parameters in overriding method as "override" here (overriding parameters usages are searched optionally and via searching of overriding methods first)
             if (declaration.hasValOrVar()) declaration.propertyDescriptor else null
         }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/JetStructureViewElement.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/JetStructureViewElement.java
index b16bb1360da..f4f16e0b9de 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/JetStructureViewElement.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/JetStructureViewElement.java
@@ -49,7 +49,7 @@ public class JetStructureViewElement implements StructureViewTreeElement, Querya
         this.element = element;
         this.isInherited = isInherited;
 
-        if (!(element instanceof JetElement)) {
+        if (!(element instanceof KtElement)) {
             // Avoid storing descriptor in fields
             presentation = new KotlinStructureElementPresentation(isInherited(), element, descriptor);
         }
@@ -60,7 +60,7 @@ public class JetStructureViewElement implements StructureViewTreeElement, Querya
         this.isInherited = isInherited;
     }
 
-    public JetStructureViewElement(@NotNull JetFile fileElement) {
+    public JetStructureViewElement(@NotNull KtFile fileElement) {
         element = fileElement;
         isInherited = false;
     }
@@ -103,10 +103,10 @@ public class JetStructureViewElement implements StructureViewTreeElement, Querya
     @NotNull
     @Override
     public TreeElement[] getChildren() {
-        List<JetDeclaration> childrenDeclarations = getChildrenDeclarations();
-        return ArrayUtil.toObjectArray(ContainerUtil.map(childrenDeclarations, new Function<JetDeclaration, TreeElement>() {
+        List<KtDeclaration> childrenDeclarations = getChildrenDeclarations();
+        return ArrayUtil.toObjectArray(ContainerUtil.map(childrenDeclarations, new Function<KtDeclaration, TreeElement>() {
             @Override
-            public TreeElement fun(JetDeclaration declaration) {
+            public TreeElement fun(KtDeclaration declaration) {
                 return new JetStructureViewElement(declaration, false);
             }
         }), TreeElement.class);
@@ -125,12 +125,12 @@ public class JetStructureViewElement implements StructureViewTreeElement, Querya
 
     @Nullable
     private DeclarationDescriptor getDescriptor() {
-        if (!(element.isValid() && element instanceof JetDeclaration)) {
+        if (!(element.isValid() && element instanceof KtDeclaration)) {
             return null;
         }
 
-        final JetDeclaration declaration = (JetDeclaration) element;
-        if (declaration instanceof JetClassInitializer) {
+        final KtDeclaration declaration = (KtDeclaration) element;
+        if (declaration instanceof KtClassInitializer) {
             return null;
         }
 
@@ -147,24 +147,24 @@ public class JetStructureViewElement implements StructureViewTreeElement, Querya
     }
 
     @NotNull
-    private List<JetDeclaration> getChildrenDeclarations() {
-        if (element instanceof JetFile) {
-            JetFile jetFile = (JetFile) element;
+    private List<KtDeclaration> getChildrenDeclarations() {
+        if (element instanceof KtFile) {
+            KtFile jetFile = (KtFile) element;
             return jetFile.getDeclarations();
         }
-        else if (element instanceof JetClass) {
-            JetClass jetClass = (JetClass) element;
-            List<JetDeclaration> declarations = new ArrayList<JetDeclaration>();
-            for (JetParameter parameter : jetClass.getPrimaryConstructorParameters()) {
+        else if (element instanceof KtClass) {
+            KtClass ktClass = (KtClass) element;
+            List<KtDeclaration> declarations = new ArrayList<KtDeclaration>();
+            for (KtParameter parameter : ktClass.getPrimaryConstructorParameters()) {
                 if (parameter.hasValOrVar()) {
                     declarations.add(parameter);
                 }
             }
-            declarations.addAll(jetClass.getDeclarations());
+            declarations.addAll(ktClass.getDeclarations());
             return declarations;
         }
-        else if (element instanceof JetClassOrObject) {
-            return ((JetClassOrObject) element).getDeclarations();
+        else if (element instanceof KtClassOrObject) {
+            return ((KtClassOrObject) element).getDeclarations();
         }
 
         return Collections.emptyList();
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/JetStructureViewFactory.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/JetStructureViewFactory.java
index 493a969ab21..45a5b93a949 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/JetStructureViewFactory.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/JetStructureViewFactory.java
@@ -24,13 +24,13 @@ import com.intellij.openapi.editor.Editor;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 
 public class JetStructureViewFactory implements PsiStructureViewFactory {
     @Override
     public StructureViewBuilder getStructureViewBuilder(PsiFile psiFile) {
-        if (psiFile instanceof JetFile) {
-            final JetFile file = (JetFile) psiFile;
+        if (psiFile instanceof KtFile) {
+            final KtFile file = (KtFile) psiFile;
 
             return new TreeBasedStructureViewBuilder() {
                 @NotNull
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/JetStructureViewModel.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/JetStructureViewModel.java
index e9131813ba1..8056e287683 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/JetStructureViewModel.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/JetStructureViewModel.java
@@ -20,8 +20,8 @@ import com.intellij.ide.structureView.StructureViewModelBase;
 import com.intellij.ide.util.treeView.smartTree.NodeProvider;
 import com.intellij.ide.util.treeView.smartTree.Sorter;
 import org.jetbrains.annotations.NotNull;
-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 java.util.Arrays;
 import java.util.Collection;
@@ -32,9 +32,9 @@ public class JetStructureViewModel extends StructureViewModelBase {
 
     private static final Sorter[] sorters = new Sorter[] {Sorter.ALPHA_SORTER};
 
-    public JetStructureViewModel(@NotNull JetFile jetFile) {
+    public JetStructureViewModel(@NotNull KtFile jetFile) {
         super(jetFile, new JetStructureViewElement(jetFile));
-        withSuitableClasses(JetDeclaration.class);
+        withSuitableClasses(KtDeclaration.class);
     }
 
     @NotNull
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/KotlinInheritedMembersNodeProvider.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/KotlinInheritedMembersNodeProvider.kt
index 0cfa26f9bca..69837869e6d 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/KotlinInheritedMembersNodeProvider.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/KotlinInheritedMembersNodeProvider.kt
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import java.util.ArrayList
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import com.intellij.psi.NavigatablePsiElement
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 
 public class KotlinInheritedMembersNodeProvider: InheritedMembersNodeProvider<TreeElement>() {
@@ -32,7 +32,7 @@ public class KotlinInheritedMembersNodeProvider: InheritedMembersNodeProvider<Tr
         if (node !is JetStructureViewElement) return listOf()
 
         val element = node.getElement()
-        if (element !is JetClassOrObject) return listOf()
+        if (element !is KtClassOrObject) return listOf()
 
         @Suppress("USELESS_CAST") // KT-3996 Workaround
         val project = (element as NavigatablePsiElement).getProject()
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/KotlinStructureElementPresentation.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/KotlinStructureElementPresentation.java
index 5afcb206425..aa4935a3d02 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/KotlinStructureElementPresentation.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/structureView/KotlinStructureElementPresentation.java
@@ -31,9 +31,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.idea.JetDescriptorIconProvider;
-import org.jetbrains.kotlin.psi.JetClassInitializer;
-import org.jetbrains.kotlin.psi.JetModifierListOwner;
-import org.jetbrains.kotlin.psi.JetPsiUtil;
+import org.jetbrains.kotlin.psi.KtClassInitializer;
+import org.jetbrains.kotlin.psi.KtModifierListOwner;
+import org.jetbrains.kotlin.psi.KtPsiUtil;
 
 import javax.swing.*;
 import java.util.Set;
@@ -101,7 +101,7 @@ class KotlinStructureElementPresentation implements ColoredItemPresentation, Loc
             return CodeInsightColors.NOT_USED_ELEMENT_ATTRIBUTES;
         }
 
-        if (navigatablePsiElement instanceof JetModifierListOwner && JetPsiUtil.isDeprecated((JetModifierListOwner) navigatablePsiElement)) {
+        if (navigatablePsiElement instanceof KtModifierListOwner && KtPsiUtil.isDeprecated((KtModifierListOwner) navigatablePsiElement)) {
             return CodeInsightColors.DEPRECATED_ATTRIBUTES;
         }
 
@@ -128,7 +128,7 @@ class KotlinStructureElementPresentation implements ColoredItemPresentation, Loc
             return text;
         }
 
-        if (navigatablePsiElement instanceof JetClassInitializer) {
+        if (navigatablePsiElement instanceof KtClassInitializer) {
             return "<class initializer>";
         }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/IdeStubIndexService.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/IdeStubIndexService.java
index a7257cac286..3fc9bf32111 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/IdeStubIndexService.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/IdeStubIndexService.java
@@ -28,8 +28,8 @@ import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.psi.stubs.*;
 import org.jetbrains.kotlin.psi.stubs.elements.StubIndexService;
 import org.jetbrains.kotlin.util.TypeIndexUtilKt;
@@ -113,7 +113,7 @@ public class IdeStubIndexService extends StubIndexService {
         indexSuperNames(stub, sink);
     }
 
-    private static void indexSuperNames(KotlinClassOrObjectStub<? extends JetClassOrObject> stub, IndexSink sink) {
+    private static void indexSuperNames(KotlinClassOrObjectStub<? extends KtClassOrObject> stub, IndexSink sink) {
         for (String superName : stub.getSuperNames()) {
             sink.occurrence(JetSuperClassIndex.getInstance().getKey(), superName);
         }
@@ -189,7 +189,7 @@ public class IdeStubIndexService extends StubIndexService {
 
     @NotNull
     @Override
-    public KotlinFileStub createFileStub(@NotNull JetFile file) {
+    public KotlinFileStub createFileStub(@NotNull KtFile file) {
         StringRef packageFqName = StringRef.fromString(file.getPackageFqNameByTree().asString());
         boolean isScript = file.isScriptByTree();
         if (PackagePartClassUtils.fileHasTopLevelCallables(file)) {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/IndexUtils.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/IndexUtils.kt
index 6d6b19ba323..8e8e35ef214 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/IndexUtils.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/IndexUtils.kt
@@ -21,14 +21,14 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.stubs.KotlinCallableStubBase
 import org.jetbrains.kotlin.util.aliasImportMap
 
-fun indexTopLevelExtension<TDeclaration : JetCallableDeclaration>(stub: KotlinCallableStubBase<TDeclaration>, sink: IndexSink) {
+fun indexTopLevelExtension<TDeclaration : KtCallableDeclaration>(stub: KotlinCallableStubBase<TDeclaration>, sink: IndexSink) {
     if (stub.isExtension()) {
         val declaration = stub.getPsi()
         declaration.getReceiverTypeReference()!!.typeElement?.index(declaration, sink)
     }
 }
 
-private fun JetTypeElement.index<TDeclaration : JetCallableDeclaration>(declaration: TDeclaration, sink: IndexSink) {
+private fun KtTypeElement.index<TDeclaration : KtCallableDeclaration>(declaration: TDeclaration, sink: IndexSink) {
     fun occurrence(typeName: String) {
         val name = declaration.getName() ?: return
         sink.occurrence(JetTopLevelExtensionsByReceiverTypeIndex.INSTANCE.getKey(),
@@ -36,7 +36,7 @@ private fun JetTypeElement.index<TDeclaration : JetCallableDeclaration>(declarat
     }
 
     when (this) {
-        is JetUserType -> {
+        is KtUserType -> {
             var referenceName = getReferencedName() ?: return
 
             val typeParameter = declaration.getTypeParameters().firstOrNull { it.getName() == referenceName }
@@ -56,14 +56,14 @@ private fun JetTypeElement.index<TDeclaration : JetCallableDeclaration>(declarat
             aliasImportMap()[referenceName].forEach { occurrence(it) }
         }
 
-        is JetNullableType -> getInnerType()?.index(declaration, sink)
+        is KtNullableType -> getInnerType()?.index(declaration, sink)
 
-        is JetFunctionType -> {
+        is KtFunctionType -> {
             val arity = getParameters().size() + (if (getReceiverTypeReference() != null) 1 else 0)
             occurrence("Function$arity")
         }
 
-        is JetDynamicType -> occurrence("Any")
+        is KtDynamicType -> occurrence("Any")
 
         else -> error("Unsupported type: $this")
     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetAnnotationsIndex.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetAnnotationsIndex.java
index 5ffe0a4e1e3..ae59b951624 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetAnnotationsIndex.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetAnnotationsIndex.java
@@ -21,12 +21,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetAnnotationEntry;
+import org.jetbrains.kotlin.psi.KtAnnotationEntry;
 
 import java.util.Collection;
 
-public class JetAnnotationsIndex extends StringStubIndexExtension<JetAnnotationEntry> {
-    private static final StubIndexKey<String, JetAnnotationEntry> KEY = KotlinIndexUtil.createIndexKey(JetAnnotationsIndex.class);
+public class JetAnnotationsIndex extends StringStubIndexExtension<KtAnnotationEntry> {
+    private static final StubIndexKey<String, KtAnnotationEntry> KEY = KotlinIndexUtil.createIndexKey(JetAnnotationsIndex.class);
 
     private static final JetAnnotationsIndex ourInstance = new JetAnnotationsIndex();
 
@@ -38,13 +38,13 @@ public class JetAnnotationsIndex extends StringStubIndexExtension<JetAnnotationE
 
     @NotNull
     @Override
-    public StubIndexKey<String, JetAnnotationEntry> getKey() {
+    public StubIndexKey<String, KtAnnotationEntry> getKey() {
         return KEY;
     }
 
     @NotNull
     @Override
-    public Collection<JetAnnotationEntry> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public Collection<KtAnnotationEntry> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
         return super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
     }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetClassShortNameIndex.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetClassShortNameIndex.java
index fa878b3dec7..4993a268f45 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetClassShortNameIndex.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetClassShortNameIndex.java
@@ -21,12 +21,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
 
 import java.util.Collection;
 
-public class JetClassShortNameIndex extends StringStubIndexExtension<JetClassOrObject> {
-    private static final StubIndexKey<String, JetClassOrObject> KEY = KotlinIndexUtil.createIndexKey(JetClassShortNameIndex.class);
+public class JetClassShortNameIndex extends StringStubIndexExtension<KtClassOrObject> {
+    private static final StubIndexKey<String, KtClassOrObject> KEY = KotlinIndexUtil.createIndexKey(JetClassShortNameIndex.class);
 
     private static final JetClassShortNameIndex ourInstance = new JetClassShortNameIndex();
 
@@ -39,13 +39,13 @@ public class JetClassShortNameIndex extends StringStubIndexExtension<JetClassOrO
 
     @NotNull
     @Override
-    public StubIndexKey<String, JetClassOrObject> getKey() {
+    public StubIndexKey<String, KtClassOrObject> getKey() {
         return KEY;
     }
 
     @NotNull
     @Override
-    public Collection<JetClassOrObject> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public Collection<KtClassOrObject> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
         return super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetExactPackagesIndex.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetExactPackagesIndex.java
index b7f8ea6d6ec..f9fbf19251f 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetExactPackagesIndex.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetExactPackagesIndex.java
@@ -21,12 +21,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 
 import java.util.Collection;
 
-public class JetExactPackagesIndex extends StringStubIndexExtension<JetFile> {
-    private static final StubIndexKey<String, JetFile> KEY = KotlinIndexUtil.createIndexKey(JetExactPackagesIndex.class);
+public class JetExactPackagesIndex extends StringStubIndexExtension<KtFile> {
+    private static final StubIndexKey<String, KtFile> KEY = KotlinIndexUtil.createIndexKey(JetExactPackagesIndex.class);
 
     private static final JetExactPackagesIndex ourInstance = new JetExactPackagesIndex();
 
@@ -39,13 +39,13 @@ public class JetExactPackagesIndex extends StringStubIndexExtension<JetFile> {
 
     @NotNull
     @Override
-    public StubIndexKey<String, JetFile> getKey() {
+    public StubIndexKey<String, KtFile> getKey() {
         return KEY;
     }
 
     @NotNull
     @Override
-    public Collection<JetFile> get(@NotNull String fqName, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public Collection<KtFile> get(@NotNull String fqName, @NotNull Project project, @NotNull GlobalSearchScope scope) {
         return super.get(fqName, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFileFacadeClassByPackageIndex.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFileFacadeClassByPackageIndex.kt
index c0057756e84..2d5447ef02f 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFileFacadeClassByPackageIndex.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFileFacadeClassByPackageIndex.kt
@@ -20,10 +20,10 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.stubs.StringStubIndexExtension
 import com.intellij.psi.stubs.StubIndexKey
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
-public class JetFileFacadeClassByPackageIndex private constructor() : StringStubIndexExtension<JetFile>() {
-    override fun getKey(): StubIndexKey<String, JetFile> = KEY
+public class JetFileFacadeClassByPackageIndex private constructor() : StringStubIndexExtension<KtFile>() {
+    override fun getKey(): StubIndexKey<String, KtFile> = KEY
 
     override fun get(key: String, project: Project, scope: GlobalSearchScope) =
             super.get(key, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project))
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFileFacadeFqNameIndex.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFileFacadeFqNameIndex.kt
index 6d19a5a92c5..fe14e86711d 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFileFacadeFqNameIndex.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFileFacadeFqNameIndex.kt
@@ -20,10 +20,10 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.stubs.StringStubIndexExtension
 import com.intellij.psi.stubs.StubIndexKey
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
-public class JetFileFacadeFqNameIndex private constructor() : StringStubIndexExtension<JetFile>() {
-    override fun getKey(): StubIndexKey<String, JetFile> = KEY
+public class JetFileFacadeFqNameIndex private constructor() : StringStubIndexExtension<KtFile>() {
+    override fun getKey(): StubIndexKey<String, KtFile> = KEY
 
     override fun get(key: String, project: Project, scope: GlobalSearchScope) =
             super.get(key, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project))
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFileFacadeShortNameIndex.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFileFacadeShortNameIndex.kt
index bc4ebccbf68..515d39901af 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFileFacadeShortNameIndex.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFileFacadeShortNameIndex.kt
@@ -20,10 +20,10 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.stubs.StringStubIndexExtension
 import com.intellij.psi.stubs.StubIndexKey
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
-public class JetFileFacadeShortNameIndex private constructor() : StringStubIndexExtension<JetFile>() {
-    override fun getKey(): StubIndexKey<String, JetFile> = KEY
+public class JetFileFacadeShortNameIndex private constructor() : StringStubIndexExtension<KtFile>() {
+    override fun getKey(): StubIndexKey<String, KtFile> = KEY
 
     override fun get(key: String, project: Project, scope: GlobalSearchScope) =
             super.get(key, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project))
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFilePartClassIndex.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFilePartClassIndex.kt
index 592e8fc2bc6..30f7ca38cca 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFilePartClassIndex.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFilePartClassIndex.kt
@@ -20,11 +20,11 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.stubs.StringStubIndexExtension
 import com.intellij.psi.stubs.StubIndexKey
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
 
-public class JetFilePartClassIndex private constructor() : StringStubIndexExtension<JetFile>() {
-    override fun getKey(): StubIndexKey<String, JetFile> = KEY
+public class JetFilePartClassIndex private constructor() : StringStubIndexExtension<KtFile>() {
+    override fun getKey(): StubIndexKey<String, KtFile> = KEY
 
     override fun get(key: String, project: Project, scope: GlobalSearchScope) =
             super.get(key, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project))
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFullClassNameIndex.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFullClassNameIndex.java
index e04c1f39a3d..aed1144b42d 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFullClassNameIndex.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFullClassNameIndex.java
@@ -21,12 +21,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
 
 import java.util.Collection;
 
-public class JetFullClassNameIndex extends StringStubIndexExtension<JetClassOrObject> {
-    private static final StubIndexKey<String, JetClassOrObject> KEY = KotlinIndexUtil.createIndexKey(JetFullClassNameIndex.class);
+public class JetFullClassNameIndex extends StringStubIndexExtension<KtClassOrObject> {
+    private static final StubIndexKey<String, KtClassOrObject> KEY = KotlinIndexUtil.createIndexKey(JetFullClassNameIndex.class);
 
     private static final JetFullClassNameIndex ourInstance = new JetFullClassNameIndex();
 
@@ -39,13 +39,13 @@ public class JetFullClassNameIndex extends StringStubIndexExtension<JetClassOrOb
 
     @NotNull
     @Override
-    public StubIndexKey<String, JetClassOrObject> getKey() {
+    public StubIndexKey<String, KtClassOrObject> getKey() {
         return KEY;
     }
 
     @NotNull
     @Override
-    public Collection<JetClassOrObject> get(@NotNull String fqName, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public Collection<KtClassOrObject> get(@NotNull String fqName, @NotNull Project project, @NotNull GlobalSearchScope scope) {
         return super.get(fqName, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFunctionShortNameIndex.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFunctionShortNameIndex.java
index 37cdb389612..18b862778c3 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFunctionShortNameIndex.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetFunctionShortNameIndex.java
@@ -21,12 +21,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
 
 import java.util.Collection;
 
-public class JetFunctionShortNameIndex extends StringStubIndexExtension<JetNamedFunction> {
-    private static final StubIndexKey<String, JetNamedFunction> KEY = KotlinIndexUtil.createIndexKey(JetFunctionShortNameIndex.class);
+public class JetFunctionShortNameIndex extends StringStubIndexExtension<KtNamedFunction> {
+    private static final StubIndexKey<String, KtNamedFunction> KEY = KotlinIndexUtil.createIndexKey(JetFunctionShortNameIndex.class);
 
     private static final JetFunctionShortNameIndex ourInstance = new JetFunctionShortNameIndex();
 
@@ -38,13 +38,13 @@ public class JetFunctionShortNameIndex extends StringStubIndexExtension<JetNamed
 
     @NotNull
     @Override
-    public StubIndexKey<String, JetNamedFunction> getKey() {
+    public StubIndexKey<String, KtNamedFunction> getKey() {
         return KEY;
     }
 
     @NotNull
     @Override
-    public Collection<JetNamedFunction> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public Collection<KtNamedFunction> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
         return super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetMultifileClassPartIndex.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetMultifileClassPartIndex.kt
index 58d980e356f..d6bee1e5f86 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetMultifileClassPartIndex.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetMultifileClassPartIndex.kt
@@ -20,11 +20,11 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.stubs.StringStubIndexExtension
 import com.intellij.psi.stubs.StubIndexKey
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
 
-public class JetMultifileClassPartIndex private constructor() : StringStubIndexExtension<JetFile>() {
-    override fun getKey(): StubIndexKey<String, JetFile> = KEY
+public class JetMultifileClassPartIndex private constructor() : StringStubIndexExtension<KtFile>() {
+    override fun getKey(): StubIndexKey<String, KtFile> = KEY
 
     override fun get(key: String, project: Project, scope: GlobalSearchScope) =
             super.get(key, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project))
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetProbablyNothingFunctionShortNameIndex.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetProbablyNothingFunctionShortNameIndex.java
index 4f6a64a74ee..5e8ee1618e3 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetProbablyNothingFunctionShortNameIndex.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetProbablyNothingFunctionShortNameIndex.java
@@ -21,12 +21,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
 
 import java.util.Collection;
 
-public class JetProbablyNothingFunctionShortNameIndex extends StringStubIndexExtension<JetNamedFunction> {
-    private static final StubIndexKey<String, JetNamedFunction> KEY = KotlinIndexUtil.createIndexKey(JetProbablyNothingFunctionShortNameIndex.class);
+public class JetProbablyNothingFunctionShortNameIndex extends StringStubIndexExtension<KtNamedFunction> {
+    private static final StubIndexKey<String, KtNamedFunction> KEY = KotlinIndexUtil.createIndexKey(JetProbablyNothingFunctionShortNameIndex.class);
 
     private static final JetProbablyNothingFunctionShortNameIndex ourInstance = new JetProbablyNothingFunctionShortNameIndex();
 
@@ -38,13 +38,13 @@ public class JetProbablyNothingFunctionShortNameIndex extends StringStubIndexExt
 
     @NotNull
     @Override
-    public StubIndexKey<String, JetNamedFunction> getKey() {
+    public StubIndexKey<String, KtNamedFunction> getKey() {
         return KEY;
     }
 
     @NotNull
     @Override
-    public Collection<JetNamedFunction> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public Collection<KtNamedFunction> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
         return super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetProbablyNothingPropertyShortNameIndex.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetProbablyNothingPropertyShortNameIndex.java
index b16f235118c..723436c5f0c 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetProbablyNothingPropertyShortNameIndex.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetProbablyNothingPropertyShortNameIndex.java
@@ -21,12 +21,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetProperty;
+import org.jetbrains.kotlin.psi.KtProperty;
 
 import java.util.Collection;
 
-public class JetProbablyNothingPropertyShortNameIndex extends StringStubIndexExtension<JetProperty> {
-    private static final StubIndexKey<String, JetProperty> KEY = KotlinIndexUtil.createIndexKey(JetProbablyNothingPropertyShortNameIndex.class);
+public class JetProbablyNothingPropertyShortNameIndex extends StringStubIndexExtension<KtProperty> {
+    private static final StubIndexKey<String, KtProperty> KEY = KotlinIndexUtil.createIndexKey(JetProbablyNothingPropertyShortNameIndex.class);
 
     private static final JetProbablyNothingPropertyShortNameIndex ourInstance = new JetProbablyNothingPropertyShortNameIndex();
 
@@ -38,13 +38,13 @@ public class JetProbablyNothingPropertyShortNameIndex extends StringStubIndexExt
 
     @NotNull
     @Override
-    public StubIndexKey<String, JetProperty> getKey() {
+    public StubIndexKey<String, KtProperty> getKey() {
         return KEY;
     }
 
     @NotNull
     @Override
-    public Collection<JetProperty> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public Collection<KtProperty> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
         return super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetPropertyShortNameIndex.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetPropertyShortNameIndex.java
index 6f62a42c0d3..76c729f6e5c 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetPropertyShortNameIndex.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetPropertyShortNameIndex.java
@@ -21,12 +21,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetProperty;
+import org.jetbrains.kotlin.psi.KtProperty;
 
 import java.util.Collection;
 
-public class JetPropertyShortNameIndex extends StringStubIndexExtension<JetProperty> {
-    private static final StubIndexKey<String, JetProperty> KEY = KotlinIndexUtil.createIndexKey(JetPropertyShortNameIndex.class);
+public class JetPropertyShortNameIndex extends StringStubIndexExtension<KtProperty> {
+    private static final StubIndexKey<String, KtProperty> KEY = KotlinIndexUtil.createIndexKey(JetPropertyShortNameIndex.class);
 
     private static final JetPropertyShortNameIndex ourInstance = new JetPropertyShortNameIndex();
 
@@ -38,13 +38,13 @@ public class JetPropertyShortNameIndex extends StringStubIndexExtension<JetPrope
 
     @NotNull
     @Override
-    public StubIndexKey<String, JetProperty> getKey() {
+    public StubIndexKey<String, KtProperty> getKey() {
         return KEY;
     }
 
     @NotNull
     @Override
-    public Collection<JetProperty> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public Collection<KtProperty> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
         return super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetSuperClassIndex.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetSuperClassIndex.java
index 92c07cb843f..e4e2e9e3ae0 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetSuperClassIndex.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetSuperClassIndex.java
@@ -21,12 +21,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
 
 import java.util.Collection;
 
-public class JetSuperClassIndex extends StringStubIndexExtension<JetClassOrObject> {
-    private static final StubIndexKey<String, JetClassOrObject> KEY = KotlinIndexUtil.createIndexKey(JetSuperClassIndex.class);
+public class JetSuperClassIndex extends StringStubIndexExtension<KtClassOrObject> {
+    private static final StubIndexKey<String, KtClassOrObject> KEY = KotlinIndexUtil.createIndexKey(JetSuperClassIndex.class);
 
     private static final JetSuperClassIndex ourInstance = new JetSuperClassIndex();
 
@@ -39,13 +39,13 @@ public class JetSuperClassIndex extends StringStubIndexExtension<JetClassOrObjec
 
     @NotNull
     @Override
-    public StubIndexKey<String, JetClassOrObject> getKey() {
+    public StubIndexKey<String, KtClassOrObject> getKey() {
         return KEY;
     }
 
     @NotNull
     @Override
-    public Collection<JetClassOrObject> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public Collection<KtClassOrObject> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
         return super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelClassByPackageIndex.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelClassByPackageIndex.java
index 6a00c91daa6..ad7261a8512 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelClassByPackageIndex.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelClassByPackageIndex.java
@@ -21,12 +21,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
 
 import java.util.Collection;
 
-public class JetTopLevelClassByPackageIndex extends StringStubIndexExtension<JetClassOrObject> {
-    private static final StubIndexKey<String, JetClassOrObject> KEY = KotlinIndexUtil.createIndexKey(JetTopLevelClassByPackageIndex.class);
+public class JetTopLevelClassByPackageIndex extends StringStubIndexExtension<KtClassOrObject> {
+    private static final StubIndexKey<String, KtClassOrObject> KEY = KotlinIndexUtil.createIndexKey(JetTopLevelClassByPackageIndex.class);
 
     private static final JetTopLevelClassByPackageIndex ourInstance = new JetTopLevelClassByPackageIndex();
 
@@ -38,13 +38,13 @@ public class JetTopLevelClassByPackageIndex extends StringStubIndexExtension<Jet
 
     @NotNull
     @Override
-    public StubIndexKey<String, JetClassOrObject> getKey() {
+    public StubIndexKey<String, KtClassOrObject> getKey() {
         return KEY;
     }
 
     @NotNull
     @Override
-    public Collection<JetClassOrObject> get(@NotNull String fqName, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public Collection<KtClassOrObject> get(@NotNull String fqName, @NotNull Project project, @NotNull GlobalSearchScope scope) {
         return super.get(fqName, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelExtensionsByReceiverTypeIndex.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelExtensionsByReceiverTypeIndex.kt
index 27d46061d80..2c9adbe19e1 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelExtensionsByReceiverTypeIndex.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelExtensionsByReceiverTypeIndex.kt
@@ -20,9 +20,9 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.stubs.StringStubIndexExtension
 import com.intellij.psi.stubs.StubIndexKey
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
 
-public class JetTopLevelExtensionsByReceiverTypeIndex private constructor() : StringStubIndexExtension<JetCallableDeclaration>() {
+public class JetTopLevelExtensionsByReceiverTypeIndex private constructor() : StringStubIndexExtension<KtCallableDeclaration>() {
 
     override fun getKey() = KEY
 
@@ -30,7 +30,7 @@ public class JetTopLevelExtensionsByReceiverTypeIndex private constructor() : St
             = super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project))
 
     companion object {
-        private val KEY = KotlinIndexUtil.createIndexKey<String, JetCallableDeclaration>(javaClass<JetTopLevelExtensionsByReceiverTypeIndex>())
+        private val KEY = KotlinIndexUtil.createIndexKey<String, KtCallableDeclaration>(javaClass<JetTopLevelExtensionsByReceiverTypeIndex>())
         private val SEPARATOR = '\n'
 
         public val INSTANCE: JetTopLevelExtensionsByReceiverTypeIndex = JetTopLevelExtensionsByReceiverTypeIndex()
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelFunctionByPackageIndex.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelFunctionByPackageIndex.java
index 9d9c62557c8..214eb04ba47 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelFunctionByPackageIndex.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelFunctionByPackageIndex.java
@@ -21,12 +21,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
 
 import java.util.Collection;
 
-public class JetTopLevelFunctionByPackageIndex extends StringStubIndexExtension<JetNamedFunction> {
-    private static final StubIndexKey<String, JetNamedFunction> KEY = KotlinIndexUtil.createIndexKey(JetTopLevelFunctionByPackageIndex.class);
+public class JetTopLevelFunctionByPackageIndex extends StringStubIndexExtension<KtNamedFunction> {
+    private static final StubIndexKey<String, KtNamedFunction> KEY = KotlinIndexUtil.createIndexKey(JetTopLevelFunctionByPackageIndex.class);
 
     private static final JetTopLevelFunctionByPackageIndex ourInstance = new JetTopLevelFunctionByPackageIndex();
 
@@ -38,13 +38,13 @@ public class JetTopLevelFunctionByPackageIndex extends StringStubIndexExtension<
 
     @NotNull
     @Override
-    public StubIndexKey<String, JetNamedFunction> getKey() {
+    public StubIndexKey<String, KtNamedFunction> getKey() {
         return KEY;
     }
 
     @NotNull
     @Override
-    public Collection<JetNamedFunction> get(@NotNull String fqName, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public Collection<KtNamedFunction> get(@NotNull String fqName, @NotNull Project project, @NotNull GlobalSearchScope scope) {
         return super.get(fqName, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelFunctionFqnNameIndex.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelFunctionFqnNameIndex.java
index 31d56e564c4..19df08f0c63 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelFunctionFqnNameIndex.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelFunctionFqnNameIndex.java
@@ -21,15 +21,15 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
 
 import java.util.Collection;
 
 /**
  * Stores package top level function (both extension and non-extension) full qualified names.
  */
-public class JetTopLevelFunctionFqnNameIndex extends StringStubIndexExtension<JetNamedFunction> {
-    private static final StubIndexKey<String, JetNamedFunction> KEY = KotlinIndexUtil.createIndexKey(JetTopLevelFunctionFqnNameIndex.class);
+public class JetTopLevelFunctionFqnNameIndex extends StringStubIndexExtension<KtNamedFunction> {
+    private static final StubIndexKey<String, KtNamedFunction> KEY = KotlinIndexUtil.createIndexKey(JetTopLevelFunctionFqnNameIndex.class);
 
     private static final JetTopLevelFunctionFqnNameIndex INSTANCE = new JetTopLevelFunctionFqnNameIndex();
 
@@ -42,13 +42,13 @@ public class JetTopLevelFunctionFqnNameIndex extends StringStubIndexExtension<Je
 
     @NotNull
     @Override
-    public StubIndexKey<String, JetNamedFunction> getKey() {
+    public StubIndexKey<String, KtNamedFunction> getKey() {
         return KEY;
     }
 
     @NotNull
     @Override
-    public Collection<JetNamedFunction> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public Collection<KtNamedFunction> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
         return super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelPropertyByPackageIndex.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelPropertyByPackageIndex.java
index f6f0558dc95..a20b7383149 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelPropertyByPackageIndex.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelPropertyByPackageIndex.java
@@ -21,12 +21,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetProperty;
+import org.jetbrains.kotlin.psi.KtProperty;
 
 import java.util.Collection;
 
-public class JetTopLevelPropertyByPackageIndex extends StringStubIndexExtension<JetProperty> {
-    private static final StubIndexKey<String, JetProperty> KEY = KotlinIndexUtil.createIndexKey(JetTopLevelPropertyByPackageIndex.class);
+public class JetTopLevelPropertyByPackageIndex extends StringStubIndexExtension<KtProperty> {
+    private static final StubIndexKey<String, KtProperty> KEY = KotlinIndexUtil.createIndexKey(JetTopLevelPropertyByPackageIndex.class);
 
     private static final JetTopLevelPropertyByPackageIndex ourInstance = new JetTopLevelPropertyByPackageIndex();
 
@@ -38,13 +38,13 @@ public class JetTopLevelPropertyByPackageIndex extends StringStubIndexExtension<
 
     @NotNull
     @Override
-    public StubIndexKey<String, JetProperty> getKey() {
+    public StubIndexKey<String, KtProperty> getKey() {
         return KEY;
     }
 
     @NotNull
     @Override
-    public Collection<JetProperty> get(@NotNull String fqName, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public Collection<KtProperty> get(@NotNull String fqName, @NotNull Project project, @NotNull GlobalSearchScope scope) {
         return super.get(fqName, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelPropertyFqnNameIndex.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelPropertyFqnNameIndex.java
index b17e101e944..dbf4d05c616 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelPropertyFqnNameIndex.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/JetTopLevelPropertyFqnNameIndex.java
@@ -21,12 +21,12 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetProperty;
+import org.jetbrains.kotlin.psi.KtProperty;
 
 import java.util.Collection;
 
-public class JetTopLevelPropertyFqnNameIndex extends StringStubIndexExtension<JetProperty> {
-    private static final StubIndexKey<String, JetProperty> KEY = KotlinIndexUtil.createIndexKey(JetTopLevelPropertyFqnNameIndex.class);
+public class JetTopLevelPropertyFqnNameIndex extends StringStubIndexExtension<KtProperty> {
+    private static final StubIndexKey<String, KtProperty> KEY = KotlinIndexUtil.createIndexKey(JetTopLevelPropertyFqnNameIndex.class);
 
     private static final JetTopLevelPropertyFqnNameIndex INSTANCE = new JetTopLevelPropertyFqnNameIndex();
 
@@ -39,13 +39,13 @@ public class JetTopLevelPropertyFqnNameIndex extends StringStubIndexExtension<Je
 
     @NotNull
     @Override
-    public StubIndexKey<String, JetProperty> getKey() {
+    public StubIndexKey<String, KtProperty> getKey() {
         return KEY;
     }
 
     @NotNull
     @Override
-    public Collection<JetProperty> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public Collection<KtProperty> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
         return super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/KotlinFileStubForIde.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/KotlinFileStubForIde.kt
index 53110d22253..2cefc47b0ea 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/KotlinFileStubForIde.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/KotlinFileStubForIde.kt
@@ -20,18 +20,18 @@ import com.intellij.psi.stubs.PsiClassHolderFileStub
 import com.intellij.util.io.StringRef
 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.psi.stubs.KotlinFileStub
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinFileStubImpl
 
 public class KotlinFileStubForIde(
-        jetFile: JetFile?,
+        jetFile: KtFile?,
         packageName: StringRef,
         isScript: Boolean,
         val facadeSimpleName: StringRef?,
         val partSimpleName: StringRef?,
         val facadePartSimpleNames: List<StringRef?>?
-) : KotlinFileStubImpl(jetFile, packageName, isScript), KotlinFileStub, PsiClassHolderFileStub<JetFile> {
+) : KotlinFileStubImpl(jetFile, packageName, isScript), KotlinFileStub, PsiClassHolderFileStub<KtFile> {
 
     private fun StringRef.relativeToPackage() = getPackageFqName().child(Name.identifier(this.string))
 
@@ -41,7 +41,7 @@ public class KotlinFileStubForIde(
     val partFqName: FqName?
         get() = partSimpleName?.relativeToPackage()
 
-    public constructor(jetFile: JetFile?, packageName: String, isScript: Boolean)
+    public constructor(jetFile: KtFile?, packageName: String, isScript: Boolean)
     : this(jetFile, StringRef.fromString(packageName)!!, isScript, null, null, null)
 
     companion object {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/PackageIndexUtil.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/PackageIndexUtil.kt
index b86c021c31f..70df1307492 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/PackageIndexUtil.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/PackageIndexUtil.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.stubindex
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.stubs.StubIndex
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.name.FqName
 import com.intellij.util.containers.MultiMap
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils
@@ -44,7 +44,7 @@ public object PackageIndexUtil {
             packageFqName: FqName,
             searchScope: GlobalSearchScope,
             project: Project
-    ): Collection<JetFile> {
+    ): Collection<KtFile> {
         return JetExactPackagesIndex.getInstance().get(packageFqName.asString(), project, searchScope)
     }
 
@@ -65,8 +65,8 @@ public object PackageIndexUtil {
             project: Project
     ): Boolean {
         var result = false
-        StubIndex.getInstance().processElements<String, JetFile>(
-                JetExactPackagesIndex.getInstance().getKey(), packageFqName.asString(), project, searchScope, javaClass<JetFile>()
+        StubIndex.getInstance().processElements<String, KtFile>(
+                JetExactPackagesIndex.getInstance().getKey(), packageFqName.asString(), project, searchScope, javaClass<KtFile>()
         ) {
             result = true
             false
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/StaticFacadeIndexUtil.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/StaticFacadeIndexUtil.kt
index e0fbea4f4b8..b503b0ae185 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/StaticFacadeIndexUtil.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/StaticFacadeIndexUtil.kt
@@ -21,7 +21,7 @@ import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
 public object StaticFacadeIndexUtil {
 
@@ -31,7 +31,7 @@ public object StaticFacadeIndexUtil {
             partFqName: FqName,
             searchScope: GlobalSearchScope,
             project: Project
-    ) : Collection<JetFile> =
+    ) : Collection<KtFile> =
             PackagePartClassUtils.getFilesWithCallables(
                     JetFileFacadeFqNameIndex.INSTANCE.get(partFqName.asString(), project, searchScope))
 
@@ -39,6 +39,6 @@ public object StaticFacadeIndexUtil {
             partFqName: FqName,
             searchScope: GlobalSearchScope,
             project: Project
-    ): Collection<JetFile> =
+    ): Collection<KtFile> =
             JetMultifileClassPartIndex.INSTANCE.get(partFqName.asString(), project, searchScope)
 }
\ No newline at end of file
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/PluginDeclarationProviderFactory.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/PluginDeclarationProviderFactory.kt
index 5ea395f17af..9dc6f5c9cf1 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/PluginDeclarationProviderFactory.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/PluginDeclarationProviderFactory.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.stubindex.resolve
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo
 import org.jetbrains.kotlin.resolve.lazy.declarations.*
 import org.jetbrains.kotlin.name.FqName
@@ -29,7 +29,7 @@ public class PluginDeclarationProviderFactory(
         private val project: Project,
         private val indexedFilesScope: GlobalSearchScope,
         private val storageManager: StorageManager,
-        private val nonIndexedFiles: Collection<JetFile>
+        private val nonIndexedFiles: Collection<KtFile>
 ) : AbstractDeclarationProviderFactory(storageManager) {
     private val fileBasedDeclarationProviderFactory = FileBasedDeclarationProviderFactory(storageManager, nonIndexedFiles)
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/PluginDeclarationProviderFactoryService.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/PluginDeclarationProviderFactoryService.kt
index 1139fcc89de..73a403620b2 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/PluginDeclarationProviderFactoryService.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/PluginDeclarationProviderFactoryService.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.stubindex.resolve
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.idea.stubindex.JetSourceFilterScope
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
 import org.jetbrains.kotlin.storage.StorageManager
@@ -29,7 +29,7 @@ public class PluginDeclarationProviderFactoryService : DeclarationProviderFactor
     override fun create(
             project: Project,
             storageManager: StorageManager,
-            syntheticFiles: Collection<JetFile>,
+            syntheticFiles: Collection<KtFile>,
             filesScope: GlobalSearchScope
     ): DeclarationProviderFactory =
         PluginDeclarationProviderFactory(project, JetSourceFilterScope.kotlinSources(filesScope, project), storageManager, syntheticFiles)
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/StubBasedPackageMemberDeclarationProvider.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/StubBasedPackageMemberDeclarationProvider.kt
index c9372752aa6..8752611e53f 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/StubBasedPackageMemberDeclarationProvider.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/StubBasedPackageMemberDeclarationProvider.kt
@@ -42,10 +42,10 @@ public class StubBasedPackageMemberDeclarationProvider(
         private val searchScope: GlobalSearchScope
 ) : PackageMemberDeclarationProvider {
 
-    override fun getDeclarations(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): List<JetDeclaration> {
-        val result = ArrayList<JetDeclaration>()
+    override fun getDeclarations(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): List<KtDeclaration> {
+        val result = ArrayList<KtDeclaration>()
 
-        fun addFromIndex(index: StringStubIndexExtension<out JetNamedDeclaration>) {
+        fun addFromIndex(index: StringStubIndexExtension<out KtNamedDeclaration>) {
             index.get(fqName.asString(), project, searchScope).filterTo(result) { nameFilter(it.getNameAsSafeName()) }
         }
 
@@ -69,11 +69,11 @@ public class StubBasedPackageMemberDeclarationProvider(
                 .map { JetClassInfoUtil.createClassLikeInfo(it) }
     }
 
-    override fun getFunctionDeclarations(name: Name): Collection<JetNamedFunction> {
+    override fun getFunctionDeclarations(name: Name): Collection<KtNamedFunction> {
         return JetTopLevelFunctionFqnNameIndex.getInstance().get(childName(name), project, searchScope)
     }
 
-    override fun getPropertyDeclarations(name: Name): Collection<JetProperty> {
+    override fun getPropertyDeclarations(name: Name): Collection<KtProperty> {
         return JetTopLevelPropertyFqnNameIndex.getInstance().get(childName(name), project, searchScope)
     }
 
@@ -81,7 +81,7 @@ public class StubBasedPackageMemberDeclarationProvider(
         return PackageIndexUtil.getSubPackageFqNames(fqName, searchScope, project, nameFilter)
     }
 
-    override fun getPackageFiles(): Collection<JetFile> {
+    override fun getPackageFiles(): Collection<KtFile> {
        return PackageIndexUtil.findFilesWithExactPackage(fqName, searchScope, project)
     }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ImportInsertHelper.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ImportInsertHelper.kt
index 116c1dc67b6..dd7fc1fca0f 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ImportInsertHelper.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ImportInsertHelper.kt
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.idea.util
 import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.ImportPath
 import java.util.*
 
 public abstract class ImportInsertHelper {
     /*TODO: implementation is not quite correct*/
-    public abstract fun isImportedWithDefault(importPath: ImportPath, contextFile: JetFile): Boolean
+    public abstract fun isImportedWithDefault(importPath: ImportPath, contextFile: KtFile): Boolean
 
     public abstract fun mayImportOnShortenReferences(descriptor: DeclarationDescriptor): Boolean
 
@@ -37,7 +37,7 @@ public abstract class ImportInsertHelper {
         ALREADY_IMPORTED
     }
 
-    public abstract fun importDescriptor(file: JetFile, descriptor: DeclarationDescriptor): ImportDescriptorResult
+    public abstract fun importDescriptor(file: KtFile, descriptor: DeclarationDescriptor): ImportDescriptorResult
 
     companion object {
         @JvmStatic
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/JetPsiPrecedences.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/JetPsiPrecedences.kt
index e3bdcd4a59a..dc13468fbb6 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/JetPsiPrecedences.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/JetPsiPrecedences.kt
@@ -42,13 +42,13 @@ public object JetPsiPrecedences {
     public val PRECEDENCE_OF_PREFIX_EXPRESSION: Int = PREFIX.ordinal()
     public val PRECEDENCE_OF_POSTFIX_EXPRESSION: Int = POSTFIX.ordinal()
 
-    public fun getPrecedence(expression: JetExpression): Int {
+    public fun getPrecedence(expression: KtExpression): Int {
         return when (expression) {
-            is JetAnnotatedExpression,
-            is JetLabeledExpression,
-            is JetPrefixExpression -> PRECEDENCE_OF_PREFIX_EXPRESSION
-            is JetPostfixExpression -> PRECEDENCE_OF_POSTFIX_EXPRESSION
-            is JetOperationExpression -> {
+            is KtAnnotatedExpression,
+            is KtLabeledExpression,
+            is KtPrefixExpression -> PRECEDENCE_OF_PREFIX_EXPRESSION
+            is KtPostfixExpression -> PRECEDENCE_OF_POSTFIX_EXPRESSION
+            is KtOperationExpression -> {
                 val operation = expression.getOperationReference().getReferencedNameElementType()
                 val precedenceNumber = precedence[operation]
                 if (precedenceNumber == null) {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ShortenReferences.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ShortenReferences.kt
index 44b2e075fae..e27366f3b0a 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ShortenReferences.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ShortenReferences.kt
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.resolve.scopes.utils.getClassifier
 import org.jetbrains.kotlin.resolve.scopes.utils.getFileScope
 import java.util.*
 
-public class ShortenReferences(val options: (JetElement) -> Options = { Options.DEFAULT }) {
+public class ShortenReferences(val options: (KtElement) -> Options = { Options.DEFAULT }) {
     public data class Options(
             val removeThisLabels: Boolean = false,
             val removeThis: Boolean = false
@@ -61,20 +61,20 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
         private fun DeclarationDescriptor.asString()
                 = DescriptorRenderer.FQ_NAMES_IN_TYPES.render(this)
 
-        private fun JetReferenceExpression.targets(context: BindingContext) = getImportableTargets(context)
+        private fun KtReferenceExpression.targets(context: BindingContext) = getImportableTargets(context)
 
-        private fun mayImport(descriptor: DeclarationDescriptor, file: JetFile): Boolean {
+        private fun mayImport(descriptor: DeclarationDescriptor, file: KtFile): Boolean {
             return descriptor.canBeReferencedViaImport()
                    && ImportInsertHelper.getInstance(file.getProject()).mayImportOnShortenReferences(descriptor)
         }
     }
 
     @JvmOverloads
-    public fun process(element: JetElement, elementFilter: (PsiElement) -> FilterResult = { FilterResult.PROCESS }): JetElement {
+    public fun process(element: KtElement, elementFilter: (PsiElement) -> FilterResult = { FilterResult.PROCESS }): KtElement {
         return process(listOf(element), elementFilter).single()
     }
 
-    public fun process(file: JetFile, startOffset: Int, endOffset: Int) {
+    public fun process(file: KtFile, startOffset: Int, endOffset: Int) {
         val documentManager = PsiDocumentManager.getInstance(file.getProject())
         val document = documentManager.getDocument(file)!!
         if (!documentManager.isCommitted(document)) {
@@ -95,8 +95,8 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
 
                         range.intersects(elementRange) -> {
                             // for qualified call expression allow to shorten only the part without parenthesis
-                            val calleeExpression = ((element as? JetDotQualifiedExpression)
-                                    ?.getSelectorExpression() as? JetCallExpression)
+                            val calleeExpression = ((element as? KtDotQualifiedExpression)
+                                    ?.getSelectorExpression() as? KtCallExpression)
                                     ?.getCalleeExpression()
                             if (calleeExpression != null) {
                                 val rangeWithoutParenthesis = TextRange(elementRange.getStartOffset(), calleeExpression.getTextRange()!!.getEndOffset())
@@ -127,16 +127,16 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
     }
 
     @JvmOverloads
-    public fun process(elements: Iterable<JetElement>, elementFilter: (PsiElement) -> FilterResult = { FilterResult.PROCESS }): Collection<JetElement> {
+    public fun process(elements: Iterable<KtElement>, elementFilter: (PsiElement) -> FilterResult = { FilterResult.PROCESS }): Collection<KtElement> {
         return elements.groupBy { element -> element.getContainingJetFile() }
                 .flatMap { shortenReferencesInFile(it.key, it.value, elementFilter) }
     }
 
     private fun shortenReferencesInFile(
-            file: JetFile,
-            elements: List<JetElement>,
+            file: KtFile,
+            elements: List<KtElement>,
             elementFilter: (PsiElement) -> FilterResult
-    ): Collection<JetElement> {
+    ): Collection<KtElement> {
         //TODO: that's not correct since we have options!
         val elementsToUse = dropNestedElements(elements)
 
@@ -174,9 +174,9 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
         return elementsToUse
     }
 
-    private fun dropNestedElements(elements: List<JetElement>): LinkedHashSet<JetElement> {
+    private fun dropNestedElements(elements: List<KtElement>): LinkedHashSet<KtElement> {
         val elementSet = elements.toSet()
-        val newElements = LinkedHashSet<JetElement>(elementSet.size())
+        val newElements = LinkedHashSet<KtElement>(elementSet.size())
         for (element in elementSet) {
             if (!element.parents.any { it in elementSet }) {
                 newElements.add(element)
@@ -185,7 +185,7 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
         return newElements
     }
 
-    private fun analyzeReferences(elements: Iterable<JetElement>, visitor: ShorteningVisitor<*>): Set<DeclarationDescriptor> {
+    private fun analyzeReferences(elements: Iterable<KtElement>, visitor: ShorteningVisitor<*>): Set<DeclarationDescriptor> {
         for (element in elements) {
             visitor.options = options(element)
             element.accept(visitor)
@@ -193,11 +193,11 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
         return visitor.getDescriptorsToImport()
     }
 
-    private abstract class ShorteningVisitor<T : JetElement>(
-            protected val file: JetFile,
+    private abstract class ShorteningVisitor<T : KtElement>(
+            protected val file: KtFile,
             protected val elementFilter: (PsiElement) -> FilterResult,
             protected val failedToImportDescriptors: Set<DeclarationDescriptor>
-    ) : JetVisitorVoid() {
+    ) : KtVisitorVoid() {
         var options: Options = Options.DEFAULT
 
         private val elementsToShorten = ArrayList<T>()
@@ -205,7 +205,7 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
 
         private val resolutionFacade = file.getResolutionFacade()
 
-        protected fun analyze(element: JetElement)
+        protected fun analyze(element: KtElement)
                 = resolutionFacade.analyze(element, BodyResolveMode.PARTIAL)
 
         protected fun processQualifiedElement(element: T, target: DeclarationDescriptor, canShortenNow: Boolean) {
@@ -224,9 +224,9 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
             elementsToShorten.add(element)
         }
 
-        protected abstract fun qualifier(element: T): JetElement
+        protected abstract fun qualifier(element: T): KtElement
 
-        protected abstract fun shortenElement(element: T): JetElement
+        protected abstract fun shortenElement(element: T): KtElement
 
         override fun visitElement(element: PsiElement) {
             if (elementFilter(element) != FilterResult.SKIP) {
@@ -234,7 +234,7 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
             }
         }
 
-        public fun shortenElements(elementSetToUpdate: MutableSet<JetElement>) {
+        public fun shortenElements(elementSetToUpdate: MutableSet<KtElement>) {
             for (element in elementsToShorten) {
                 if (!element.isValid()) continue
                 val newElement = shortenElement(element)
@@ -249,11 +249,11 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
     }
 
     private class ShortenTypesVisitor(
-            file: JetFile,
+            file: KtFile,
             elementFilter: (PsiElement) -> FilterResult,
             failedToImportDescriptors: Set<DeclarationDescriptor>
-    ) : ShorteningVisitor<JetUserType>(file, elementFilter, failedToImportDescriptors) {
-        override fun visitUserType(userType: JetUserType) {
+    ) : ShorteningVisitor<KtUserType>(file, elementFilter, failedToImportDescriptors) {
+        override fun visitUserType(userType: KtUserType) {
             val filterResult = elementFilter(userType)
             if (filterResult == FilterResult.SKIP) return
 
@@ -267,14 +267,14 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
             }
         }
 
-        private fun processType(type: JetUserType) {
+        private fun processType(type: KtUserType) {
             if (type.getQualifier() == null) return
             val referenceExpression = type.getReferenceExpression() ?: return
 
             val bindingContext = analyze(referenceExpression)
             val target = referenceExpression.targets(bindingContext).singleOrNull() ?: return
 
-            val typeReference = type.getStrictParentOfType<JetTypeReference>()!!
+            val typeReference = type.getStrictParentOfType<KtTypeReference>()!!
             val scope = bindingContext[BindingContext.LEXICAL_SCOPE, typeReference] ?: return
             val name = target.getName()
             val targetByName = if (target is ClassifierDescriptor)
@@ -286,20 +286,20 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
             processQualifiedElement(type, target, canShortenNow)
         }
 
-        override fun qualifier(element: JetUserType) = element.getQualifier()!!
+        override fun qualifier(element: KtUserType) = element.getQualifier()!!
 
-        override fun shortenElement(element: JetUserType): JetElement {
+        override fun shortenElement(element: KtUserType): KtElement {
             element.deleteQualifier()
             return element
         }
     }
 
     private abstract class QualifiedExpressionShorteningVisitor(
-            file: JetFile,
+            file: KtFile,
             elementFilter: (PsiElement) -> FilterResult,
             failedToImportDescriptors: Set<DeclarationDescriptor>
-    ) : ShorteningVisitor<JetDotQualifiedExpression>(file, elementFilter, failedToImportDescriptors) {
-        override fun visitDotQualifiedExpression(expression: JetDotQualifiedExpression) {
+    ) : ShorteningVisitor<KtDotQualifiedExpression>(file, elementFilter, failedToImportDescriptors) {
+        override fun visitDotQualifiedExpression(expression: KtDotQualifiedExpression) {
             val filterResult = elementFilter(expression)
             if (filterResult == FilterResult.SKIP) return
 
@@ -312,23 +312,23 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
             expression.getReceiverExpression().accept(this)
         }
 
-        abstract fun process(qualifiedExpression: JetDotQualifiedExpression): Boolean
+        abstract fun process(qualifiedExpression: KtDotQualifiedExpression): Boolean
 
-        override fun qualifier(element: JetDotQualifiedExpression) = element.getReceiverExpression()
+        override fun qualifier(element: KtDotQualifiedExpression) = element.getReceiverExpression()
     }
 
     private class ShortenQualifiedExpressionsVisitor(
-            file: JetFile,
+            file: KtFile,
             elementFilter: (PsiElement) -> FilterResult,
             failedToImportDescriptors: Set<DeclarationDescriptor>
     ) : QualifiedExpressionShorteningVisitor(file, elementFilter, failedToImportDescriptors) {
 
-        override fun process(qualifiedExpression: JetDotQualifiedExpression): Boolean {
+        override fun process(qualifiedExpression: KtDotQualifiedExpression): Boolean {
             val bindingContext = analyze(qualifiedExpression)
 
             val receiver = qualifiedExpression.getReceiverExpression()
             when (receiver) {
-                is JetThisExpression -> {
+                is KtThisExpression -> {
                     if (!options.removeThis) return false
                 }
                 else -> {
@@ -338,19 +338,19 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
 
             if (PsiTreeUtil.getParentOfType(
                     qualifiedExpression,
-                    javaClass<JetImportDirective>(), javaClass<JetPackageDirective>()) != null) return true
+                    javaClass<KtImportDirective>(), javaClass<KtPackageDirective>()) != null) return true
 
             val selector = qualifiedExpression.getSelectorExpression() ?: return false
-            val callee = selector.getCalleeExpressionIfAny() as? JetReferenceExpression ?: return false
+            val callee = selector.getCalleeExpressionIfAny() as? KtReferenceExpression ?: return false
             val target = callee.targets(bindingContext).singleOrNull() ?: return false
 
             val scope = bindingContext[BindingContext.RESOLUTION_SCOPE, qualifiedExpression] ?: return false
-            val selectorCopy = selector.copy() as JetReferenceExpression
+            val selectorCopy = selector.copy() as KtReferenceExpression
             val newContext = selectorCopy.analyzeInContext(scope, selector)
-            val targetsWhenShort = (selectorCopy.getCalleeExpressionIfAny() as JetReferenceExpression).targets(newContext)
+            val targetsWhenShort = (selectorCopy.getCalleeExpressionIfAny() as KtReferenceExpression).targets(newContext)
             val targetsMatch = targetsWhenShort.singleOrNull()?.asString() == target.asString()
 
-            if (receiver is JetThisExpression) {
+            if (receiver is KtThisExpression) {
                 if (!targetsMatch) return false
                 val originalCall = selector.getResolvedCall(bindingContext) ?: return false
                 val newCall = selectorCopy.getResolvedCall(newContext) ?: return false
@@ -374,19 +374,19 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
             return true
         }
 
-        override fun shortenElement(element: JetDotQualifiedExpression): JetElement {
-            return element.replace(element.getSelectorExpression()!!) as JetElement
+        override fun shortenElement(element: KtDotQualifiedExpression): KtElement {
+            return element.replace(element.getSelectorExpression()!!) as KtElement
         }
     }
 
     private class ShortenThisExpressionsVisitor(
-            file: JetFile,
+            file: KtFile,
             elementFilter: (PsiElement) -> FilterResult,
             failedToImportDescriptors: Set<DeclarationDescriptor>
-    ) : ShorteningVisitor<JetThisExpression>(file, elementFilter, failedToImportDescriptors) {
-        private val simpleThis = JetPsiFactory(file).createExpression("this") as JetThisExpression
+    ) : ShorteningVisitor<KtThisExpression>(file, elementFilter, failedToImportDescriptors) {
+        private val simpleThis = KtPsiFactory(file).createExpression("this") as KtThisExpression
 
-        private fun process(thisExpression: JetThisExpression) {
+        private fun process(thisExpression: KtThisExpression) {
             if (!options.removeThisLabels || thisExpression.getTargetLabel() == null) return
 
             val bindingContext = analyze(thisExpression)
@@ -400,38 +400,38 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
             }
         }
 
-        override fun visitThisExpression(expression: JetThisExpression) {
+        override fun visitThisExpression(expression: KtThisExpression) {
             if (elementFilter(expression) == FilterResult.PROCESS) {
                 process(expression)
             }
         }
 
-        override fun qualifier(element: JetThisExpression): JetElement =
+        override fun qualifier(element: KtThisExpression): KtElement =
                 throw AssertionError("Qualifier requested: ${element.getElementTextWithContext()}")
 
-        override fun shortenElement(element: JetThisExpression): JetElement {
-            return element.replace(simpleThis) as JetElement
+        override fun shortenElement(element: KtThisExpression): KtElement {
+            return element.replace(simpleThis) as KtElement
         }
     }
 
     private class RemoveExplicitCompanionObjectReferenceVisitor(
-            file: JetFile,
+            file: KtFile,
             elementFilter: (PsiElement) -> FilterResult,
             failedToImportDescriptors: Set<DeclarationDescriptor>
     ) : QualifiedExpressionShorteningVisitor(file, elementFilter, failedToImportDescriptors) {
 
-        private fun JetExpression.singleTarget(context: BindingContext): DeclarationDescriptor? {
-            return (getCalleeExpressionIfAny() as? JetReferenceExpression)?.targets(context)?.singleOrNull()
+        private fun KtExpression.singleTarget(context: BindingContext): DeclarationDescriptor? {
+            return (getCalleeExpressionIfAny() as? KtReferenceExpression)?.targets(context)?.singleOrNull()
         }
 
-        override fun process(qualifiedExpression: JetDotQualifiedExpression): Boolean {
+        override fun process(qualifiedExpression: KtDotQualifiedExpression): Boolean {
             val bindingContext = analyze(qualifiedExpression)
 
             val receiver = qualifiedExpression.getReceiverExpression()
 
             if (PsiTreeUtil.getParentOfType(
                     qualifiedExpression,
-                    javaClass<JetImportDirective>(), javaClass<JetPackageDirective>()) != null) return false
+                    javaClass<KtImportDirective>(), javaClass<KtPackageDirective>()) != null) return false
 
             val receiverTarget = receiver.singleTarget(bindingContext) ?: return false
             if (receiverTarget !is ClassDescriptor) return false
@@ -441,7 +441,7 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
 
             if (receiverTarget.getCompanionObjectDescriptor() != selectorTarget) return false
 
-            val selectorsSelector = (qualifiedExpression.getParent() as? JetDotQualifiedExpression)?.getSelectorExpression()
+            val selectorsSelector = (qualifiedExpression.getParent() as? KtDotQualifiedExpression)?.getSelectorExpression()
             if (selectorsSelector == null) {
                 addElementToShorten(qualifiedExpression)
                 return true
@@ -454,8 +454,8 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
             return true
         }
 
-        override fun shortenElement(element: JetDotQualifiedExpression): JetElement {
-            return element.replace(element.getReceiverExpression()) as JetElement
+        override fun shortenElement(element: KtDotQualifiedExpression): KtElement {
+            return element.replace(element.getReceiverExpression()) as KtElement
         }
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/plugin/references/SimpleNameReferenceExtension.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/plugin/references/SimpleNameReferenceExtension.kt
index 94b1739602a..0e89d7c6622 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/plugin/references/SimpleNameReferenceExtension.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/plugin/references/SimpleNameReferenceExtension.kt
@@ -17,15 +17,15 @@
 package org.jetbrains.kotlin.plugin.references
 
 import com.intellij.openapi.extensions.ExtensionPointName
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtPsiFactory
 
 public interface SimpleNameReferenceExtension {
     companion object {
         public val EP_NAME: ExtensionPointName<SimpleNameReferenceExtension> = ExtensionPointName.create("org.jetbrains.kotlin.simpleNameReferenceExtension")!!
     }
 
-    fun isReferenceTo(reference: JetSimpleNameReference, element: PsiElement): Boolean?
-    fun handleElementRename(reference: JetSimpleNameReference, psiFactory: JetPsiFactory, newElementName: String): PsiElement?
+    fun isReferenceTo(reference: KtSimpleNameReference, element: PsiElement): Boolean?
+    fun handleElementRename(reference: KtSimpleNameReference, psiFactory: KtPsiFactory, newElementName: String): PsiElement?
 }
\ No newline at end of file
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/AllClassesCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/AllClassesCompletion.kt
index 113a8f79771..2c806a8f366 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/AllClassesCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/AllClassesCompletion.kt
@@ -26,9 +26,9 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.idea.core.KotlinIndicesHelper
 import org.jetbrains.kotlin.idea.project.ProjectStructureUtil
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.getDescriptorsFiltered
 
 class AllClassesCompletion(private val parameters: CompletionParameters,
@@ -51,12 +51,12 @@ class AllClassesCompletion(private val parameters: CompletionParameters,
                 .getKotlinClasses({ prefixMatcher.prefixMatches(it) }, kindFilter)
                 .forEach { classDescriptorCollector(it) }
 
-        if (!ProjectStructureUtil.isJsKotlinModule(parameters.originalFile as JetFile)) {
+        if (!ProjectStructureUtil.isJsKotlinModule(parameters.originalFile as KtFile)) {
             addAdaptedJavaCompletion(javaClassCollector)
         }
     }
 
-    private fun collectClassesFromScope(scope: JetScope, collector: (ClassDescriptor) -> Unit) {
+    private fun collectClassesFromScope(scope: KtScope, collector: (ClassDescriptor) -> Unit) {
         for (descriptor in scope.getDescriptorsFiltered(DescriptorKindFilter.CLASSIFIERS)) {
             if (descriptor is ClassDescriptor) {
                 if (kindFilter(descriptor.kind) && prefixMatcher.prefixMatches(descriptor.name.asString())) {
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt
index 7685689c4c6..b8026434862 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt
@@ -110,7 +110,7 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
         }
 
         if (nameExpression == null) {
-            val parameter = position.getParent() as? JetParameter
+            val parameter = position.getParent() as? KtParameter
             return if (parameter != null && position == parameter.getNameIdentifier())
                 CompletionKind.PARAMETER_NAME
             else
@@ -119,13 +119,13 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
 
         // Check that completion in the type annotation context and if there's a qualified
         // expression we are at first of it
-        val typeReference = position.getStrictParentOfType<JetTypeReference>()
+        val typeReference = position.getStrictParentOfType<KtTypeReference>()
         if (typeReference != null) {
-            if (typeReference.parent is JetSuperExpression) {
+            if (typeReference.parent is KtSuperExpression) {
                 return CompletionKind.SUPER_QUALIFIER
             }
 
-            val firstPartReference = PsiTreeUtil.findChildOfType(typeReference, javaClass<JetSimpleNameExpression>())
+            val firstPartReference = PsiTreeUtil.findChildOfType(typeReference, javaClass<KtSimpleNameExpression>())
             if (firstPartReference == nameExpression) {
                 return CompletionKind.TYPES
             }
@@ -137,13 +137,13 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
     private fun shouldCompleteParameterNameAndType(): Boolean {
         if (completionKind != CompletionKind.PARAMETER_NAME) return false
 
-        val parameter = position.getNonStrictParentOfType<JetParameter>()!!
-        val list = parameter.parent as? JetParameterList ?: return false
+        val parameter = position.getNonStrictParentOfType<KtParameter>()!!
+        val list = parameter.parent as? KtParameterList ?: return false
         val owner = list.parent
         return when (owner) {
-            is JetCatchClause, is JetPropertyAccessor, is JetFunctionLiteral -> false
-            is JetNamedFunction -> owner.nameIdentifier != null
-            is JetPrimaryConstructor -> !owner.getContainingClassOrObject().isAnnotation()
+            is KtCatchClause, is KtPropertyAccessor, is KtFunctionLiteral -> false
+            is KtNamedFunction -> owner.nameIdentifier != null
+            is KtPrimaryConstructor -> !owner.getContainingClassOrObject().isAnnotation()
             else -> true
         }
     }
@@ -221,7 +221,7 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
                 val packageNames = PackageIndexUtil.getSubPackageFqNames(FqName.ROOT, originalSearchScope, project, prefixMatcher.asNameFilter())
                         .toMutableSet()
 
-                if (!ProjectStructureUtil.isJsKotlinModule(parameters.getOriginalFile() as JetFile)) {
+                if (!ProjectStructureUtil.isJsKotlinModule(parameters.getOriginalFile() as KtFile)) {
                     JavaPsiFacade.getInstance(project).findPackage("")?.getSubPackages(originalSearchScope)?.forEach { psiPackage ->
                         val name = psiPackage.getName()
                         if (Name.isValidIdentifier(name!!)) {
@@ -242,7 +242,7 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
 
                 completeNonImported()
 
-                if (position.getContainingFile() is JetCodeFragment) {
+                if (position.getContainingFile() is KtCodeFragment) {
                     flushToResultSet()
                     collector.addDescriptorElements(getRuntimeReceiverTypeReferenceVariants(), withReceiverCast = true)
                 }
@@ -339,7 +339,7 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
     }
 
     private fun completeSuperQualifier() {
-        val classOrObject = position.parents.firstIsInstanceOrNull<JetClassOrObject>() ?: return
+        val classOrObject = position.parents.firstIsInstanceOrNull<KtClassOrObject>() ?: return
         val classDescriptor = resolutionFacade.resolveToDescriptor(classOrObject) as ClassDescriptor
         var superClasses = classDescriptor.defaultType.constructor.supertypes
                 .map { it.constructor.declarationDescriptor as? ClassDescriptor }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt
index 802dc979d53..1afec0bbb62 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.decapitalizeSmart
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstance
@@ -68,21 +68,21 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
                                      protected val parameters: CompletionParameters,
                                      resultSet: CompletionResultSet) {
     protected val position = parameters.getPosition()
-    private val file = position.getContainingFile() as JetFile
+    private val file = position.getContainingFile() as KtFile
     protected val resolutionFacade = file.getResolutionFacade()
     protected val moduleDescriptor = resolutionFacade.moduleDescriptor
     protected val project = position.getProject()
-    protected val isJvmModule = !ProjectStructureUtil.isJsKotlinModule(parameters.originalFile as JetFile)
+    protected val isJvmModule = !ProjectStructureUtil.isJsKotlinModule(parameters.originalFile as KtFile)
 
-    protected val nameExpression: JetSimpleNameExpression?
-    protected val expression: JetExpression?
+    protected val nameExpression: KtSimpleNameExpression?
+    protected val expression: KtExpression?
 
     init {
-        val reference = (position.getParent() as? JetSimpleNameExpression)?.mainReference
+        val reference = (position.getParent() as? KtSimpleNameExpression)?.mainReference
         if (reference != null) {
-            if (reference.expression is JetLabelReferenceExpression) {
+            if (reference.expression is KtLabelReferenceExpression) {
                 this.nameExpression = null
-                this.expression = reference.expression.getParent().getParent() as? JetExpressionWithLabel
+                this.expression = reference.expression.getParent().getParent() as? KtExpressionWithLabel
             }
             else {
                 this.nameExpression = reference.expression
@@ -95,7 +95,7 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
         }
     }
 
-    protected val bindingContext = resolutionFacade.analyze(position.parentsWithSelf.firstIsInstance<JetElement>(), BodyResolveMode.PARTIAL_FOR_COMPLETION)
+    protected val bindingContext = resolutionFacade.analyze(position.parentsWithSelf.firstIsInstance<KtElement>(), BodyResolveMode.PARTIAL_FOR_COMPLETION)
     protected val inDescriptor = position.getResolutionScope(bindingContext, resolutionFacade).ownerDescriptor
 
     private val kotlinIdentifierStartPattern = StandardPatterns.character().javaIdentifierStart() andNot singleCharPattern('$')
@@ -139,7 +139,7 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
         LookupElementsCollector(prefixMatcher, parameters, resultSet, lookupElementFactory, createSorter())
     }
 
-    protected val originalSearchScope: GlobalSearchScope = getResolveScope(parameters.getOriginalFile() as JetFile)
+    protected val originalSearchScope: GlobalSearchScope = getResolveScope(parameters.getOriginalFile() as KtFile)
 
     // we need to exclude the original file from scope because our resolve session is built with this file replaced by synthetic one
     protected val searchScope: GlobalSearchScope = object : DelegatingGlobalSearchScope(originalSearchScope) {
@@ -150,7 +150,7 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
         get() = KotlinIndicesHelper(resolutionFacade, searchScope, isVisibleFilter, true)
 
     protected val toFromOriginalFileMapper: ToFromOriginalFileMapper
-            = ToFromOriginalFileMapper(parameters.originalFile as JetFile, position.containingFile as JetFile, parameters.offset)
+            = ToFromOriginalFileMapper(parameters.originalFile as KtFile, position.containingFile as KtFile, parameters.offset)
 
     private fun isVisibleDescriptor(descriptor: DeclarationDescriptor): Boolean {
         if (!configuration.completeJavaClassesNotToBeUsed && descriptor is ClassDescriptor) {
@@ -257,14 +257,14 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
     }
 
     // filters out variable inside its initializer
-    private fun Collection<DeclarationDescriptor>.excludeNonInitializedVariable(expression: JetExpression): Collection<DeclarationDescriptor> {
+    private fun Collection<DeclarationDescriptor>.excludeNonInitializedVariable(expression: KtExpression): Collection<DeclarationDescriptor> {
         for (element in expression.parentsWithSelf) {
             val parent = element.getParent()
-            if (parent is JetVariableDeclaration && element == parent.getInitializer()) {
+            if (parent is KtVariableDeclaration && element == parent.getInitializer()) {
                 val descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, parent]
                 return this.filter { it != descriptor }
             }
-            if (element is JetDeclaration) break // we can use variable inside lambda or anonymous object located in its initializer
+            if (element is KtDeclaration) break // we can use variable inside lambda or anonymous object located in its initializer
         }
         return this
     }
@@ -287,7 +287,7 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
 
     protected fun isNoQualifierContext(): Boolean {
         val parent = position.getParent()
-        return parent is JetSimpleNameExpression && !JetPsiUtil.isSelectorInQualified(parent)
+        return parent is KtSimpleNameExpression && !KtPsiUtil.isSelectorInQualified(parent)
     }
 
     protected fun getTopLevelCallables(): Collection<DeclarationDescriptor> {
@@ -313,7 +313,7 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
                 )
     }
 
-    private fun createLookupElementFactory(callType: CallType<*>?, receiverTypes: Collection<JetType>?): LookupElementFactory {
+    private fun createLookupElementFactory(callType: CallType<*>?, receiverTypes: Collection<KtType>?): LookupElementFactory {
         val contextVariablesProvider = {
             nameExpression?.let {
                 referenceVariantsHelper.getReferenceVariants(it, DescriptorKindFilter.VARIABLES, { true }, CallTypeAndReceiver.DEFAULT)
@@ -323,11 +323,11 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
 
         val insertHandlerProvider = InsertHandlerProvider(callType) { expectedInfos }
         return LookupElementFactory(resolutionFacade, receiverTypes,
-                                    callType, expression?.parent is JetSimpleNameStringTemplateEntry,
+                                    callType, expression?.parent is KtSimpleNameStringTemplateEntry,
                                     insertHandlerProvider, contextVariablesProvider)
     }
 
-    private fun detectCallTypeAndReceiverTypes(): Pair<CallTypeAndReceiver<*, *>, Collection<JetType>?> {
+    private fun detectCallTypeAndReceiverTypes(): Pair<CallTypeAndReceiver<*, *>, Collection<KtType>?> {
         if (nameExpression == null) {
             return CallTypeAndReceiver.UNKNOWN to null
         }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionUtils.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionUtils.kt
index 6bb90227a00..9e393b6518e 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionUtils.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionUtils.kt
@@ -26,7 +26,7 @@ import com.intellij.psi.PsiDocumentManager
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
-import org.jetbrains.kotlin.idea.JetIcons
+import org.jetbrains.kotlin.idea.KtIcons
 import org.jetbrains.kotlin.idea.completion.handlers.CastReceiverInsertHandler
 import org.jetbrains.kotlin.idea.completion.handlers.WithTailInsertHandler
 import org.jetbrains.kotlin.idea.core.getResolutionScope
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.renderer.render
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.resolve.scopes.utils.asJetScope
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.typeUtil.TypeNullability
 import org.jetbrains.kotlin.types.typeUtil.nullability
 import java.util.*
@@ -188,35 +188,35 @@ class ThisItemLookupObject(val receiverParameter: ReceiverParameterDescriptor, v
 fun ThisItemLookupObject.createLookupElement() = createKeywordElement("this", labelName.labelNameToTail(), lookupObject = this)
         .withTypeText(DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(receiverParameter.type))
 
-fun thisExpressionItems(bindingContext: BindingContext, position: JetExpression, prefix: String, resolutionFacade: ResolutionFacade): Collection<ThisItemLookupObject> {
+fun thisExpressionItems(bindingContext: BindingContext, position: KtExpression, prefix: String, resolutionFacade: ResolutionFacade): Collection<ThisItemLookupObject> {
     val scope = position.getResolutionScope(bindingContext, resolutionFacade)
 
-    val psiFactory = JetPsiFactory(position)
+    val psiFactory = KtPsiFactory(position)
 
     val result = ArrayList<ThisItemLookupObject>()
     for ((receiver, expressionFactory) in scope.asJetScope().getImplicitReceiversWithInstanceToExpression()) {
         if (expressionFactory == null) continue
         // if prefix does not start with "this@" do not include immediate this in the form with label
-        val expression = expressionFactory.createExpression(psiFactory, shortThis = !prefix.startsWith("this@")) as? JetThisExpression ?: continue
+        val expression = expressionFactory.createExpression(psiFactory, shortThis = !prefix.startsWith("this@")) as? KtThisExpression ?: continue
         result.add(ThisItemLookupObject(receiver, expression.getLabelNameAsName()))
     }
     return result
 }
 
-fun returnExpressionItems(bindingContext: BindingContext, position: JetElement): Collection<LookupElement> {
+fun returnExpressionItems(bindingContext: BindingContext, position: KtElement): Collection<LookupElement> {
     val result = ArrayList<LookupElement>()
     for (parent in position.parentsWithSelf) {
-        if (parent is JetDeclarationWithBody) {
+        if (parent is KtDeclarationWithBody) {
             val returnType = parent.returnType(bindingContext)
             val isUnit = returnType == null || KotlinBuiltIns.isUnit(returnType)
-            if (parent is JetFunctionLiteral) {
+            if (parent is KtFunctionLiteral) {
                 val (label, call) = parent.findLabelAndCall()
                 if (label != null) {
                     result.add(createKeywordElementWithSpace("return", tail = label.labelNameToTail(), addSpaceAfter = !isUnit))
                 }
 
                 // check if the current function literal is inlined and stop processing outer declarations if it's not
-                val callee = call?.getCalleeExpression() as? JetReferenceExpression ?: break // not inlined
+                val callee = call?.getCalleeExpression() as? KtReferenceExpression ?: break // not inlined
                 if (!InlineUtil.isInline(bindingContext[BindingContext.REFERENCE_TARGET, callee])) break // not inlined
             }
             else {
@@ -247,7 +247,7 @@ fun returnExpressionItems(bindingContext: BindingContext, position: JetElement):
     return result
 }
 
-private fun JetDeclarationWithBody.returnType(bindingContext: BindingContext): JetType? {
+private fun KtDeclarationWithBody.returnType(bindingContext: BindingContext): KtType? {
     val callable = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, this] as? CallableDescriptor ?: return null
     return callable.getReturnType()
 }
@@ -287,35 +287,35 @@ private fun createKeywordElement(
     return element
 }
 
-fun breakOrContinueExpressionItems(position: JetElement, breakOrContinue: String): Collection<LookupElement> {
+fun breakOrContinueExpressionItems(position: KtElement, breakOrContinue: String): Collection<LookupElement> {
     val result = ArrayList<LookupElement>()
 
     parentsLoop@
     for (parent in position.parentsWithSelf) {
         when (parent) {
-            is JetLoopExpression -> {
+            is KtLoopExpression -> {
                 if (result.isEmpty()) {
                     result.add(createKeywordElement(breakOrContinue))
                 }
 
-                val label = (parent.getParent() as? JetLabeledExpression)?.getLabelNameAsName()
+                val label = (parent.getParent() as? KtLabeledExpression)?.getLabelNameAsName()
                 if (label != null) {
                     result.add(createKeywordElement(breakOrContinue, tail = label.labelNameToTail()))
                 }
             }
 
-            is JetDeclarationWithBody -> break@parentsLoop //TODO: support non-local break's&continue's when they are supported by compiler
+            is KtDeclarationWithBody -> break@parentsLoop //TODO: support non-local break's&continue's when they are supported by compiler
         }
     }
     return result
 }
 
-fun LookupElementFactory.createLookupElementForType(type: JetType): LookupElement? {
+fun LookupElementFactory.createLookupElementForType(type: KtType): LookupElement? {
     if (type.isError()) return null
 
     if (KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(type)) {
         val text = IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType(type)
-        val baseLookupElement = LookupElementBuilder.create(text).withIcon(JetIcons.LAMBDA)
+        val baseLookupElement = LookupElementBuilder.create(text).withIcon(KtIcons.LAMBDA)
         return BaseTypeLookupElement(type, baseLookupElement)
     }
     else {
@@ -339,7 +339,7 @@ fun LookupElementFactory.createLookupElementForType(type: JetType): LookupElemen
     }
 }
 
-private open class BaseTypeLookupElement(type: JetType, baseLookupElement: LookupElement) : LookupElementDecorator<LookupElement>(baseLookupElement) {
+private open class BaseTypeLookupElement(type: KtType, baseLookupElement: LookupElement) : LookupElementDecorator<LookupElement>(baseLookupElement) {
     val fullText = IdeDescriptorRenderers.SOURCE_CODE.renderType(type)
 
     override fun equals(other: Any?) = other is BaseTypeLookupElement && fullText == other.fullText
@@ -358,7 +358,7 @@ private open class BaseTypeLookupElement(type: JetType, baseLookupElement: Looku
 
 fun shortenReferences(context: InsertionContext, startOffset: Int, endOffset: Int) {
     PsiDocumentManager.getInstance(context.project).commitAllDocuments()
-    ShortenReferences.DEFAULT.process(context.file as JetFile, startOffset, endOffset)
+    ShortenReferences.DEFAULT.process(context.file as KtFile, startOffset, endOffset)
 }
 
 fun <T> ElementPattern<T>.and(rhs: ElementPattern<T>) = StandardPatterns.and(this, rhs)
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/DataFlowInfoUtilForCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/DataFlowInfoUtilForCompletion.kt
index 8ba368a1e27..2a40ad4d990 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/DataFlowInfoUtilForCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/DataFlowInfoUtilForCompletion.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.completion
 
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValue
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
 
@@ -28,7 +28,7 @@ fun renderDataFlowValue(value: DataFlowValue): String? {
 
     fun renderId(id: Any?): String? {
         return when (id) {
-            is JetExpression -> id.getText()
+            is KtExpression -> id.getText()
             is ThisReceiver -> "this@${id.getDeclarationDescriptor().getName()}"
             is VariableDescriptor -> id.getName().asString()
             is PackageViewDescriptor -> id.fqName.asString()
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt
index 315ffb4a452..cb2418dd79d 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.resolve.ideService
 import org.jetbrains.kotlin.idea.util.FuzzyType
 import org.jetbrains.kotlin.idea.util.fuzzyReturnType
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelectorOrThis
@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.util.DelegatingCall
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasDefaultValue
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.typeUtil.containsError
@@ -97,15 +97,15 @@ class ExpectedInfo(
     constructor(fuzzyType: FuzzyType, expectedName: String?, tail: Tail?, itemOptions: ItemOptions = ItemOptions.DEFAULT, additionalData: ExpectedInfo.AdditionalData? = null)
         : this(ByExpectedTypeFilter(fuzzyType), expectedName, tail, itemOptions, additionalData)
 
-    constructor(type: JetType, expectedName: String?, tail: Tail?, itemOptions: ItemOptions = ItemOptions.DEFAULT, additionalData: ExpectedInfo.AdditionalData? = null)
+    constructor(type: KtType, expectedName: String?, tail: Tail?, itemOptions: ItemOptions = ItemOptions.DEFAULT, additionalData: ExpectedInfo.AdditionalData? = null)
         : this(FuzzyType(type, emptyList()), expectedName, tail, itemOptions, additionalData)
 
     fun matchingSubstitutor(descriptorType: FuzzyType): TypeSubstitutor? = filter.matchingSubstitutor(descriptorType)
 
-    fun matchingSubstitutor(descriptorType: JetType): TypeSubstitutor? = matchingSubstitutor(FuzzyType(descriptorType, emptyList()))
+    fun matchingSubstitutor(descriptorType: KtType): TypeSubstitutor? = matchingSubstitutor(FuzzyType(descriptorType, emptyList()))
 
     companion object {
-        fun createForArgument(type: JetType, expectedName: String?, tail: Tail?, argumentData: ArgumentPositionData, itemOptions: ItemOptions = ItemOptions.DEFAULT): ExpectedInfo {
+        fun createForArgument(type: KtType, expectedName: String?, tail: Tail?, argumentData: ArgumentPositionData, itemOptions: ItemOptions = ItemOptions.DEFAULT): ExpectedInfo {
             return ExpectedInfo(FuzzyType(type, argumentData.function.typeParameters), expectedName, tail, itemOptions, argumentData)
         }
 
@@ -113,7 +113,7 @@ class ExpectedInfo(
             return ExpectedInfo(ByTypeFilter.None, null, null/*TODO?*/, ItemOptions.DEFAULT, argumentData)
         }
 
-        fun createForReturnValue(type: JetType?, callable: CallableDescriptor): ExpectedInfo {
+        fun createForReturnValue(type: KtType?, callable: CallableDescriptor): ExpectedInfo {
             val filter = if (type != null) ByExpectedTypeFilter(FuzzyType(type, emptyList())) else ByTypeFilter.All
             return ExpectedInfo(filter, callable.name.asString(), null, additionalData = ReturnValueAdditionalData(callable))
         }
@@ -147,7 +147,7 @@ class ExpectedInfos(
         val useHeuristicSignatures: Boolean = true,
         val useOuterCallsExpectedTypeCount: Int = 0
 ) {
-    public fun calculate(expressionWithType: JetExpression): Collection<ExpectedInfo> {
+    public fun calculate(expressionWithType: KtExpression): Collection<ExpectedInfo> {
         val expectedInfos = calculateForArgument(expressionWithType)
                             ?: calculateForFunctionLiteralArgument(expressionWithType)
                             ?: calculateForIndexingArgument(expressionWithType)
@@ -167,31 +167,31 @@ class ExpectedInfos(
         return expectedInfos.filterNot { it.fuzzyType?.type?.isError ?: false }
     }
 
-    private fun calculateForArgument(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
-        val argument = expressionWithType.getParent() as? JetValueArgument ?: return null
-        val argumentList = argument.getParent() as? JetValueArgumentList ?: return null
-        val callElement = argumentList.getParent() as? JetCallElement ?: return null
+    private fun calculateForArgument(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
+        val argument = expressionWithType.getParent() as? KtValueArgument ?: return null
+        val argumentList = argument.getParent() as? KtValueArgumentList ?: return null
+        val callElement = argumentList.getParent() as? KtCallElement ?: return null
         return calculateForArgument(callElement, argument)
     }
 
-    private fun calculateForFunctionLiteralArgument(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
-        val functionLiteralArgument = expressionWithType.getParent() as? JetFunctionLiteralArgument
-        val callExpression = functionLiteralArgument?.getParent() as? JetCallExpression ?: return null
+    private fun calculateForFunctionLiteralArgument(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
+        val functionLiteralArgument = expressionWithType.getParent() as? KtFunctionLiteralArgument
+        val callExpression = functionLiteralArgument?.getParent() as? KtCallExpression ?: return null
         val literalArgument = callExpression.getFunctionLiteralArguments().firstOrNull() ?: return null
         if (literalArgument.getArgumentExpression() != expressionWithType) return null
         return calculateForArgument(callExpression, literalArgument)
     }
 
-    private fun calculateForIndexingArgument(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
-        val containerNode = expressionWithType.parent as? JetContainerNode ?: return null
-        val arrayAccessExpression = containerNode.parent as? JetArrayAccessExpression ?: return null
+    private fun calculateForIndexingArgument(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
+        val containerNode = expressionWithType.parent as? KtContainerNode ?: return null
+        val arrayAccessExpression = containerNode.parent as? KtArrayAccessExpression ?: return null
         if (containerNode != arrayAccessExpression.indicesNode) return null
         val call = arrayAccessExpression.getCall(bindingContext) ?: return null
         val argument = call.valueArguments.firstOrNull { it.getArgumentExpression() == expressionWithType } ?: return null
         return calculateForArgument(call, argument)
     }
 
-    private fun calculateForArgument(callElement: JetCallElement, argument: ValueArgument): Collection<ExpectedInfo>? {
+    private fun calculateForArgument(callElement: KtCallElement, argument: ValueArgument): Collection<ExpectedInfo>? {
         val call = callElement.getCall(bindingContext) ?: return null
         return calculateForArgument(call, argument)
     }
@@ -207,7 +207,7 @@ class ExpectedInfos(
         }
 
         if (useOuterCallsExpectedTypeCount > 0 && results.any(::makesSenseToUseOuterCallExpectedType)) {
-            val callExpression = (call.callElement as? JetExpression)?.getQualifiedExpressionForSelectorOrThis() ?: return results
+            val callExpression = (call.callElement as? KtExpression)?.getQualifiedExpressionForSelectorOrThis() ?: return results
             val expectedFuzzyTypes = ExpectedInfos(bindingContext, resolutionFacade, useHeuristicSignatures, useOuterCallsExpectedTypeCount - 1)
                     .calculate(callExpression)
                     .map { it.fuzzyType }
@@ -223,7 +223,7 @@ class ExpectedInfos(
         return results
     }
 
-    private fun calculateForArgument(call: Call, callExpectedType: JetType, argument: ValueArgument): Collection<ExpectedInfo> {
+    private fun calculateForArgument(call: Call, callExpectedType: KtType, argument: ValueArgument): Collection<ExpectedInfo> {
         val argumentIndex = call.getValueArguments().indexOf(argument)
         assert(argumentIndex >= 0) {
             "Could not find argument '$argument(${argument.asElement().text})' among arguments of call: $call"
@@ -394,11 +394,11 @@ class ExpectedInfos(
             Tail.COMMA
     }
 
-    private fun calculateForEqAndAssignment(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
-        val binaryExpression = expressionWithType.getParent() as? JetBinaryExpression
+    private fun calculateForEqAndAssignment(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
+        val binaryExpression = expressionWithType.getParent() as? KtBinaryExpression
         if (binaryExpression != null) {
             val operationToken = binaryExpression.getOperationToken()
-            if (operationToken == JetTokens.EQ || operationToken in COMPARISON_TOKENS) {
+            if (operationToken == KtTokens.EQ || operationToken in COMPARISON_TOKENS) {
                 val otherOperand = if (expressionWithType == binaryExpression.getRight()) binaryExpression.getLeft() else binaryExpression.getRight()
                 if (otherOperand != null) {
                     var expectedType = bindingContext.getType(otherOperand) ?: return null
@@ -415,8 +415,8 @@ class ExpectedInfos(
         return null
     }
 
-    private fun calculateForIf(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
-        val ifExpression = (expressionWithType.getParent() as? JetContainerNode)?.getParent() as? JetIfExpression ?: return null
+    private fun calculateForIf(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
+        val ifExpression = (expressionWithType.getParent() as? KtContainerNode)?.getParent() as? KtIfExpression ?: return null
         return when (expressionWithType) {
             ifExpression.getCondition() -> listOf(ExpectedInfo(resolutionFacade.moduleDescriptor.builtIns.booleanType, null, Tail.RPARENTH, additionalData = IfConditionAdditionalData))
 
@@ -436,11 +436,11 @@ class ExpectedInfos(
         }
     }
 
-    private fun calculateForElvis(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
-        val binaryExpression = expressionWithType.getParent() as? JetBinaryExpression
+    private fun calculateForElvis(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
+        val binaryExpression = expressionWithType.getParent() as? KtBinaryExpression
         if (binaryExpression != null) {
             val operationToken = binaryExpression.getOperationToken()
-            if (operationToken == JetTokens.ELVIS && expressionWithType == binaryExpression.getRight()) {
+            if (operationToken == KtTokens.ELVIS && expressionWithType == binaryExpression.getRight()) {
                 val leftExpression = binaryExpression.getLeft() ?: return null
                 val leftType = bindingContext.getType(leftExpression)
                 val leftTypeNotNullable = leftType?.makeNotNullable()
@@ -460,13 +460,13 @@ class ExpectedInfos(
         return null
     }
 
-    private fun calculateForBlockExpression(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
-        val block = expressionWithType.parent as? JetBlockExpression ?: return null
+    private fun calculateForBlockExpression(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
+        val block = expressionWithType.parent as? KtBlockExpression ?: return null
         if (expressionWithType != block.statements.last()) return null
 
-        val functionLiteral = block.parent as? JetFunctionLiteral
+        val functionLiteral = block.parent as? KtFunctionLiteral
         if (functionLiteral != null) {
-            val literalExpression = functionLiteral.parent as JetFunctionLiteralExpression
+            val literalExpression = functionLiteral.parent as KtFunctionLiteralExpression
             return calculate(literalExpression)
                     .map { it.fuzzyType }
                     .filterNotNull()
@@ -481,10 +481,10 @@ class ExpectedInfos(
         }
     }
 
-    private fun calculateForWhenEntryValue(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
-        val condition = expressionWithType.getParent() as? JetWhenConditionWithExpression ?: return null
-        val entry = condition.getParent() as JetWhenEntry
-        val whenExpression = entry.getParent() as JetWhenExpression
+    private fun calculateForWhenEntryValue(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
+        val condition = expressionWithType.getParent() as? KtWhenConditionWithExpression ?: return null
+        val entry = condition.getParent() as KtWhenEntry
+        val whenExpression = entry.getParent() as KtWhenExpression
         val subject = whenExpression.getSubjectExpression()
         if (subject != null) {
             val subjectType = bindingContext.getType(subject) ?: return null
@@ -495,14 +495,14 @@ class ExpectedInfos(
         }
     }
 
-    private fun calculateForExclOperand(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
-        val prefixExpression = expressionWithType.getParent() as? JetPrefixExpression ?: return null
-        if (prefixExpression.getOperationToken() != JetTokens.EXCL) return null
+    private fun calculateForExclOperand(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
+        val prefixExpression = expressionWithType.getParent() as? KtPrefixExpression ?: return null
+        if (prefixExpression.getOperationToken() != KtTokens.EXCL) return null
         return listOf(ExpectedInfo(resolutionFacade.moduleDescriptor.builtIns.booleanType, null, null))
     }
 
-    private fun calculateForInitializer(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
-        val property = expressionWithType.getParent() as? JetProperty ?: return null
+    private fun calculateForInitializer(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
+        val property = expressionWithType.getParent() as? KtProperty ?: return null
         if (expressionWithType != property.getInitializer()) return null
         val propertyDescriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, property] as? VariableDescriptor ?: return null
         val expectedName = propertyDescriptor.name.asString()
@@ -513,15 +513,15 @@ class ExpectedInfos(
         return listOf(expectedInfo)
     }
 
-    private fun calculateForExpressionBody(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
-        val declaration = expressionWithType.getParent() as? JetDeclarationWithBody ?: return null
+    private fun calculateForExpressionBody(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
+        val declaration = expressionWithType.getParent() as? KtDeclarationWithBody ?: return null
         if (expressionWithType != declaration.getBodyExpression() || declaration.hasBlockBody()) return null
         val descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, declaration] as? FunctionDescriptor ?: return null
         return functionReturnValueExpectedInfo(descriptor, expectType = declaration.hasDeclaredReturnType()).singletonOrEmptyList()
     }
 
-    private fun calculateForReturn(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
-        val returnExpression = expressionWithType.getParent() as? JetReturnExpression ?: return null
+    private fun calculateForReturn(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
+        val returnExpression = expressionWithType.getParent() as? KtReturnExpression ?: return null
         val descriptor = returnExpression.getTargetFunctionDescriptor(bindingContext) ?: return null
         return functionReturnValueExpectedInfo(descriptor, expectType = true).singletonOrEmptyList()
     }
@@ -544,9 +544,9 @@ class ExpectedInfos(
         }
     }
 
-    private fun calculateForLoopRange(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
-        val forExpression = (expressionWithType.parent as? JetContainerNode)
-                                    ?.parent as? JetForExpression ?: return null
+    private fun calculateForLoopRange(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
+        val forExpression = (expressionWithType.parent as? KtContainerNode)
+                                    ?.parent as? KtForExpression ?: return null
         if (expressionWithType != forExpression.loopRange) return null
 
         val loopVar = forExpression.loopParameter
@@ -566,10 +566,10 @@ class ExpectedInfos(
         return listOf(ExpectedInfo(byTypeFilter, null, Tail.RPARENTH))
     }
 
-    private fun calculateForInOperatorArgument(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
-        val binaryExpression = expressionWithType.parent as? JetBinaryExpression ?: return null
+    private fun calculateForInOperatorArgument(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
+        val binaryExpression = expressionWithType.parent as? KtBinaryExpression ?: return null
         val operationToken = binaryExpression.operationToken
-        if (operationToken != JetTokens.IN_KEYWORD && operationToken != JetTokens.NOT_IN || expressionWithType != binaryExpression.right) return null
+        if (operationToken != KtTokens.IN_KEYWORD && operationToken != KtTokens.NOT_IN || expressionWithType != binaryExpression.right) return null
 
         val leftOperandType = binaryExpression.left?.let { bindingContext.getType(it) } ?: return null
         val scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, expressionWithType)!!
@@ -583,17 +583,17 @@ class ExpectedInfos(
         return listOf(ExpectedInfo(byTypeFilter, null, null))
     }
 
-    private fun getFromBindingContext(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
+    private fun getFromBindingContext(expressionWithType: KtExpression): Collection<ExpectedInfo>? {
         val expectedType = bindingContext[BindingContext.EXPECTED_EXPRESSION_TYPE, expressionWithType] ?: return null
         return listOf(ExpectedInfo(expectedType, null, null))
     }
 
-    private fun expectedNameFromExpression(expression: JetExpression?): String? {
+    private fun expectedNameFromExpression(expression: KtExpression?): String? {
         return when (expression) {
-            is JetSimpleNameExpression -> expression.getReferencedName()
-            is JetQualifiedExpression -> expectedNameFromExpression(expression.getSelectorExpression())
-            is JetCallExpression -> expectedNameFromExpression(expression.getCalleeExpression())
-            is JetArrayAccessExpression -> expectedNameFromExpression(expression.getArrayExpression())?.unpluralize()
+            is KtSimpleNameExpression -> expression.getReferencedName()
+            is KtQualifiedExpression -> expectedNameFromExpression(expression.getSelectorExpression())
+            is KtCallExpression -> expectedNameFromExpression(expression.getCalleeExpression())
+            is KtArrayAccessExpression -> expectedNameFromExpression(expression.getArrayExpression())?.unpluralize()
             else -> null
         }
     }
@@ -604,5 +604,5 @@ class ExpectedInfos(
     private fun Collection<ExpectedInfo>.copyWithNoAdditionalData() = map { it.copy(additionalData = null, itemOptions = ItemOptions.DEFAULT) }
 }
 
-val COMPARISON_TOKENS = setOf(JetTokens.EQEQ, JetTokens.EXCLEQ, JetTokens.EQEQEQ, JetTokens.EXCLEQEQEQ)
+val COMPARISON_TOKENS = setOf(KtTokens.EQEQ, KtTokens.EXCLEQ, KtTokens.EQEQEQ, KtTokens.EXCLEQEQEQ)
 
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/HeuristicSignatures.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/HeuristicSignatures.kt
index 749cb9273bc..6605c5e8273 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/HeuristicSignatures.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/HeuristicSignatures.kt
@@ -24,14 +24,14 @@ import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.descriptors.impl.SubpackagesScope
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.TypeResolver
 import org.jetbrains.kotlin.resolve.scopes.LexicalScopeImpl
 import org.jetbrains.kotlin.resolve.scopes.utils.memberScopeAsFileScope
 import org.jetbrains.kotlin.types.IndexedParametersSubstitution
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.SubstitutionUtils
 import org.jetbrains.kotlin.types.Variance
 import java.util.*
@@ -41,13 +41,13 @@ public class HeuristicSignatures(
         private val project: Project,
         private val typeResolver: TypeResolver
 ) {
-    public fun correctedParameterType(function: FunctionDescriptor, parameter: ValueParameterDescriptor): JetType? {
+    public fun correctedParameterType(function: FunctionDescriptor, parameter: ValueParameterDescriptor): KtType? {
         val parameterIndex = function.getValueParameters().indexOf(parameter)
         assert(parameterIndex >= 0)
         return correctedParameterType(function, parameterIndex)
     }
 
-    private fun correctedParameterType(function: FunctionDescriptor, parameterIndex: Int): JetType? {
+    private fun correctedParameterType(function: FunctionDescriptor, parameterIndex: Int): KtType? {
         val ownerType = function.getDispatchReceiverParameter()?.getType() ?: return null
 
         val superFunctions = function.getOverriddenDescriptors()
@@ -74,8 +74,8 @@ public class HeuristicSignatures(
         }
     }
 
-    private fun typeFromText(text: String, typeParameters: Collection<TypeParameterDescriptor>): JetType {
-        val typeRef = JetPsiFactory(project).createType(text)
+    private fun typeFromText(text: String, typeParameters: Collection<TypeParameterDescriptor>): KtType {
+        val typeRef = KtPsiFactory(project).createType(text)
         val rootPackagesScope = SubpackagesScope(moduleDescriptor, FqName.ROOT).memberScopeAsFileScope()
         val scope = LexicalScopeImpl(rootPackagesScope, moduleDescriptor, false, null, "Root packages + type parameters") {
                         typeParameters.forEach { addClassifierDescriptor(it) }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/InsertHandlerProvider.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/InsertHandlerProvider.kt
index e5129972b35..79f7cb6846b 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/InsertHandlerProvider.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/InsertHandlerProvider.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.completion.handlers.*
 import org.jetbrains.kotlin.idea.util.CallType
 import org.jetbrains.kotlin.idea.util.fuzzyReturnType
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.util.*
 
 class InsertHandlerProvider(
@@ -85,7 +85,7 @@ class InsertHandlerProvider(
 
         val potentiallyInferred = HashSet<TypeParameterDescriptor>()
 
-        fun addPotentiallyInferred(type: JetType) {
+        fun addPotentiallyInferred(type: KtType) {
             val descriptor = type.constructor.declarationDescriptor as? TypeParameterDescriptor
             if (descriptor != null && descriptor in typeParameters) {
                 potentiallyInferred.add(descriptor)
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt
index 59847c2fa78..7baaf27f9ad 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt
@@ -32,9 +32,9 @@ import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget.*
 import org.jetbrains.kotlin.idea.completion.handlers.KotlinFunctionInsertHandler
 import org.jetbrains.kotlin.idea.completion.handlers.KotlinKeywordInsertHandler
-import org.jetbrains.kotlin.lexer.JetKeywordToken
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens.*
+import org.jetbrains.kotlin.lexer.KtKeywordToken
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.*
 import org.jetbrains.kotlin.resolve.ModifierCheckerCore
@@ -46,14 +46,14 @@ object KeywordCompletion {
                                             TYPE_ALIAS_KEYWORD)
     private val ALL_KEYWORDS = (KEYWORDS.getTypes() + SOFT_KEYWORDS.getTypes())
             .filter { it !in NON_ACTUAL_KEYWORDS }
-            .map { it as JetKeywordToken }
+            .map { it as KtKeywordToken }
 
     private val DEFAULT_DUMMY_POSTFIX = " X"
     private val KEYWORD_TO_DUMMY_POSTFIX = mapOf(FILE_KEYWORD to ":")
 
     private val KEYWORDS_TO_IGNORE_PREFIX = TokenSet.create(OVERRIDE_KEYWORD /* it's needed to complete overrides that should be work by member name too */)
 
-    private val COMPOUND_KEYWORDS = mapOf<JetKeywordToken, JetKeywordToken>(
+    private val COMPOUND_KEYWORDS = mapOf<KtKeywordToken, KtKeywordToken>(
             COMPANION_KEYWORD to OBJECT_KEYWORD,
             ENUM_KEYWORD to CLASS_KEYWORD,
             ANNOTATION_KEYWORD to CLASS_KEYWORD
@@ -100,15 +100,15 @@ object KeywordCompletion {
 
     private val GENERAL_FILTER = NotFilter(OrFilter(
             CommentFilter(),
-            ParentFilter(ClassFilter(javaClass<JetLiteralStringTemplateEntry>())),
-            ParentFilter(ClassFilter(javaClass<JetConstantExpression>())),
+            ParentFilter(ClassFilter(javaClass<KtLiteralStringTemplateEntry>())),
+            ParentFilter(ClassFilter(javaClass<KtConstantExpression>())),
             LeftNeighbour(TextFilter(".")),
             LeftNeighbour(TextFilter("?."))
     ))
 
     private class CommentFilter() : ElementFilter {
         override fun isAcceptable(element : Any?, context : PsiElement?)
-                = (element is PsiElement) && JetPsiUtil.isInComment(element)
+                = (element is PsiElement) && KtPsiUtil.isInComment(element)
 
         override fun isClassAcceptable(hintClass: Class<out Any?>)
                 = true
@@ -125,23 +125,23 @@ object KeywordCompletion {
         }
     }
 
-    private fun buildFilter(position: PsiElement): (JetKeywordToken) -> Boolean {
+    private fun buildFilter(position: PsiElement): (KtKeywordToken) -> Boolean {
         var parent = position.getParent()
         var prevParent = position
         while (parent != null) {
             when (parent) {
-                is JetBlockExpression -> {
+                is KtBlockExpression -> {
                     return buildFilterWithContext("fun foo() { ", prevParent, position)
                 }
 
-                is JetWithExpressionInitializer -> {
+                is KtWithExpressionInitializer -> {
                     val initializer = parent.getInitializer()
                     if (prevParent == initializer) {
                         return buildFilterWithContext("val v = ", initializer!!, position)
                     }
                 }
 
-                is JetParameter -> {
+                is KtParameter -> {
                     val default = parent.getDefaultValue()
                     if (prevParent == default) {
                         return buildFilterWithContext("val v = ", default!!, position)
@@ -149,11 +149,11 @@ object KeywordCompletion {
                 }
             }
 
-            if (parent is JetDeclaration) {
+            if (parent is KtDeclaration) {
                 val scope = parent.parent
                 when (scope) {
-                    is JetClassOrObject -> {
-                        if (parent is JetPrimaryConstructor) {
+                    is KtClassOrObject -> {
+                        if (parent is KtPrimaryConstructor) {
                             return buildFilterWithReducedContext("class X ", parent, position)
                         }
                         else {
@@ -161,7 +161,7 @@ object KeywordCompletion {
                         }
                     }
 
-                    is JetFile -> return buildFilterWithReducedContext("", parent, position)
+                    is KtFile -> return buildFilterWithReducedContext("", parent, position)
                 }
             }
 
@@ -174,7 +174,7 @@ object KeywordCompletion {
 
     private fun buildFilterWithContext(prefixText: String,
                                        contextElement: PsiElement,
-                                       position: PsiElement): (JetKeywordToken) -> Boolean {
+                                       position: PsiElement): (KtKeywordToken) -> Boolean {
         val offset = position.getStartOffsetInAncestor(contextElement)
         val truncatedContext = contextElement.getText()!!.substring(0, offset)
         return buildFilterByText(prefixText + truncatedContext, contextElement.getProject())
@@ -182,15 +182,15 @@ object KeywordCompletion {
 
     private fun buildFilterWithReducedContext(prefixText: String,
                                               contextElement: PsiElement?,
-                                              position: PsiElement): (JetKeywordToken) -> Boolean {
+                                              position: PsiElement): (KtKeywordToken) -> Boolean {
         val builder = StringBuilder()
         buildReducedContextBefore(builder, position, contextElement)
         return buildFilterByText(prefixText + builder.toString(), position.getProject())
     }
 
 
-    private fun buildFilterByText(prefixText: String, project: Project): (JetKeywordToken) -> Boolean {
-        val psiFactory = JetPsiFactory(project)
+    private fun buildFilterByText(prefixText: String, project: Project): (KtKeywordToken) -> Boolean {
+        val psiFactory = KtPsiFactory(project)
         return fun (keywordTokenType): Boolean {
             val postfix = KEYWORD_TO_DUMMY_POSTFIX[keywordTokenType] ?: DEFAULT_DUMMY_POSTFIX
             val file = psiFactory.createFile(prefixText + keywordTokenType.getValue() + postfix)
@@ -203,37 +203,37 @@ object KeywordCompletion {
 
                 elementAt.prevLeaf { it !is PsiWhiteSpace && it !is PsiComment }?.parentsWithSelf?.any { it is PsiErrorElement } ?: false -> return false
 
-                keywordTokenType !is JetModifierKeywordToken -> return true
+                keywordTokenType !is KtModifierKeywordToken -> return true
 
                 else -> {
-                    if (elementAt.parent !is JetModifierList) return true
+                    if (elementAt.parent !is KtModifierList) return true
                     val container = elementAt.parent.parent
                     val possibleTargets = when (container) {
-                        is JetParameter -> {
-                            if (container.ownerFunction is JetPrimaryConstructor)
+                        is KtParameter -> {
+                            if (container.ownerFunction is KtPrimaryConstructor)
                                 listOf(VALUE_PARAMETER, MEMBER_PROPERTY)
                             else
                                 listOf(VALUE_PARAMETER)
                         }
 
-                        is JetTypeParameter -> listOf(TYPE_PARAMETER)
+                        is KtTypeParameter -> listOf(TYPE_PARAMETER)
 
-                        is JetEnumEntry -> listOf(ENUM_ENTRY)
+                        is KtEnumEntry -> listOf(ENUM_ENTRY)
 
-                        is JetClassBody -> listOf(CLASS_ONLY, INTERFACE, OBJECT, ENUM_CLASS, ANNOTATION_CLASS, INNER_CLASS, MEMBER_FUNCTION, MEMBER_PROPERTY, FUNCTION, PROPERTY)
+                        is KtClassBody -> listOf(CLASS_ONLY, INTERFACE, OBJECT, ENUM_CLASS, ANNOTATION_CLASS, INNER_CLASS, MEMBER_FUNCTION, MEMBER_PROPERTY, FUNCTION, PROPERTY)
 
-                        is JetFile -> listOf(CLASS_ONLY, INTERFACE, OBJECT, ENUM_CLASS, ANNOTATION_CLASS, TOP_LEVEL_FUNCTION, TOP_LEVEL_PROPERTY, FUNCTION, PROPERTY)
+                        is KtFile -> listOf(CLASS_ONLY, INTERFACE, OBJECT, ENUM_CLASS, ANNOTATION_CLASS, TOP_LEVEL_FUNCTION, TOP_LEVEL_PROPERTY, FUNCTION, PROPERTY)
 
                         else -> null
                     }
                     val modifierTargets = ModifierCheckerCore.possibleTargetMap[keywordTokenType]
                     if (modifierTargets != null && possibleTargets != null && possibleTargets.none { it in modifierTargets }) return false
 
-                    val ownerDeclaration = container?.getParentOfType<JetDeclaration>(strict = true)
+                    val ownerDeclaration = container?.getParentOfType<KtDeclaration>(strict = true)
                     val parentTarget = when (ownerDeclaration) {
                         null -> KotlinTarget.FILE
 
-                        is JetClass -> {
+                        is KtClass -> {
                             when {
                                 ownerDeclaration.isInterface() -> KotlinTarget.INTERFACE
                                 ownerDeclaration.isEnum() -> KotlinTarget.ENUM_CLASS
@@ -243,7 +243,7 @@ object KeywordCompletion {
                             }
                         }
 
-                        is JetObjectDeclaration -> if (ownerDeclaration.isObjectLiteral()) KotlinTarget.OBJECT_LITERAL else KotlinTarget.OBJECT
+                        is KtObjectDeclaration -> if (ownerDeclaration.isObjectLiteral()) KotlinTarget.OBJECT_LITERAL else KotlinTarget.OBJECT
 
                         else -> return true
                     }
@@ -260,7 +260,7 @@ object KeywordCompletion {
         }
     }
 
-    private fun IElementType.matchesKeyword(keywordType: JetKeywordToken): Boolean {
+    private fun IElementType.matchesKeyword(keywordType: KtKeywordToken): Boolean {
         return when(this) {
             keywordType -> true
             NOT_IN -> keywordType == IN_KEYWORD
@@ -276,11 +276,11 @@ object KeywordCompletion {
 
         buildReducedContextBefore(builder, parent, scope)
 
-        val prevDeclaration = position.siblings(forward = false, withItself = false).firstOrNull { it is JetDeclaration }
+        val prevDeclaration = position.siblings(forward = false, withItself = false).firstOrNull { it is KtDeclaration }
 
         var child = parent.getFirstChild()
         while (child != position) {
-            if (child is JetDeclaration) {
+            if (child is KtDeclaration) {
                 if (child == prevDeclaration) {
                     builder.appendReducedText(child)
                 }
@@ -301,7 +301,7 @@ object KeywordCompletion {
         else {
             while (child != null) {
                 when (child) {
-                    is JetBlockExpression, is JetClassBody -> append("{}")
+                    is KtBlockExpression, is KtClassBody -> append("{}")
                     else -> appendReducedText(child)
                 }
 
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordValues.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordValues.kt
index eb9bd1e91f6..bb38e3623dc 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordValues.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordValues.kt
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.idea.util.CallTypeAndReceiver
 import org.jetbrains.kotlin.idea.util.FuzzyType
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.types.JetTypeImpl
+import org.jetbrains.kotlin.types.KtTypeImpl
 import org.jetbrains.kotlin.types.TypeProjectionImpl
 import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.types.typeUtil.isBooleanOrNullableBoolean
@@ -92,7 +92,7 @@ object KeywordValues {
             val qualifierType = bindingContext[BindingContext.TYPE, callTypeAndReceiver.receiver]
             if (qualifierType != null) {
                 val kClassDescriptor = resolutionFacade.getFrontendService(ReflectionTypes::class.java).kClass
-                val classLiteralType = JetTypeImpl.create(Annotations.EMPTY, kClassDescriptor, false, listOf(TypeProjectionImpl(qualifierType)))
+                val classLiteralType = KtTypeImpl.create(Annotations.EMPTY, kClassDescriptor, false, listOf(TypeProjectionImpl(qualifierType)))
                 val kClassTypes = listOf(FuzzyType(classLiteralType, emptyList()))
                 val kClassMatcher = { info: ExpectedInfo -> kClassTypes.matchExpectedInfo(info) }
                 consumer.consume("class", kClassMatcher, SmartCompletionItemPriority.CLASS_LITERAL) {
@@ -104,7 +104,7 @@ object KeywordValues {
                             .singleOrNull() as? ClassDescriptor
 
                     if (javaLangClassDescriptor != null) {
-                        val javaLangClassType = JetTypeImpl.create(Annotations.EMPTY, javaLangClassDescriptor, false, listOf(TypeProjectionImpl(qualifierType)))
+                        val javaLangClassType = KtTypeImpl.create(Annotations.EMPTY, javaLangClassDescriptor, false, listOf(TypeProjectionImpl(qualifierType)))
                         val javaClassTypes = listOf(FuzzyType(javaLangClassType, emptyList()))
                         val javaClassMatcher = { info: ExpectedInfo -> javaClassTypes.matchExpectedInfo(info) }
                         consumer.consume("class", javaClassMatcher, SmartCompletionItemPriority.CLASS_LITERAL) {
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionCharFilter.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionCharFilter.kt
index 6ada567cfc5..a3489776126 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionCharFilter.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionCharFilter.kt
@@ -25,9 +25,9 @@ import com.intellij.openapi.util.Key
 import com.intellij.psi.PsiComment
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiWhiteSpace
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetFunctionLiteral
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtFunctionLiteral
 import org.jetbrains.kotlin.psi.psiUtil.prevLeaf
 
 public class KotlinCompletionCharFilter() : CharFilter() {
@@ -41,7 +41,7 @@ public class KotlinCompletionCharFilter() : CharFilter() {
     }
 
     override fun acceptChar(c : Char, prefixLength : Int, lookup : Lookup) : Result? {
-        if (lookup.getPsiFile() !is JetFile) return null
+        if (lookup.getPsiFile() !is KtFile) return null
         if (!lookup.isCompletion()) return null
         // it does not work in tests, so we use other way
 //        val isAutopopup = CompletionService.getCompletionService().getCurrentCompletion().isAutopopupCompletion()
@@ -97,11 +97,11 @@ public class KotlinCompletionCharFilter() : CharFilter() {
 
     private fun isInFunctionLiteralStart(position: PsiElement): Boolean {
         var prev = position.prevLeaf { it !is PsiWhiteSpace && it !is PsiComment }
-        if (prev?.getNode()?.getElementType() == JetTokens.LPAR) {
+        if (prev?.getNode()?.getElementType() == KtTokens.LPAR) {
             prev = prev?.prevLeaf { it !is PsiWhiteSpace && it !is PsiComment }
         }
-        if (prev?.getNode()?.getElementType() != JetTokens.LBRACE) return false
-        val functionLiteral = prev!!.getParent() as? JetFunctionLiteral ?: return false
+        if (prev?.getNode()?.getElementType() != KtTokens.LBRACE) return false
+        val functionLiteral = prev!!.getParent() as? KtFunctionLiteral ?: return false
         return functionLiteral.getLBrace() == prev
     }
 }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionContributor.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionContributor.kt
index 2e8be4986f6..06b7146b44c 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionContributor.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionContributor.kt
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.caches.resolve.performCompletionWithOutOfBlockTracking
 import org.jetbrains.kotlin.idea.completion.smart.SmartCompletion
 import org.jetbrains.kotlin.idea.completion.smart.SmartCompletionSession
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.*
 import org.jetbrains.kotlin.resolve.bindingContextUtil.getReferenceTargets
@@ -43,11 +43,11 @@ import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.utils.addToStdlib.check
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 
-public var JetFile.doNotComplete: Boolean? by UserDataProperty(Key.create("DO_NOT_COMPLETE"))
+public var KtFile.doNotComplete: Boolean? by UserDataProperty(Key.create("DO_NOT_COMPLETE"))
 
 public class KotlinCompletionContributor : CompletionContributor() {
-    private val AFTER_NUMBER_LITERAL = psiElement().afterLeafSkipping(psiElement().withText(""), psiElement().withElementType(elementType().oneOf(JetTokens.FLOAT_LITERAL, JetTokens.INTEGER_LITERAL)))
-    private val AFTER_INTEGER_LITERAL_AND_DOT = psiElement().afterLeafSkipping(psiElement().withText("."), psiElement().withElementType(elementType().oneOf(JetTokens.INTEGER_LITERAL)))
+    private val AFTER_NUMBER_LITERAL = psiElement().afterLeafSkipping(psiElement().withText(""), psiElement().withElementType(elementType().oneOf(KtTokens.FLOAT_LITERAL, KtTokens.INTEGER_LITERAL)))
+    private val AFTER_INTEGER_LITERAL_AND_DOT = psiElement().afterLeafSkipping(psiElement().withText("."), psiElement().withElementType(elementType().oneOf(KtTokens.INTEGER_LITERAL)))
 
     companion object {
         public val DEFAULT_DUMMY_IDENTIFIER: String = CompletionUtilCore.DUMMY_IDENTIFIER_TRIMMED + "$" // add '$' to ignore context after the caret
@@ -65,7 +65,7 @@ public class KotlinCompletionContributor : CompletionContributor() {
 
     override fun beforeCompletion(context: CompletionInitializationContext) {
         val psiFile = context.getFile()
-        if (psiFile !is JetFile) return
+        if (psiFile !is KtFile) return
 
         val offset = context.getStartOffset()
         val tokenBefore = psiFile.findElementAt(Math.max(0, offset - 1))
@@ -96,11 +96,11 @@ public class KotlinCompletionContributor : CompletionContributor() {
             val tokenAt = psiFile.findElementAt(Math.max(0, offset))
             if (tokenAt != null) {
                 var parent = tokenAt.getParent()
-                if (parent is JetExpression && parent !is JetBlockExpression) {
+                if (parent is KtExpression && parent !is KtBlockExpression) {
                     // search expression to be replaced - go up while we are the first child of parent expression
-                    var expression: JetExpression = parent
+                    var expression: KtExpression = parent
                     parent = expression.getParent()
-                    while (parent is JetExpression && parent.getFirstChild() == expression) {
+                    while (parent is KtExpression && parent.getFirstChild() == expression) {
                         expression = parent
                         parent = expression.getParent()
                     }
@@ -112,7 +112,7 @@ public class KotlinCompletionContributor : CompletionContributor() {
 
                     context.getOffsetMap().addOffset(SmartCompletion.OLD_ARGUMENTS_REPLACEMENT_OFFSET, expression.endOffset)
 
-                    val argumentList = (expression.getParent() as? JetValueArgument)?.getParent() as? JetValueArgumentList
+                    val argumentList = (expression.getParent() as? KtValueArgument)?.getParent() as? KtValueArgumentList
                     if (argumentList != null) {
                         context.getOffsetMap().addOffset(SmartCompletion.MULTIPLE_ARGUMENTS_REPLACEMENT_OFFSET,
                                                          argumentList.getRightParenthesis()?.getTextRange()?.getStartOffset() ?: argumentList.endOffset)
@@ -122,16 +122,16 @@ public class KotlinCompletionContributor : CompletionContributor() {
         }
     }
 
-    private fun replacementOffsetByExpression(expression: JetExpression): Int {
+    private fun replacementOffsetByExpression(expression: KtExpression): Int {
         when (expression) {
-            is JetCallExpression -> {
+            is KtCallExpression -> {
                 val calleeExpression = expression.getCalleeExpression()
                 if (calleeExpression != null) {
                     return calleeExpression.getTextRange()!!.getEndOffset()
                 }
             }
 
-            is JetQualifiedExpression -> {
+            is KtQualifiedExpression -> {
                 val selector = expression.getSelectorExpression()
                 if (selector != null) {
                     return replacementOffsetByExpression(selector)
@@ -142,7 +142,7 @@ public class KotlinCompletionContributor : CompletionContributor() {
     }
 
     private fun isInClassHeader(tokenBefore: PsiElement?): Boolean {
-        val classOrObject = tokenBefore?.parents?.firstIsInstanceOrNull<JetClassOrObject>() ?: return false
+        val classOrObject = tokenBefore?.parents?.firstIsInstanceOrNull<KtClassOrObject>() ?: return false
         val name = classOrObject.getNameIdentifier() ?: return false
         val body = classOrObject.getBody() ?: return false
         val offset = tokenBefore!!.startOffset
@@ -155,12 +155,12 @@ public class KotlinCompletionContributor : CompletionContributor() {
             leaf = leaf.prevLeaf(true)
         }
 
-        val lambda = leaf?.parents?.firstOrNull { it is JetFunctionLiteral } ?: return null
+        val lambda = leaf?.parents?.firstOrNull { it is KtFunctionLiteral } ?: return null
 
         val lambdaChild = leaf!!.parents.takeWhile { it != lambda }.lastOrNull() ?: return null
-        if (lambdaChild is JetParameterList) return CompletionUtilCore.DUMMY_IDENTIFIER_TRIMMED
+        if (lambdaChild is KtParameterList) return CompletionUtilCore.DUMMY_IDENTIFIER_TRIMMED
 
-        if (lambdaChild !is JetBlockExpression) return null
+        if (lambdaChild !is KtBlockExpression) return null
         val blockChild = leaf.parents.takeWhile { it != lambdaChild }.lastOrNull()
         if (blockChild !is PsiErrorElement) return null
         val inIncompleteSignature = blockChild.siblings(forward = false, withItself = false).all {
@@ -173,13 +173,13 @@ public class KotlinCompletionContributor : CompletionContributor() {
 
     }
 
-    private val declarationKeywords = TokenSet.create(JetTokens.FUN_KEYWORD, JetTokens.VAL_KEYWORD, JetTokens.VAR_KEYWORD)
-    private val declarationTokens = TokenSet.orSet(TokenSet.create(JetTokens.IDENTIFIER, JetTokens.LT, JetTokens.GT,
-                                                                   JetTokens.COMMA, JetTokens.DOT, JetTokens.QUEST, JetTokens.COLON,
-                                                                   JetTokens.IN_KEYWORD, JetTokens.OUT_KEYWORD,
-                                                                   JetTokens.LPAR, JetTokens.RPAR, JetTokens.ARROW,
+    private val declarationKeywords = TokenSet.create(KtTokens.FUN_KEYWORD, KtTokens.VAL_KEYWORD, KtTokens.VAR_KEYWORD)
+    private val declarationTokens = TokenSet.orSet(TokenSet.create(KtTokens.IDENTIFIER, KtTokens.LT, KtTokens.GT,
+                                                                   KtTokens.COMMA, KtTokens.DOT, KtTokens.QUEST, KtTokens.COLON,
+                                                                   KtTokens.IN_KEYWORD, KtTokens.OUT_KEYWORD,
+                                                                   KtTokens.LPAR, KtTokens.RPAR, KtTokens.ARROW,
                                                                    TokenType.ERROR_ELEMENT),
-                                                   JetTokens.WHITE_SPACE_OR_COMMENT_BIT_SET)
+                                                   KtTokens.WHITE_SPACE_OR_COMMENT_BIT_SET)
 
     private fun specialExtensionReceiverDummyIdentifier(tokenBefore: PsiElement?): String? {
         var token = tokenBefore ?: return null
@@ -195,21 +195,21 @@ public class KotlinCompletionContributor : CompletionContributor() {
                 builder.reverse()
 
                 var tail = "X" + ">".repeat(balance) + ".f"
-                if (tokenType == JetTokens.FUN_KEYWORD) {
+                if (tokenType == KtTokens.FUN_KEYWORD) {
                     tail += "()"
                 }
                 builder append tail
 
                 val text = builder.toString()
-                val file = JetPsiFactory(tokenBefore.getProject()).createFile(text)
+                val file = KtPsiFactory(tokenBefore.getProject()).createFile(text)
                 val declaration = file.getDeclarations().singleOrNull() ?: return null
                 if (declaration.getTextLength() != text.length()) return null
                 val containsErrorElement = !PsiTreeUtil.processElements(file, PsiElementProcessor<PsiElement>{ it !is PsiErrorElement })
                 return if (containsErrorElement) null else tail + "$"
             }
             if (tokenType !in declarationTokens) return null
-            if (tokenType == JetTokens.LT) ltCount++
-            if (tokenType == JetTokens.GT) gtCount++
+            if (tokenType == KtTokens.LT) ltCount++
+            if (tokenType == KtTokens.GT) gtCount++
             builder.append(token.getText()!!.reversed())
             token = PsiTreeUtil.prevLeaf(token) ?: return null
         }
@@ -218,8 +218,8 @@ public class KotlinCompletionContributor : CompletionContributor() {
     private fun performCompletion(parameters: CompletionParameters, result: CompletionResultSet) {
         val position = parameters.getPosition()
         val positionFile = position.containingFile
-        if (positionFile !is JetFile) return
-        if ((positionFile.originalFile as JetFile).doNotComplete ?: false) return
+        if (positionFile !is KtFile) return
+        if ((positionFile.originalFile as KtFile).doNotComplete ?: false) return
 
         performCompletionWithOutOfBlockTracking(position) {
             doComplete(parameters, position, result)
@@ -291,7 +291,7 @@ public class KotlinCompletionContributor : CompletionContributor() {
             val callable = isInExtensionReceiverOf(position)
             if (callable != null) {
                 return when (callable) {
-                    is JetNamedFunction -> prefixMatcher.prefix.let { it.isEmpty() || it[0].isLowerCase() /* function name usually starts with lower case letter */ }
+                    is KtNamedFunction -> prefixMatcher.prefix.let { it.isEmpty() || it[0].isLowerCase() /* function name usually starts with lower case letter */ }
                     else -> true
                 }
             }
@@ -300,15 +300,15 @@ public class KotlinCompletionContributor : CompletionContributor() {
         return false
     }
 
-    private fun isInExtensionReceiverOf(position: PsiElement): JetCallableDeclaration? {
-        val nameRef = position.getParent() as? JetNameReferenceExpression ?: return null
-        val userType = nameRef.getParent() as? JetUserType ?: return null
-        val typeRef = userType.getParent() as? JetTypeReference ?: return null
+    private fun isInExtensionReceiverOf(position: PsiElement): KtCallableDeclaration? {
+        val nameRef = position.getParent() as? KtNameReferenceExpression ?: return null
+        val userType = nameRef.getParent() as? KtUserType ?: return null
+        val typeRef = userType.getParent() as? KtTypeReference ?: return null
         if (userType != typeRef.typeElement) return null
         val parent = typeRef.getParent()
         return when (parent) {
-            is JetNamedFunction -> parent.check { typeRef == it.receiverTypeReference }
-            is JetProperty -> parent.check { typeRef == it.receiverTypeReference }
+            is KtNamedFunction -> parent.check { typeRef == it.receiverTypeReference }
+            is KtProperty -> parent.check { typeRef == it.receiverTypeReference }
             else -> null
         }
     }
@@ -328,7 +328,7 @@ public class KotlinCompletionContributor : CompletionContributor() {
     private fun specialInTypeArgsDummyIdentifier(tokenBefore: PsiElement?): String? {
         if (tokenBefore == null) return null
 
-        if (tokenBefore.getParentOfType<JetTypeArgumentList>(true) != null) { // already parsed inside type argument list
+        if (tokenBefore.getParentOfType<KtTypeArgumentList>(true) != null) { // already parsed inside type argument list
             return CompletionUtilCore.DUMMY_IDENTIFIER_TRIMMED // do not insert '$' to not break type argument list parsing
         }
 
@@ -336,7 +336,7 @@ public class KotlinCompletionContributor : CompletionContributor() {
         val (nameToken, balance) = pair
         assert(balance > 0)
 
-        val nameRef = nameToken.getParent() as? JetNameReferenceExpression ?: return null
+        val nameRef = nameToken.getParent() as? KtNameReferenceExpression ?: return null
         val bindingContext = nameRef.getResolutionFacade().analyze(nameRef, BodyResolveMode.PARTIAL)
         val targets = nameRef.getReferenceTargets(bindingContext)
         if (targets.isNotEmpty() && targets.all { it is FunctionDescriptor || it is ClassDescriptor && it.getKind() == ClassKind.CLASS }) {
@@ -358,10 +358,10 @@ public class KotlinCompletionContributor : CompletionContributor() {
         }
     }
 
-    private val callTypeArgsTokens = TokenSet.orSet(TokenSet.create(JetTokens.IDENTIFIER, JetTokens.LT, JetTokens.GT,
-                                                                   JetTokens.COMMA, JetTokens.DOT, JetTokens.QUEST, JetTokens.COLON,
-                                                                   JetTokens.LPAR, JetTokens.RPAR, JetTokens.ARROW),
-                                                   JetTokens.WHITE_SPACE_OR_COMMENT_BIT_SET)
+    private val callTypeArgsTokens = TokenSet.orSet(TokenSet.create(KtTokens.IDENTIFIER, KtTokens.LT, KtTokens.GT,
+                                                                   KtTokens.COMMA, KtTokens.DOT, KtTokens.QUEST, KtTokens.COLON,
+                                                                   KtTokens.LPAR, KtTokens.RPAR, KtTokens.ARROW),
+                                                   KtTokens.WHITE_SPACE_OR_COMMENT_BIT_SET)
 
     // if the leaf could be located inside type argument list of a call (if parsed properly)
     // then it returns the call name reference this type argument list would belong to
@@ -371,13 +371,13 @@ public class KotlinCompletionContributor : CompletionContributor() {
             val tokenType = current.getNode()!!.getElementType()
             if (tokenType !in callTypeArgsTokens) return null
 
-            if (tokenType == JetTokens.LT) {
+            if (tokenType == KtTokens.LT) {
                 val nameToken = current.prevLeaf(skipEmptyElements = true) ?: return null
-                if (nameToken.getNode()!!.getElementType() != JetTokens.IDENTIFIER) return null
+                if (nameToken.getNode()!!.getElementType() != KtTokens.IDENTIFIER) return null
                 return nameToken
             }
 
-            if (tokenType == JetTokens.GT) { // pass nested type argument list
+            if (tokenType == KtTokens.GT) { // pass nested type argument list
                 val prev = current.prevLeaf(skipEmptyElements = true) ?: return null
                 val typeRef = findCallNameTokenIfInTypeArgs(prev) ?: return null
                 current = typeRef
@@ -392,8 +392,8 @@ public class KotlinCompletionContributor : CompletionContributor() {
         // If we insert $ in the argument list of a delegation specifier, this will break parsing
         // and the following block will not be attached as a body to the constructor. Therefore
         // we need to use a regular identifier.
-        val argumentList = tokenBefore?.getNonStrictParentOfType<JetValueArgumentList>() ?: return null
-        if (argumentList.getParent() is JetConstructorDelegationCall) return CompletionUtil.DUMMY_IDENTIFIER_TRIMMED
+        val argumentList = tokenBefore?.getNonStrictParentOfType<KtValueArgumentList>() ?: return null
+        if (argumentList.getParent() is KtConstructorDelegationCall) return CompletionUtil.DUMMY_IDENTIFIER_TRIMMED
         return null
     }
 
@@ -403,8 +403,8 @@ public class KotlinCompletionContributor : CompletionContributor() {
         var balance = 0
         while (current != stopAt) {
             when (current!!.getNode().getElementType()) {
-                JetTokens.LPAR -> balance++
-                JetTokens.RPAR -> balance--
+                KtTokens.LPAR -> balance++
+                KtTokens.RPAR -> balance--
             }
             current = current.prevLeaf()
         }
@@ -413,15 +413,15 @@ public class KotlinCompletionContributor : CompletionContributor() {
 
     private fun isInUnclosedSuperQualifier(tokenBefore: PsiElement?): Boolean {
         if (tokenBefore == null) return false
-        val tokensToSkip = TokenSet.orSet(TokenSet.create(JetTokens.IDENTIFIER, JetTokens.DOT ), JetTokens.WHITE_SPACE_OR_COMMENT_BIT_SET)
+        val tokensToSkip = TokenSet.orSet(TokenSet.create(KtTokens.IDENTIFIER, KtTokens.DOT ), KtTokens.WHITE_SPACE_OR_COMMENT_BIT_SET)
         val tokens = sequence(tokenBefore) { it.prevLeaf() }
         val ltToken = tokens.firstOrNull { it.node.elementType !in tokensToSkip } ?: return false
-        if (ltToken.node.elementType != JetTokens.LT) return false
+        if (ltToken.node.elementType != KtTokens.LT) return false
         val superToken = ltToken.prevLeaf { it !is PsiWhiteSpace && it !is PsiComment }
-        return superToken?.node?.elementType == JetTokens.SUPER_KEYWORD
+        return superToken?.node?.elementType == KtTokens.SUPER_KEYWORD
     }
 
     private fun isInSimpleStringTemplate(tokenBefore: PsiElement?): Boolean {
-        return tokenBefore?.parents?.firstIsInstanceOrNull<JetStringTemplateExpression>()?.isPlain() ?: false
+        return tokenBefore?.parents?.firstIsInstanceOrNull<KtStringTemplateExpression>()?.isPlain() ?: false
     }
 }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/LookupElementFactory.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/LookupElementFactory.kt
index 78b853af3a5..48df7bff9a1 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/LookupElementFactory.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/LookupElementFactory.kt
@@ -38,13 +38,13 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.hasDefaultValue
 import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 import org.jetbrains.kotlin.synthetic.SamAdapterExtensionFunctionDescriptor
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
 
 class LookupElementFactory(
         private val resolutionFacade: ResolutionFacade,
-        private val receiverTypes: Collection<JetType>?,
+        private val receiverTypes: Collection<KtType>?,
         private val callType: CallType<*>?,
         private val isInStringTemplateAfterDollar: Boolean,
         public val insertHandlerProvider: InsertHandlerProvider,
@@ -104,7 +104,7 @@ class LookupElementFactory(
         }
     }
 
-    private fun createFunctionCallElementWithLambda(descriptor: FunctionDescriptor, parameterType: JetType, explicitLambdaParameters: Boolean, useReceiverTypes: Boolean): LookupElement {
+    private fun createFunctionCallElementWithLambda(descriptor: FunctionDescriptor, parameterType: KtType, explicitLambdaParameters: Boolean, useReceiverTypes: Boolean): LookupElement {
         var lookupElement = createLookupElement(descriptor, useReceiverTypes)
         val inputTypeArguments = (insertHandlerProvider.insertHandler(descriptor) as KotlinFunctionInsertHandler.Normal).inputTypeArguments
         val lambdaInfo = GenerateLambdaInfo(parameterType, explicitLambdaParameters)
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/NamedArgumentCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/NamedArgumentCompletion.kt
index 755f0e94c17..10acea2c70c 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/NamedArgumentCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/NamedArgumentCompletion.kt
@@ -20,24 +20,24 @@ import com.intellij.codeInsight.completion.InsertHandler
 import com.intellij.codeInsight.completion.InsertionContext
 import com.intellij.codeInsight.lookup.LookupElement
 import com.intellij.codeInsight.lookup.LookupElementBuilder
-import org.jetbrains.kotlin.idea.JetIcons
+import org.jetbrains.kotlin.idea.KtIcons
 import org.jetbrains.kotlin.idea.completion.handlers.WithTailInsertHandler
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetCallElement
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
-import org.jetbrains.kotlin.psi.JetValueArgument
+import org.jetbrains.kotlin.psi.KtCallElement
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtValueArgument
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.render
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.util.*
 
 object NamedArgumentCompletion {
-    public fun isOnlyNamedArgumentExpected(nameExpression: JetSimpleNameExpression): Boolean {
-        val thisArgument = nameExpression.parent as? JetValueArgument ?: return false
+    public fun isOnlyNamedArgumentExpected(nameExpression: KtSimpleNameExpression): Boolean {
+        val thisArgument = nameExpression.parent as? KtValueArgument ?: return false
         if (thisArgument.isNamed()) return false
 
-        val callElement = thisArgument.getStrictParentOfType<JetCallElement>() ?: return false
+        val callElement = thisArgument.getStrictParentOfType<KtCallElement>() ?: return false
 
         return callElement.valueArguments
                 .takeWhile { it != thisArgument }
@@ -45,7 +45,7 @@ object NamedArgumentCompletion {
     }
 
     public fun complete(collector: LookupElementsCollector, expectedInfos: Collection<ExpectedInfo>) {
-        val nameToParameterType = HashMap<Name, MutableSet<JetType>>()
+        val nameToParameterType = HashMap<Name, MutableSet<KtType>>()
         for (expectedInfo in expectedInfos) {
             val argumentData = expectedInfo.additionalData as? ArgumentPositionData.Positional ?: continue
             for (parameter in argumentData.namedArgumentCandidates) {
@@ -59,7 +59,7 @@ object NamedArgumentCompletion {
             val lookupElement = LookupElementBuilder.create(nameString)
                     .withPresentableText("$nameString =")
                     .withTailText(" $typeText")
-                    .withIcon(JetIcons.PARAMETER)
+                    .withIcon(KtIcons.PARAMETER)
                     .withInsertHandler(NamedArgumentInsertHandler(name))
                     .assignPriority(ItemPriority.NAMED_PARAMETER)
             collector.addElement(lookupElement)
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/OverridesCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/OverridesCompletion.kt
index 85a8eaac5bf..a878e18b668 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/OverridesCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/OverridesCompletion.kt
@@ -38,10 +38,10 @@ import org.jetbrains.kotlin.idea.quickfix.moveCaret
 import org.jetbrains.kotlin.idea.quickfix.moveCaretIntoGeneratedElement
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
-import org.jetbrains.kotlin.psi.JetPrimaryConstructor
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
+import org.jetbrains.kotlin.psi.KtPrimaryConstructor
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
@@ -55,9 +55,9 @@ class OverridesCompletion(
     }
 
     fun complete(position: PsiElement) {
-        val isConstructorParameter = position.getNonStrictParentOfType<JetPrimaryConstructor>() != null
+        val isConstructorParameter = position.getNonStrictParentOfType<KtPrimaryConstructor>() != null
 
-        val classOrObject = position.getNonStrictParentOfType<JetClassOrObject>() ?: return
+        val classOrObject = position.getNonStrictParentOfType<KtClassOrObject>() ?: return
 
         val members = OverrideMembersHandler().collectMembersToGenerate(classOrObject)
 
@@ -104,10 +104,10 @@ class OverridesCompletion(
 
                     PsiDocumentManager.getInstance(context.project).commitAllDocuments()
 
-                    val dummyMember = context.file.findElementAt(context.startOffset)!!.getStrictParentOfType<JetNamedDeclaration>()!!
+                    val dummyMember = context.file.findElementAt(context.startOffset)!!.getStrictParentOfType<KtNamedDeclaration>()!!
 
                     // keep original modifiers
-                    val modifierList = JetPsiFactory(context.project).createModifierList(dummyMember.modifierList!!.text)
+                    val modifierList = KtPsiFactory(context.project).createModifierList(dummyMember.modifierList!!.text)
 
                     val prototype = memberObject.generateMember(context.project, isConstructorParameter)
                     prototype.modifierList!!.replace(modifierList)
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/PackageDirectiveCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/PackageDirectiveCompletion.kt
index 1935039a37a..d1368ff4f6f 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/PackageDirectiveCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/PackageDirectiveCompletion.kt
@@ -24,9 +24,9 @@ import com.intellij.patterns.PlatformPatterns
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.codeInsight.ReferenceVariantsHelper
 import org.jetbrains.kotlin.idea.util.CallType
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetPackageDirective
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtPackageDirective
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 
 /**
  * Performs completion in package directive. Should suggest only packages and avoid showing fake package produced by
@@ -34,15 +34,15 @@ import org.jetbrains.kotlin.psi.JetSimpleNameExpression
  */
 object PackageDirectiveCompletion {
     val DUMMY_IDENTIFIER = "___package___"
-    val ACTIVATION_PATTERN = PlatformPatterns.psiElement().inside(javaClass<JetPackageDirective>())
+    val ACTIVATION_PATTERN = PlatformPatterns.psiElement().inside(javaClass<KtPackageDirective>())
 
     fun perform(parameters: CompletionParameters, result: CompletionResultSet): Boolean {
         val position = parameters.getPosition()
         if (!ACTIVATION_PATTERN.accepts(position)) return false
 
-        val file = position.getContainingFile() as JetFile
+        val file = position.getContainingFile() as KtFile
 
-        val expression = file.findElementAt(parameters.getOffset())?.getParent() as? JetSimpleNameExpression ?: return false
+        val expression = file.findElementAt(parameters.getOffset())?.getParent() as? KtSimpleNameExpression ?: return false
 
         try {
             val prefixLength = parameters.getOffset() - expression.getTextOffset()
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ParameterNameAndTypeCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ParameterNameAndTypeCompletion.kt
index 7962b2111d2..05d3a62cc10 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ParameterNameAndTypeCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ParameterNameAndTypeCompletion.kt
@@ -36,14 +36,14 @@ import org.jetbrains.kotlin.idea.core.formatter.JetCodeStyleSettings
 import org.jetbrains.kotlin.idea.core.getResolutionScope
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetParameter
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.psi.psiUtil.forEachDescendantOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.utils.getDescriptorsFiltered
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.util.*
 
 class ParameterNameAndTypeCompletion(
@@ -101,8 +101,8 @@ class ParameterNameAndTypeCompletion(
 
     public fun addFromParametersInFile(position: PsiElement, resolutionFacade: ResolutionFacade, visibilityFilter: (DeclarationDescriptor) -> Boolean) {
         val lookupElementToCount = LinkedHashMap<LookupElement, Int>()
-        position.getContainingFile().forEachDescendantOfType<JetParameter>(
-                canGoInside = { it !is JetExpression || it is JetDeclaration } // we analyze parameters inside bodies to not resolve too much
+        position.getContainingFile().forEachDescendantOfType<KtParameter>(
+                canGoInside = { it !is KtExpression || it is KtDeclaration } // we analyze parameters inside bodies to not resolve too much
         ) { parameter ->
             ProgressManager.checkCanceled()
 
@@ -152,7 +152,7 @@ class ParameterNameAndTypeCompletion(
         }
     }
 
-    private fun JetType.isVisible(visibilityFilter: (DeclarationDescriptor) -> Boolean): Boolean {
+    private fun KtType.isVisible(visibilityFilter: (DeclarationDescriptor) -> Boolean): Boolean {
         if (isError()) return false
         val classifier = getConstructor().getDeclarationDescriptor() ?: return false
         return visibilityFilter(classifier) && getArguments().all { it.isStarProjection || it.getType().isVisible(visibilityFilter) }
@@ -175,7 +175,7 @@ class ParameterNameAndTypeCompletion(
                 = lookupElementFactory.createLookupElementForJavaClass(psiClass, qualifyNestedClasses = true)
     }
 
-    private class ArbitraryType(private val type: JetType) : Type(IdeDescriptorRenderers.SOURCE_CODE.renderType(type)) {
+    private class ArbitraryType(private val type: KtType) : Type(IdeDescriptorRenderers.SOURCE_CODE.renderType(type)) {
         override fun createTypeLookupElement(lookupElementFactory: LookupElementFactory)
                 = lookupElementFactory.createLookupElementForType(type)
     }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/PropertyKeyCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/PropertyKeyCompletion.kt
index 13786446cca..bb2bf6baa74 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/PropertyKeyCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/PropertyKeyCompletion.kt
@@ -20,7 +20,7 @@ import com.intellij.codeInsight.completion.CompletionParameters
 import com.intellij.codeInsight.completion.CompletionResultSet
 import com.intellij.lang.properties.references.PropertiesCompletionContributor
 import com.intellij.lang.properties.references.PropertyReference
-import org.jetbrains.kotlin.psi.JetStringTemplateExpression
+import org.jetbrains.kotlin.psi.KtStringTemplateExpression
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.isPlain
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 
 object PropertyKeyCompletion {
     fun perform(parameters: CompletionParameters, result: CompletionResultSet): Boolean {
-        val template = parameters.position.getStrictParentOfType<JetStringTemplateExpression>() ?: return false
+        val template = parameters.position.getStrictParentOfType<KtStringTemplateExpression>() ?: return false
         if (!template.isPlain()) return false
 
         val references = template.references
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/SmartCastCalculator.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/SmartCastCalculator.kt
index cf1f7cfbec7..641b5871dfc 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/SmartCastCalculator.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/SmartCastCalculator.kt
@@ -22,8 +22,8 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.idea.util.getImplicitReceiversWithInstance
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.psiUtil.getReceiverExpression
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
@@ -31,9 +31,9 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValue
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
 import org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
 import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import java.util.HashMap
@@ -41,26 +41,26 @@ import java.util.HashMap
 class SmartCastCalculator(
         val bindingContext: BindingContext,
         val containingDeclarationOrModule: DeclarationDescriptor,
-        expression: JetExpression
+        expression: KtExpression
 ) {
-    private val receiver = if (expression is JetSimpleNameExpression) expression.getReceiverExpression() else null
+    private val receiver = if (expression is KtSimpleNameExpression) expression.getReceiverExpression() else null
 
     // keys are VariableDescriptor's and ThisReceiver's
     private val entityToSmartCastInfo: Map<Any, SmartCastInfo>
             = processDataFlowInfo(bindingContext.getDataFlowInfo(expression), bindingContext[BindingContext.RESOLUTION_SCOPE, expression], receiver)
 
-    fun types(descriptor: VariableDescriptor): Collection<JetType> {
+    fun types(descriptor: VariableDescriptor): Collection<KtType> {
         val type = descriptor.returnType ?: return emptyList()
         return entityType(descriptor, type)
     }
 
-    fun types(thisReceiverParameter: ReceiverParameterDescriptor): Collection<JetType> {
+    fun types(thisReceiverParameter: ReceiverParameterDescriptor): Collection<KtType> {
         val type = thisReceiverParameter.type
         val thisReceiver = thisReceiverParameter.value as? ThisReceiver ?: return listOf(type)
         return entityType(thisReceiver, type)
     }
 
-    private fun entityType(entity: Any, ownType: JetType): Collection<JetType> {
+    private fun entityType(entity: Any, ownType: KtType): Collection<KtType> {
         val smartCastInfo = entityToSmartCastInfo[entity] ?: return listOf(ownType)
 
         var types = smartCastInfo.types + ownType
@@ -72,11 +72,11 @@ class SmartCastCalculator(
         return types
     }
 
-    private data class SmartCastInfo(var types: Collection<JetType>, var notNull: Boolean) {
+    private data class SmartCastInfo(var types: Collection<KtType>, var notNull: Boolean) {
         constructor() : this(emptyList(), false)
     }
 
-    private fun processDataFlowInfo(dataFlowInfo: DataFlowInfo, resolutionScope: JetScope?, receiver: JetExpression?): Map<Any, SmartCastInfo> {
+    private fun processDataFlowInfo(dataFlowInfo: DataFlowInfo, resolutionScope: KtScope?, receiver: KtExpression?): Map<Any, SmartCastInfo> {
         if (dataFlowInfo == DataFlowInfo.EMPTY) return emptyMap()
 
         val dataFlowValueToEntity: (DataFlowValue) -> Any?
@@ -126,7 +126,7 @@ class SmartCastCalculator(
         return entityToInfo
     }
 
-    private fun JetScope.findNearestReceiverForVariable(variableDescriptor: VariableDescriptor): ReceiverParameterDescriptor? {
+    private fun KtScope.findNearestReceiverForVariable(variableDescriptor: VariableDescriptor): ReceiverParameterDescriptor? {
         val classifier = variableDescriptor.containingDeclaration as? ClassifierDescriptor ?: return null
         val type = classifier.defaultType
         return getImplicitReceiversWithInstance().firstOrNull { it.type.isSubtypeOf(type) }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/Statisticians.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/Statisticians.kt
index fb8c8bb867e..2c7015c99a5 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/Statisticians.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/Statisticians.kt
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.core.completion.DeclarationLookupObject
 import org.jetbrains.kotlin.idea.imports.importableFqName
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.ParameterNameRenderingPolicy
 
@@ -52,7 +52,7 @@ class KotlinCompletionStatistician : CompletionStatistician() {
 
 class KotlinProximityStatistician : ProximityStatistician() {
     override fun serialize(element: PsiElement, location: ProximityLocation): StatisticsInfo? {
-        if (element !is JetDeclaration) return null
+        if (element !is KtDeclaration) return null
         val descriptor = element.resolveToDescriptor()
         return KotlinStatisticsInfo.forDescriptor(descriptor)
     }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ToFromOriginalFileMapper.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ToFromOriginalFileMapper.kt
index 750e52487bf..79785bc69fe 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ToFromOriginalFileMapper.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ToFromOriginalFileMapper.kt
@@ -16,14 +16,14 @@
 
 package org.jetbrains.kotlin.idea.completion
 
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtDeclaration
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
 class ToFromOriginalFileMapper(
-        val originalFile: JetFile,
-        val syntheticFile: JetFile,
+        val originalFile: KtFile,
+        val syntheticFile: KtFile,
         val completionOffset: Int
 ) {
     private val syntheticLength: Int
@@ -63,15 +63,15 @@ class ToFromOriginalFileMapper(
         }
     }
 
-    public fun toOriginalFile(declaration: JetDeclaration): JetDeclaration? {
+    public fun toOriginalFile(declaration: KtDeclaration): KtDeclaration? {
         if (declaration.getContainingFile() != syntheticFile) return declaration
         val offset = toOriginalFile(declaration.startOffset) ?: return null
-        return PsiTreeUtil.findElementOfClassAtOffset(originalFile, offset, javaClass<JetDeclaration>(), true)
+        return PsiTreeUtil.findElementOfClassAtOffset(originalFile, offset, javaClass<KtDeclaration>(), true)
     }
 
-    public fun toSyntheticFile(declaration: JetDeclaration): JetDeclaration? {
+    public fun toSyntheticFile(declaration: KtDeclaration): KtDeclaration? {
         if (declaration.getContainingFile() != originalFile) return declaration
         val offset = toSyntheticFile(declaration.startOffset) ?: return null
-        return PsiTreeUtil.findElementOfClassAtOffset(syntheticFile, offset, javaClass<JetDeclaration>(), true)
+        return PsiTreeUtil.findElementOfClassAtOffset(syntheticFile, offset, javaClass<KtDeclaration>(), true)
     }
 }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/confidence/UnfocusedPossibleFunctionParameter.java b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/confidence/UnfocusedPossibleFunctionParameter.java
index f0a81047b0e..bd6d96dd7c2 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/confidence/UnfocusedPossibleFunctionParameter.java
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/confidence/UnfocusedPossibleFunctionParameter.java
@@ -34,17 +34,17 @@ public class UnfocusedPossibleFunctionParameter extends CompletionConfidence {
         // 2. The same but for the case when first expression is additionally surrounded with brackets
 
         PsiElement position = parameters.getPosition();
-        JetFunctionLiteralExpression functionLiteral = PsiTreeUtil.getParentOfType(
-                position, JetFunctionLiteralExpression.class);
+        KtFunctionLiteralExpression functionLiteral = PsiTreeUtil.getParentOfType(
+                position, KtFunctionLiteralExpression.class);
 
         if (functionLiteral != null) {
             PsiElement expectedReference = position.getParent();
-            if (expectedReference instanceof JetSimpleNameExpression) {
-                if (PsiTreeUtil.findChildOfType(functionLiteral, JetParameterList.class) == null) {
+            if (expectedReference instanceof KtSimpleNameExpression) {
+                if (PsiTreeUtil.findChildOfType(functionLiteral, KtParameterList.class) == null) {
                     {
                         // 1.
                         PsiElement expectedBlock = expectedReference.getParent();
-                        if (expectedBlock instanceof JetBlockExpression) {
+                        if (expectedBlock instanceof KtBlockExpression) {
                             if (expectedReference.getPrevSibling() == null) {
                                 return ThreeState.NO;
                             }
@@ -54,9 +54,9 @@ public class UnfocusedPossibleFunctionParameter extends CompletionConfidence {
                     {
                         // 2.
                         PsiElement expectedParenthesized = expectedReference.getParent();
-                        if (expectedParenthesized instanceof JetParenthesizedExpression) {
+                        if (expectedParenthesized instanceof KtParenthesizedExpression) {
                             PsiElement expectedBlock = expectedParenthesized.getParent();
-                            if (expectedBlock instanceof JetBlockExpression) {
+                            if (expectedBlock instanceof KtBlockExpression) {
                                 if (expectedParenthesized.getPrevSibling() == null) {
                                     return ThreeState.NO;
                                 }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/CastReceiverInsertHandler.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/CastReceiverInsertHandler.kt
index 0b9a34d2464..8c529dc5937 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/CastReceiverInsertHandler.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/CastReceiverInsertHandler.kt
@@ -28,8 +28,8 @@ import org.jetbrains.kotlin.psi.*
 
 object CastReceiverInsertHandler {
     fun postHandleInsert(context: InsertionContext, item: LookupElement) {
-        val expression = PsiTreeUtil.findElementOfClassAtOffset(context.getFile(), context.getStartOffset(), javaClass<JetSimpleNameExpression>(), false)
-        val qualifiedExpression = PsiTreeUtil.getParentOfType(expression, javaClass<JetQualifiedExpression>(), true)
+        val expression = PsiTreeUtil.findElementOfClassAtOffset(context.getFile(), context.getStartOffset(), javaClass<KtSimpleNameExpression>(), false)
+        val qualifiedExpression = PsiTreeUtil.getParentOfType(expression, javaClass<KtQualifiedExpression>(), true)
         if (qualifiedExpression != null) {
             val receiver = qualifiedExpression.getReceiverExpression()
 
@@ -39,17 +39,17 @@ object CastReceiverInsertHandler {
             val thisObj = if (descriptor.getExtensionReceiverParameter() != null) descriptor.getExtensionReceiverParameter() else descriptor.getDispatchReceiverParameter()
             val fqName = IdeDescriptorRenderers.SOURCE_CODE.renderClassifierName(thisObj!!.getType().getConstructor().getDeclarationDescriptor()!!)
 
-            val parentCast = JetPsiFactory(project).createExpression("(expr as $fqName)") as JetParenthesizedExpression
-            val cast = parentCast.getExpression() as JetBinaryExpressionWithTypeRHS
+            val parentCast = KtPsiFactory(project).createExpression("(expr as $fqName)") as KtParenthesizedExpression
+            val cast = parentCast.getExpression() as KtBinaryExpressionWithTypeRHS
             cast.getLeft().replace(receiver)
 
             val psiDocumentManager = PsiDocumentManager.getInstance(project)
             psiDocumentManager.commitAllDocuments()
             psiDocumentManager.doPostponedOperationsAndUnblockDocument(context.getDocument())
 
-            val expr = receiver.replace(parentCast) as JetParenthesizedExpression
+            val expr = receiver.replace(parentCast) as KtParenthesizedExpression
 
-            ShortenReferences.DEFAULT.process((expr.getExpression() as JetBinaryExpressionWithTypeRHS).getRight()!!)
+            ShortenReferences.DEFAULT.process((expr.getExpression() as KtBinaryExpressionWithTypeRHS).getRight()!!)
         }
     }
 }
\ No newline at end of file
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/GenerateLambda.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/GenerateLambda.kt
index 6407fd0d9b9..f99caa25890 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/GenerateLambda.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/GenerateLambda.kt
@@ -32,12 +32,12 @@ import org.jetbrains.kotlin.idea.completion.fuzzyType
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
-fun insertLambdaTemplate(context: InsertionContext, placeholderRange: TextRange, lambdaType: JetType) {
+fun insertLambdaTemplate(context: InsertionContext, placeholderRange: TextRange, lambdaType: KtType) {
     val explicitParameterTypes = needExplicitParameterTypes(context, placeholderRange, lambdaType)
 
     // we start template later to not interfere with insertion of tail type
@@ -64,17 +64,17 @@ fun insertLambdaTemplate(context: InsertionContext, placeholderRange: TextRange,
     }
 }
 
-fun lambdaPresentation(lambdaType: JetType?): String {
+fun lambdaPresentation(lambdaType: KtType?): String {
     if (lambdaType == null) return "{...}"
     val parameterTypes = functionParameterTypes(lambdaType)
     val parametersPresentation = parameterTypes.map { IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType(it) }.joinToString(", ")
     return "{ $parametersPresentation -> ... }"
 }
 
-private fun needExplicitParameterTypes(context: InsertionContext, placeholderRange: TextRange, lambdaType: JetType): Boolean {
+private fun needExplicitParameterTypes(context: InsertionContext, placeholderRange: TextRange, lambdaType: KtType): Boolean {
     PsiDocumentManager.getInstance(context.getProject()).commitAllDocuments()
-    val file = context.getFile() as JetFile
-    val expression = PsiTreeUtil.findElementOfClassAtRange(file, placeholderRange.getStartOffset(), placeholderRange.getEndOffset(), javaClass<JetExpression>())
+    val file = context.getFile() as KtFile
+    val expression = PsiTreeUtil.findElementOfClassAtRange(file, placeholderRange.getStartOffset(), placeholderRange.getEndOffset(), javaClass<KtExpression>())
                      ?: return false
 
     val resolutionFacade = file.getResolutionFacade()
@@ -92,7 +92,7 @@ private fun needExplicitParameterTypes(context: InsertionContext, placeholderRan
     return functionTypes.filter { KotlinBuiltIns.getParameterTypeProjectionsFromFunctionType(it).size() == lambdaParameterCount }.size() > 1
 }
 
-private fun buildTemplate(lambdaType: JetType, explicitParameterTypes: Boolean, project: Project): Template {
+private fun buildTemplate(lambdaType: KtType, explicitParameterTypes: Boolean, project: Project): Template {
     val parameterTypes = functionParameterTypes(lambdaType)
 
     val manager = TemplateManager.getInstance(project)
@@ -128,5 +128,5 @@ private class ParameterNameExpression(val nameSuggestions: Array<String>) : Expr
             = Array<LookupElement>(nameSuggestions.size(), { LookupElementBuilder.create(nameSuggestions[it]) })
 }
 
-fun functionParameterTypes(functionType: JetType): List<JetType>
+fun functionParameterTypes(functionType: KtType): List<KtType>
         = KotlinBuiltIns.getParameterTypeProjectionsFromFunctionType(functionType).map { it.getType() }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinCallableInsertHandler.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinCallableInsertHandler.kt
index c98fcafbe12..c1489170b47 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinCallableInsertHandler.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinCallableInsertHandler.kt
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.idea.completion.isAfterDot
 import org.jetbrains.kotlin.idea.core.completion.DeclarationLookupObject
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 
 abstract class KotlinCallableInsertHandler : BaseDeclarationInsertHandler() {
@@ -39,7 +39,7 @@ abstract class KotlinCallableInsertHandler : BaseDeclarationInsertHandler() {
 
         val file = context.getFile()
         val o = item.getObject()
-        if (file is JetFile && o is DeclarationLookupObject) {
+        if (file is KtFile && o is DeclarationLookupObject) {
             val descriptor = o.descriptor as? CallableDescriptor
             if (descriptor != null) {
                 // for completion after dot, import insertion may be required only for extensions
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinClassifierInsertHandler.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinClassifierInsertHandler.kt
index 7b14cdccbd4..9578b1dda8f 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinClassifierInsertHandler.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinClassifierInsertHandler.kt
@@ -29,8 +29,8 @@ import org.jetbrains.kotlin.idea.util.CallTypeAndReceiver
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences
 import org.jetbrains.kotlin.name.FqNameUnsafe
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNameReferenceExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNameReferenceExpression
 import org.jetbrains.kotlin.renderer.render
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
@@ -40,7 +40,7 @@ object KotlinClassifierInsertHandler : BaseDeclarationInsertHandler() {
         super.handleInsert(context, item)
 
         val file = context.getFile()
-        if (file is JetFile) {
+        if (file is KtFile) {
             if (!context.isAfterDot()) {
                 val psiDocumentManager = PsiDocumentManager.getInstance(context.getProject())
                 psiDocumentManager.commitAllDocuments()
@@ -52,7 +52,7 @@ object KotlinClassifierInsertHandler : BaseDeclarationInsertHandler() {
 
                 // first try to resolve short name for faster handling
                 val token = file.findElementAt(startOffset)
-                val nameRef = token!!.getParent() as? JetNameReferenceExpression
+                val nameRef = token!!.getParent() as? KtNameReferenceExpression
                 if (nameRef != null) {
                     val bindingContext = nameRef.getResolutionFacade().analyze(nameRef, BodyResolveMode.PARTIAL)
                     val target = bindingContext[BindingContext.SHORT_REFERENCE_TO_COMPANION_OBJECT, nameRef]
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinFunctionInsertHandler.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinFunctionInsertHandler.kt
index 22cd3cd45de..46860a79a8e 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinFunctionInsertHandler.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinFunctionInsertHandler.kt
@@ -26,12 +26,12 @@ import com.intellij.psi.PsiDocumentManager
 import com.intellij.psi.PsiElement
 import com.intellij.psi.codeStyle.CodeStyleSettingsManager
 import org.jetbrains.kotlin.idea.core.formatter.JetCodeStyleSettings
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetTypeArgumentList
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtTypeArgumentList
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
-class GenerateLambdaInfo(val lambdaType: JetType, val explicitParameters: Boolean)
+class GenerateLambdaInfo(val lambdaType: KtType, val explicitParameters: Boolean)
 
 sealed class KotlinFunctionInsertHandler : KotlinCallableInsertHandler() {
 
@@ -97,9 +97,9 @@ sealed class KotlinFunctionInsertHandler : KotlinCallableInsertHandler() {
                     if (chars[offset1] == '<') {
                         PsiDocumentManager.getInstance(project).commitDocument(document)
                         val token = context.getFile().findElementAt(offset1)!!
-                        if (token.getNode().getElementType() == JetTokens.LT) {
+                        if (token.getNode().getElementType() == KtTokens.LT) {
                             val parent = token.getParent()
-                            if (parent is JetTypeArgumentList && parent.getText().indexOf('\n') < 0/* if type argument list is on multiple lines this is more likely wrong parsing*/) {
+                            if (parent is KtTypeArgumentList && parent.getText().indexOf('\n') < 0/* if type argument list is on multiple lines this is more likely wrong parsing*/) {
                                 offset = parent.endOffset
                                 insertTypeArguments = false
                             }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinKeywordInsertHandler.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinKeywordInsertHandler.kt
index 121d55cc3f8..c740809efd7 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinKeywordInsertHandler.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinKeywordInsertHandler.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.completion.handlers
 import com.intellij.codeInsight.completion.InsertHandler
 import com.intellij.codeInsight.completion.InsertionContext
 import com.intellij.codeInsight.lookup.LookupElement
-import org.jetbrains.kotlin.lexer.JetTokens.*
+import org.jetbrains.kotlin.lexer.KtTokens.*
 
 object KotlinKeywordInsertHandler : InsertHandler<LookupElement> {
     private val NO_SPACE_AFTER = listOf(THIS_KEYWORD,
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/WithExpressionPrefixInsertHandler.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/WithExpressionPrefixInsertHandler.kt
index 26bc024ee9e..08ce4b65b94 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/WithExpressionPrefixInsertHandler.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/WithExpressionPrefixInsertHandler.kt
@@ -20,10 +20,10 @@ import com.intellij.codeInsight.completion.InsertHandler
 import com.intellij.codeInsight.completion.InsertionContext
 import com.intellij.codeInsight.lookup.LookupElement
 import com.intellij.psi.PsiDocumentManager
-import org.jetbrains.kotlin.psi.JetCallExpression
-import org.jetbrains.kotlin.psi.JetDotQualifiedExpression
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtCallExpression
+import org.jetbrains.kotlin.psi.KtDotQualifiedExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 
 class WithExpressionPrefixInsertHandler(val prefix: String) : InsertHandler<LookupElement> {
@@ -40,14 +40,14 @@ class WithExpressionPrefixInsertHandler(val prefix: String) : InsertHandler<Look
 
         val offset = context.getStartOffset()
         val token = context.getFile().findElementAt(offset)!!
-        var expression = token.getStrictParentOfType<JetExpression>() ?: return
-        if (expression is JetSimpleNameExpression) {
+        var expression = token.getStrictParentOfType<KtExpression>() ?: return
+        if (expression is KtSimpleNameExpression) {
             var parent = expression.getParent()
-            if (parent is JetCallExpression && expression == parent.getCalleeExpression()) {
+            if (parent is KtCallExpression && expression == parent.getCalleeExpression()) {
                 expression = parent
                 parent = parent.getParent()
             }
-            if (parent is JetDotQualifiedExpression && expression == parent.getSelectorExpression()) {
+            if (parent is KtDotQualifiedExpression && expression == parent.getSelectorExpression()) {
                 expression = parent
             }
         }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/ClassLiteralItems.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/ClassLiteralItems.kt
index a52df9e1ab5..9474d0937e0 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/ClassLiteralItems.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/ClassLiteralItems.kt
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.idea.completion.createLookupElementForType
 import org.jetbrains.kotlin.idea.completion.fuzzyType
 import org.jetbrains.kotlin.idea.imports.importableFqName
 import org.jetbrains.kotlin.idea.quickfix.moveCaret
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.Variance
 import java.util.*
 
@@ -39,7 +39,7 @@ object ClassLiteralItems {
             lookupElementFactory: LookupElementFactory,
             isJvmModule: Boolean
     ) {
-        val typeAndSuffixToExpectedInfos = LinkedHashMap<Pair<JetType, String>, MutableList<ExpectedInfo>>()
+        val typeAndSuffixToExpectedInfos = LinkedHashMap<Pair<KtType, String>, MutableList<ExpectedInfo>>()
 
         for (expectedInfo in expectedInfos) {
             val fuzzyType = expectedInfo.fuzzyType ?: continue
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/MultipleArgumentsItemProvider.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/MultipleArgumentsItemProvider.kt
index 0d041ee3268..145d60b6262 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/MultipleArgumentsItemProvider.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/MultipleArgumentsItemProvider.kt
@@ -30,12 +30,12 @@ import org.jetbrains.kotlin.idea.completion.Tail
 import org.jetbrains.kotlin.idea.util.getVariableFromImplicitReceivers
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.psi.Call
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.renderer.render
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasDefaultValue
-import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.resolve.scopes.KtScope
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import java.util.*
 
 class MultipleArgumentsItemProvider(val bindingContext: BindingContext,
@@ -43,7 +43,7 @@ class MultipleArgumentsItemProvider(val bindingContext: BindingContext,
 
     public fun addToCollection(collection: MutableCollection<LookupElement>,
                                expectedInfos: Collection<ExpectedInfo>,
-                               context: JetExpression) {
+                               context: KtExpression) {
         val resolutionScope = bindingContext[BindingContext.RESOLUTION_SCOPE, context] ?: return
 
         val added = HashSet<String>()
@@ -96,12 +96,12 @@ class MultipleArgumentsItemProvider(val bindingContext: BindingContext,
                 .assignSmartCompletionPriority(SmartCompletionItemPriority.MULTIPLE_ARGUMENTS_ITEM)
     }
 
-    private fun variableInScope(parameter: ValueParameterDescriptor, scope: JetScope): VariableDescriptor? {
+    private fun variableInScope(parameter: ValueParameterDescriptor, scope: KtScope): VariableDescriptor? {
         val name = parameter.getName()
         //TODO: there can be more than one property with such name in scope and we should be able to select one (but we need API for this)
         val variable = scope.getLocalVariable(name) ?: scope.getProperties(name, NoLookupLocation.FROM_IDE).singleOrNull() ?:
                        scope.getVariableFromImplicitReceivers(name) ?: return null
-        return if (smartCastCalculator.types(variable).any { JetTypeChecker.DEFAULT.isSubtypeOf(it, parameter.getType()) })
+        return if (smartCastCalculator.types(variable).any { KotlinTypeChecker.DEFAULT.isSubtypeOf(it, parameter.getType()) })
             variable
         else
             null
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt
index 7e7dbf5af8f..0dfdadd5ea7 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt
@@ -30,11 +30,11 @@ import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.util.CallTypeAndReceiver
 import org.jetbrains.kotlin.idea.util.FuzzyType
 import org.jetbrains.kotlin.idea.util.isAlmostEverything
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import org.jetbrains.kotlin.utils.addIfNotNull
@@ -48,7 +48,7 @@ interface InheritanceItemsSearcher {
 }
 
 class SmartCompletion(
-        private val expression: JetExpression,
+        private val expression: KtExpression,
         private val resolutionFacade: ResolutionFacade,
         private val bindingContext: BindingContext,
         private val moduleDescriptor: ModuleDescriptor,
@@ -69,7 +69,7 @@ class SmartCompletion(
         is CallTypeAndReceiver.SAFE,
         is CallTypeAndReceiver.INFIX,
         is CallTypeAndReceiver.CALLABLE_REFERENCE ->
-            expression.parent as JetExpression
+            expression.parent as KtExpression
 
         else -> // actually no smart completion for such places
             expression
@@ -104,26 +104,26 @@ class SmartCompletion(
     public val descriptorsToSkip: Set<DeclarationDescriptor> by lazy<Set<DeclarationDescriptor>>(LazyThreadSafetyMode.NONE) {
         val parent = expressionWithType.getParent()
         when (parent) {
-            is JetBinaryExpression -> {
+            is KtBinaryExpression -> {
                 if (parent.getRight() == expressionWithType) {
                     val operationToken = parent.getOperationToken()
-                    if (operationToken == JetTokens.EQ || operationToken in COMPARISON_TOKENS) {
+                    if (operationToken == KtTokens.EQ || operationToken in COMPARISON_TOKENS) {
                         val left = parent.getLeft()
-                        if (left is JetReferenceExpression) {
+                        if (left is KtReferenceExpression) {
                             return@lazy bindingContext[BindingContext.REFERENCE_TARGET, left].singletonOrEmptySet()
                         }
                     }
                 }
             }
 
-            is JetWhenConditionWithExpression -> {
-                val entry = parent.getParent() as JetWhenEntry
-                val whenExpression = entry.getParent() as JetWhenExpression
+            is KtWhenConditionWithExpression -> {
+                val entry = parent.getParent() as KtWhenEntry
+                val whenExpression = entry.getParent() as KtWhenExpression
                 val subject = whenExpression.getSubjectExpression() ?: return@lazy emptySet()
 
                 val descriptorsToSkip = HashSet<DeclarationDescriptor>()
 
-                if (subject is JetSimpleNameExpression) {
+                if (subject is KtSimpleNameExpression) {
                     val variable = bindingContext[BindingContext.REFERENCE_TARGET, subject] as? VariableDescriptor
                     if (variable != null) {
                         descriptorsToSkip.add(variable)
@@ -135,10 +135,10 @@ class SmartCompletion(
                 if (classDescriptor != null && DescriptorUtils.isEnumClass(classDescriptor)) {
                     val conditions = whenExpression.getEntries()
                             .flatMap { it.getConditions().toList() }
-                            .filterIsInstance<JetWhenConditionWithExpression>()
+                            .filterIsInstance<KtWhenConditionWithExpression>()
                     for (condition in conditions) {
-                        val selectorExpr = (condition.getExpression() as? JetDotQualifiedExpression)
-                                                   ?.getSelectorExpression() as? JetReferenceExpression ?: continue
+                        val selectorExpr = (condition.getExpression() as? KtDotQualifiedExpression)
+                                                   ?.getSelectorExpression() as? KtReferenceExpression ?: continue
                         val target = bindingContext[BindingContext.REFERENCE_TARGET, selectorExpr] as? ClassDescriptor ?: continue
                         if (DescriptorUtils.isEnumEntry(target)) {
                             descriptorsToSkip.add(target)
@@ -203,7 +203,7 @@ class SmartCompletion(
                 TypeInstantiationItems(resolutionFacade, bindingContext, visibilityFilter, toFromOriginalFileMapper, inheritorSearchScope, lookupElementFactory, forBasicCompletion)
                         .addTo(items, inheritanceSearchers, expectedInfos)
 
-                if (expression is JetSimpleNameExpression) {
+                if (expression is KtSimpleNameExpression) {
                     StaticMembers(bindingContext, lookupElementFactory).addToCollection(items, expectedInfos, expression, descriptorsToSkip)
                 }
 
@@ -212,10 +212,10 @@ class SmartCompletion(
                 if (!forBasicCompletion) {
                     LambdaItems.addToCollection(items, expectedInfos)
 
-                    val whenCondition = expressionWithType.parent as? JetWhenConditionWithExpression
+                    val whenCondition = expressionWithType.parent as? KtWhenConditionWithExpression
                     if (whenCondition != null) {
-                        val entry = whenCondition.parent as JetWhenEntry
-                        val whenExpression = entry.parent as JetWhenExpression
+                        val entry = whenCondition.parent as KtWhenEntry
+                        val whenExpression = entry.parent as KtWhenExpression
                         val entries = whenExpression.entries
                         if (whenExpression.elseExpression == null && entry == entries.last() && entries.size() != 1) {
                             val lookupElement = LookupElementBuilder.create("else").bold().withTailText(" ->")
@@ -266,7 +266,7 @@ class SmartCompletion(
         }
     }
 
-    private fun MutableCollection<LookupElement>.addThisItems(place: JetExpression, expectedInfos: Collection<ExpectedInfo>, smartCastCalculator: SmartCastCalculator) {
+    private fun MutableCollection<LookupElement>.addThisItems(place: KtExpression, expectedInfos: Collection<ExpectedInfo>, smartCastCalculator: SmartCastCalculator) {
         if (shouldCompleteThisItems(prefixMatcher)) {
             val items = thisExpressionItems(bindingContext, place, prefixMatcher.getPrefix(), resolutionFacade)
             for (item in items) {
@@ -279,7 +279,7 @@ class SmartCompletion(
         }
     }
 
-    private fun calcExpectedInfos(expression: JetExpression): Collection<ExpectedInfo> {
+    private fun calcExpectedInfos(expression: KtExpression): Collection<ExpectedInfo> {
         // if our expression is initializer of implicitly typed variable - take type of variable from original file (+ the same for function)
         val declaration = implicitlyTypedDeclarationFromInitializer(expression)
         if (declaration != null) {
@@ -309,11 +309,11 @@ class SmartCompletion(
         //TODO: we could always give higher priority to results with outer call expected type used
     }
 
-    private fun implicitlyTypedDeclarationFromInitializer(expression: JetExpression): JetDeclaration? {
+    private fun implicitlyTypedDeclarationFromInitializer(expression: KtExpression): KtDeclaration? {
         val parent = expression.getParent()
         when (parent) {
-            is JetVariableDeclaration -> if (expression == parent.getInitializer() && parent.getTypeReference() == null) return parent
-            is JetNamedFunction -> if (expression == parent.getInitializer() && parent.getTypeReference() == null) return parent
+            is KtVariableDeclaration -> if (expression == parent.getInitializer() && parent.getTypeReference() == null) return parent
+            is KtNamedFunction -> if (expression == parent.getInitializer() && parent.getTypeReference() == null) return parent
         }
         return null
     }
@@ -366,15 +366,15 @@ class SmartCompletion(
     }
 
     private fun buildForAsTypePosition(): Collection<LookupElement>? {
-        val binaryExpression = ((expression.getParent() as? JetUserType)
-                ?.getParent() as? JetTypeReference)
-                    ?.getParent() as? JetBinaryExpressionWithTypeRHS
+        val binaryExpression = ((expression.getParent() as? KtUserType)
+                ?.getParent() as? KtTypeReference)
+                    ?.getParent() as? KtBinaryExpressionWithTypeRHS
                         ?: return null
         val elementType = binaryExpression.getOperationReference().getReferencedNameElementType()
-        if (elementType != JetTokens.AS_KEYWORD && elementType != JetTokens.AS_SAFE) return null
+        if (elementType != KtTokens.AS_KEYWORD && elementType != KtTokens.AS_SAFE) return null
         val expectedInfos = calcExpectedInfos(binaryExpression)
 
-        val expectedInfosGrouped: Map<JetType?, List<ExpectedInfo>> = expectedInfos.groupBy { it.fuzzyType?.type?.makeNotNullable() }
+        val expectedInfosGrouped: Map<KtType?, List<ExpectedInfo>> = expectedInfos.groupBy { it.fuzzyType?.type?.makeNotNullable() }
 
         val items = ArrayList<LookupElement>()
         for ((type, infos) in expectedInfosGrouped) {
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletionSession.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletionSession.kt
index eb346d960de..048be502077 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletionSession.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletionSession.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.idea.completion.*
 import org.jetbrains.kotlin.idea.util.CallTypeAndReceiver
 import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptorKindExclude
 import org.jetbrains.kotlin.psi.FunctionLiteralArgument
-import org.jetbrains.kotlin.psi.JetCodeFragment
+import org.jetbrains.kotlin.psi.KtCodeFragment
 import org.jetbrains.kotlin.psi.ValueArgumentName
 import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
 import org.jetbrains.kotlin.resolve.calls.util.DelegatingCall
@@ -77,7 +77,7 @@ class SmartCompletionSession(configuration: CompletionSessionConfiguration, para
                     processNonImported { collector.addElements(filter(it), notImported = true) }
                     flushToResultSet()
 
-                    if (position.getContainingFile() is JetCodeFragment) {
+                    if (position.getContainingFile() is KtCodeFragment) {
                         getRuntimeReceiverTypeReferenceVariants().forEach {
                             collector.addElements(filter(it).map { it.withReceiverCast() })
                         }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/StaticMembers.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/StaticMembers.kt
index 8be97474891..4196c857335 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/StaticMembers.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/StaticMembers.kt
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.idea.completion.shortenReferences
 import org.jetbrains.kotlin.idea.core.isVisible
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.fuzzyReturnType
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -45,7 +45,7 @@ class StaticMembers(
 ) {
     public fun addToCollection(collection: MutableCollection<LookupElement>,
                                expectedInfos: Collection<ExpectedInfo>,
-                               context: JetSimpleNameExpression,
+                               context: KtSimpleNameExpression,
                                enumEntriesToSkip: Set<DeclarationDescriptor>) {
 
         val expectedInfosByClass = expectedInfos.groupBy {
@@ -62,7 +62,7 @@ class StaticMembers(
             collection: MutableCollection<LookupElement>,
             classDescriptor: ClassDescriptor,
             expectedInfos: Collection<ExpectedInfo>,
-            context: JetSimpleNameExpression,
+            context: KtSimpleNameExpression,
             enumEntriesToSkip: Set<DeclarationDescriptor>) {
 
         val scope = bindingContext[BindingContext.RESOLUTION_SCOPE, context] ?: return
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt
index 2d42a476011..51d8e987da6 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt
@@ -40,8 +40,8 @@ import org.jetbrains.kotlin.idea.util.makeNotNullable
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptor
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -104,14 +104,14 @@ class TypeInstantiationItems(
             descriptor: ClassDescriptor, kotlinClassDescriptor: ClassDescriptor, typeArgs: List<TypeProjection>, freeParameters: Collection<TypeParameterDescriptor>, tail: Tail?
     ) {
         val _declaration = DescriptorToSourceUtilsIde.getAnyDeclaration(resolutionFacade.project, descriptor) ?: return
-        val declaration = if (_declaration is JetDeclaration)
+        val declaration = if (_declaration is KtDeclaration)
             toFromOriginalFileMapper.toOriginalFile(_declaration) ?: return
         else
             _declaration
 
         val psiClass: PsiClass = when (declaration) {
             is PsiClass -> declaration
-            is JetClassOrObject -> LightClassUtil.getPsiClass(declaration) ?: return
+            is KtClassOrObject -> LightClassUtil.getPsiClass(declaration) ?: return
             else -> return
         }
         add(InheritanceSearcher(psiClass, kotlinClassDescriptor, typeArgs, freeParameters, tail))
@@ -266,7 +266,7 @@ class TypeInstantiationItems(
         return InstantiationLookupElement(lookupElement).addTail(tail)
     }
 
-    private fun JetType.areTypeParametersUsedInside(freeParameters: Collection<TypeParameterDescriptor>): Boolean {
+    private fun KtType.areTypeParametersUsedInside(freeParameters: Collection<TypeParameterDescriptor>): Boolean {
         return FuzzyType(this, freeParameters).freeParameters.isNotEmpty()
     }
 
@@ -296,7 +296,7 @@ class TypeInstantiationItems(
             private val tail: Tail?) : InheritanceItemsSearcher {
 
         private val baseHasTypeArgs = classDescriptor.typeConstructor.parameters.isNotEmpty()
-        private val expectedType = JetTypeImpl.create(Annotations.EMPTY, classDescriptor, false, typeArgs)
+        private val expectedType = KtTypeImpl.create(Annotations.EMPTY, classDescriptor, false, typeArgs)
         private val expectedFuzzyType = FuzzyType(expectedType, freeParameters)
 
         override fun search(nameFilter: (String) -> Boolean, consumer: (LookupElement) -> Unit) {
@@ -304,7 +304,7 @@ class TypeInstantiationItems(
             for (inheritor in ClassInheritorsSearch.search(parameters)) {
                 val descriptor = resolutionFacade.psiClassToDescriptor(
                         inheritor,
-                        { toFromOriginalFileMapper.toSyntheticFile(it) as JetClassOrObject? }) as? ClassDescriptor ?: continue
+                        { toFromOriginalFileMapper.toSyntheticFile(it) as KtClassOrObject? }) as? ClassDescriptor ?: continue
                 if (!visibilityFilter(descriptor)) continue
 
                 var inheritorFuzzyType = FuzzyType(descriptor.defaultType, descriptor.typeConstructor.parameters)
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypesWithContainsDetector.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypesWithContainsDetector.kt
index 7c254eb6ad3..f3a097fd68a 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypesWithContainsDetector.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypesWithContainsDetector.kt
@@ -25,15 +25,15 @@ import org.jetbrains.kotlin.idea.util.FuzzyType
 import org.jetbrains.kotlin.idea.util.nullability
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
-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.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.typeUtil.TypeNullability
 import java.util.*
 
 class TypesWithContainsDetector(
-        private val scope: JetScope,
-        private val argumentType: JetType,
+        private val scope: KtScope,
+        private val argumentType: KtType,
         private val resolutionFacade: ResolutionFacade
 ) {
     private val cache = HashMap<FuzzyType, Boolean>()
@@ -41,7 +41,7 @@ class TypesWithContainsDetector(
     private val booleanType = resolutionFacade.moduleDescriptor.builtIns.booleanType
     private val heuristicSignatures = resolutionFacade.ideService<HeuristicSignatures>()
 
-    private val typesWithExtensionContains: Collection<JetType> = scope.getFunctions(containsName, NoLookupLocation.FROM_IDE)
+    private val typesWithExtensionContains: Collection<KtType> = scope.getFunctions(containsName, NoLookupLocation.FROM_IDE)
             .filter { it.getExtensionReceiverParameter() != null && isGoodContainsFunction(it, listOf()) }
             .map { it.getExtensionReceiverParameter()!!.getType() }
 
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/CommentSaver.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/CommentSaver.kt
index e856a3c5a96..6c95c26e7b8 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/CommentSaver.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/CommentSaver.kt
@@ -20,9 +20,9 @@ import com.intellij.openapi.util.Key
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.*
 import com.intellij.psi.codeStyle.CodeStyleManager
-import org.jetbrains.kotlin.lexer.JetToken
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.lexer.KtToken
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.psiUtil.*
 import java.util.ArrayList
 import java.util.HashMap
@@ -32,7 +32,7 @@ public class CommentSaver(originalElements: PsiChildRange, private val saveLineB
     public constructor(originalElement: PsiElement, saveLineBreaks: Boolean = false/*TODO?*/) : this(PsiChildRange.singleElement(originalElement), saveLineBreaks)
 
     private val SAVED_TREE_KEY = Key<TreeElement>("SAVED_TREE")
-    private val psiFactory = JetPsiFactory(originalElements.first!!)
+    private val psiFactory = KtPsiFactory(originalElements.first!!)
 
     private abstract class TreeElement {
         public companion object {
@@ -122,7 +122,7 @@ public class CommentSaver(originalElements: PsiChildRange, private val saveLineB
     }
 
     private class StandardTreeElement() : TreeElement()
-    private class TokenTreeElement(val tokenType: JetToken) : TreeElement()
+    private class TokenTreeElement(val tokenType: KtToken) : TreeElement()
     private class LineBreakTreeElement() : TreeElement()
 
     private class CommentTreeElement(
@@ -314,7 +314,7 @@ public class CommentSaver(originalElements: PsiChildRange, private val saveLineB
 
             bindNewElement(restored, commentTreeElement) // will be used when restoring line breaks
 
-            if (restored.tokenType == JetTokens.EOL_COMMENT) {
+            if (restored.tokenType == KtTokens.EOL_COMMENT) {
                 needAdjustIndentAfterRestore = true // TODO: do we really need it?
             }
         }
@@ -336,7 +336,7 @@ public class CommentSaver(originalElements: PsiChildRange, private val saveLineB
             }
 
 
-            val tokensToMatch = arrayListOf<JetToken>()
+            val tokensToMatch = arrayListOf<KtToken>()
             for (leaf in lineBreakElement.prevLeafs) {
                 var psiElement = findRestored(leaf)
                 if (psiElement != null) {
@@ -352,7 +352,7 @@ public class CommentSaver(originalElements: PsiChildRange, private val saveLineB
         }
     }
 
-    private fun skipTokensForward(psiElement: PsiElement, tokensToMatch: List<JetToken>): PsiElement? {
+    private fun skipTokensForward(psiElement: PsiElement, tokensToMatch: List<KtToken>): PsiElement? {
         var currentPsiElement = psiElement
         for (token in tokensToMatch) {
             currentPsiElement = currentPsiElement.nextLeaf(nonSpaceAndNonEmptyFilter) ?: return null
@@ -432,7 +432,7 @@ public class CommentSaver(originalElements: PsiChildRange, private val saveLineB
         }
 
         // don't put end of line comment right before comma
-        if (anchor.before && comment.tokenType == JetTokens.EOL_COMMENT) {
+        if (anchor.before && comment.tokenType == KtTokens.EOL_COMMENT) {
             psiElement = shiftNewLineAnchor(psiElement)
         }
 
@@ -442,14 +442,14 @@ public class CommentSaver(originalElements: PsiChildRange, private val saveLineB
     // don't put line break right before comma
     private fun shiftNewLineAnchor(putAfter: PsiElement): PsiElement {
         val next = putAfter.nextLeaf(nonSpaceAndNonEmptyFilter)
-        return if (next?.tokenType == JetTokens.COMMA) next!! else putAfter
+        return if (next?.tokenType == KtTokens.COMMA) next!! else putAfter
     }
 
     private val nonSpaceAndNonEmptyFilter = { element: PsiElement -> element !is PsiWhiteSpace && element.getTextLength() > 0 }
 
     companion object {
         //TODO: making it private causes error on runtime (KT-7874?)
-        val PsiElement.tokenType: JetToken?
-            get() = getNode().getElementType() as? JetToken
+        val PsiElement.tokenType: KtToken?
+            get() = getNode().getElementType() as? KtToken
     }
 }
\ No newline at end of file
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/ImportableFqNameClassifier.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/ImportableFqNameClassifier.kt
index 822a5146a90..da54432f505 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/ImportableFqNameClassifier.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/ImportableFqNameClassifier.kt
@@ -20,11 +20,11 @@ import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.load.java.components.JavaAnnotationMapper
 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.resolve.ImportPath
 import java.util.*
 
-class ImportableFqNameClassifier(private val file: JetFile) {
+class ImportableFqNameClassifier(private val file: KtFile) {
     private val preciseImports = HashSet<FqName>()
     private val preciseImportPackages = HashSet<FqName>()
     private val allUnderImports = HashSet<FqName>()
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetection.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetection.kt
index 8db3fbe706d..21724fe3989 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetection.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetection.kt
@@ -21,13 +21,13 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.idea.util.FuzzyType
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.kotlin.resolve.scopes.utils.asLexicalScope
-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
 import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker
@@ -42,37 +42,37 @@ public class IterableTypesDetection(
         private val iteratorName = Name.identifier("iterator")
     }
 
-    public fun createDetector(scope: JetScope): IterableTypesDetector {
+    public fun createDetector(scope: KtScope): IterableTypesDetector {
         return Detector(scope)
     }
-    private inner class Detector(private val scope: JetScope): IterableTypesDetector {
+    private inner class Detector(private val scope: KtScope): IterableTypesDetector {
         private val cache = HashMap<FuzzyType, FuzzyType?>()
 
-        private val typesWithExtensionIterator: Collection<JetType> = scope.getFunctions(iteratorName, NoLookupLocation.FROM_IDE)
+        private val typesWithExtensionIterator: Collection<KtType> = scope.getFunctions(iteratorName, NoLookupLocation.FROM_IDE)
                 .map { it.getExtensionReceiverParameter() }
                 .filterNotNull()
                 .map { it.getType() }
 
-        override fun isIterable(type: FuzzyType, loopVarType: JetType?): Boolean {
+        override fun isIterable(type: FuzzyType, loopVarType: KtType?): Boolean {
             val elementType = elementType(type) ?: return false
             return loopVarType == null || elementType.checkIsSubtypeOf(loopVarType) != null
         }
 
-        override fun isIterable(type: JetType, loopVarType: JetType?): Boolean
+        override fun isIterable(type: KtType, loopVarType: KtType?): Boolean
                 = isIterable(FuzzyType(type, emptyList()), loopVarType)
 
         private fun elementType(type: FuzzyType): FuzzyType? {
             return cache.getOrPut(type, { elementTypeNoCache(type) })
         }
 
-        override fun elementType(type: JetType): FuzzyType?
+        override fun elementType(type: KtType): FuzzyType?
                 = elementType(FuzzyType(type, emptyList()))
 
         private fun elementTypeNoCache(type: FuzzyType): FuzzyType? {
             // optimization
             if (!canBeIterable(type)) return null
 
-            val expression = JetPsiFactory(project).createExpression("fake")
+            val expression = KtPsiFactory(project).createExpression("fake")
             val expressionReceiver = ExpressionReceiver(expression, type.type)
             val context = ExpressionTypingContext.newContext(BindingTraceContext(), scope.asLexicalScope(), DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE)
             val elementType = forLoopConventionsChecker.checkIterableConvention(expressionReceiver, context)
@@ -87,9 +87,9 @@ public class IterableTypesDetection(
 }
 
 public interface IterableTypesDetector {
-    public fun isIterable(type: JetType, loopVarType: JetType? = null): Boolean
+    public fun isIterable(type: KtType, loopVarType: KtType? = null): Boolean
 
-    public fun isIterable(type: FuzzyType, loopVarType: JetType? = null): Boolean
+    public fun isIterable(type: FuzzyType, loopVarType: KtType? = null): Boolean
 
-    public fun elementType(type: JetType): FuzzyType?
+    public fun elementType(type: KtType): FuzzyType?
 }
\ No newline at end of file
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinIndicesHelper.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinIndicesHelper.kt
index d3f080059a3..1001b99c746 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinIndicesHelper.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinIndicesHelper.kt
@@ -30,14 +30,14 @@ import org.jetbrains.kotlin.idea.util.CallTypeAndReceiver
 import org.jetbrains.kotlin.idea.util.receiverTypes
 import org.jetbrains.kotlin.idea.util.substituteExtensionIfCallable
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.isAnnotatedAsHidden
 import org.jetbrains.kotlin.resolve.lazy.ResolveSessionUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
 import java.util.*
@@ -60,7 +60,7 @@ public class KotlinIndicesHelper(
     }
 
     public fun getTopLevelCallablesByName(name: String): Collection<CallableDescriptor> {
-        val declarations = HashSet<JetNamedDeclaration>()
+        val declarations = HashSet<KtNamedDeclaration>()
         declarations.addTopLevelNonExtensionCallablesByName(JetFunctionShortNameIndex.getInstance(), name)
         declarations.addTopLevelNonExtensionCallablesByName(JetPropertyShortNameIndex.getInstance(), name)
         return declarations.flatMap {
@@ -73,11 +73,11 @@ public class KotlinIndicesHelper(
         }.filter { it.getExtensionReceiverParameter() == null && descriptorFilter(it) }
     }
 
-    private fun MutableSet<JetNamedDeclaration>.addTopLevelNonExtensionCallablesByName(
-            index: StringStubIndexExtension<out JetCallableDeclaration>,
+    private fun MutableSet<KtNamedDeclaration>.addTopLevelNonExtensionCallablesByName(
+            index: StringStubIndexExtension<out KtCallableDeclaration>,
             name: String
     ) {
-        index.get(name, project, scope).filterTo(this) { it.getParent() is JetFile && it.getReceiverTypeReference() == null }
+        index.get(name, project, scope).filterTo(this) { it.getParent() is KtFile && it.getReceiverTypeReference() == null }
     }
 
     public fun getTopLevelCallables(nameFilter: (String) -> Boolean): Collection<CallableDescriptor> {
@@ -92,7 +92,7 @@ public class KotlinIndicesHelper(
     public fun getCallableTopLevelExtensions(
             nameFilter: (String) -> Boolean,
             callTypeAndReceiver: CallTypeAndReceiver<*, *>,
-            position: JetExpression,
+            position: KtExpression,
             bindingContext: BindingContext
     ): Collection<CallableDescriptor> {
         val receiverTypes = callTypeAndReceiver.receiverTypes(bindingContext, position, moduleDescriptor, predictableSmartCastsOnly = false)
@@ -114,7 +114,7 @@ public class KotlinIndicesHelper(
         return findSuitableExtensions(declarations, receiverTypes, callTypeAndReceiver.callType)
     }
 
-    private fun MutableCollection<String>.addTypeNames(type: JetType) {
+    private fun MutableCollection<String>.addTypeNames(type: KtType) {
         val constructor = type.getConstructor()
         addIfNotNull(constructor.getDeclarationDescriptor()?.getName()?.asString())
         constructor.getSupertypes().forEach { addTypeNames(it) }
@@ -124,8 +124,8 @@ public class KotlinIndicesHelper(
      * Check that function or property with the given qualified name can be resolved in given scope and called on given receiver
      */
     private fun findSuitableExtensions(
-            declarations: Sequence<JetCallableDeclaration>,
-            receiverTypes: Collection<JetType>,
+            declarations: Sequence<KtCallableDeclaration>,
+            receiverTypes: Collection<KtType>,
             callType: CallType<*>
     ): Collection<CallableDescriptor> {
         val result = LinkedHashSet<CallableDescriptor>()
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinNameSuggester.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinNameSuggester.kt
index 9795048a3a6..2bc3874a075 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinNameSuggester.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinNameSuggester.kt
@@ -18,14 +18,14 @@ package org.jetbrains.kotlin.idea.core
 
 import com.intellij.openapi.util.text.StringUtil
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.lexer.JetLexer
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KotlinLexer
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.typeUtil.builtIns
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.decapitalizeSmart
 import java.util.*
@@ -33,7 +33,7 @@ import java.util.regex.Pattern
 
 public object KotlinNameSuggester {
 
-    public fun suggestNamesByExpressionAndType(expression: JetExpression, bindingContext: BindingContext, validator: (String) -> Boolean, defaultName: String?): Collection<String> {
+    public fun suggestNamesByExpressionAndType(expression: KtExpression, bindingContext: BindingContext, validator: (String) -> Boolean, defaultName: String?): Collection<String> {
         val result = LinkedHashSet<String>()
 
         result.addNamesByExpression(expression, validator)
@@ -50,7 +50,7 @@ public object KotlinNameSuggester {
         return result
     }
 
-    public fun suggestNamesByType(type: JetType, validator: (String) -> Boolean, defaultName: String? = null): List<String> {
+    public fun suggestNamesByType(type: KtType, validator: (String) -> Boolean, defaultName: String? = null): List<String> {
         val result = ArrayList<String>()
 
         result.addNamesByType(type, validator)
@@ -62,7 +62,7 @@ public object KotlinNameSuggester {
         return result
     }
 
-    public fun suggestNamesByExpressionOnly(expression: JetExpression, validator: (String) -> Boolean, defaultName: String? = null): List<String> {
+    public fun suggestNamesByExpressionOnly(expression: KtExpression, validator: (String) -> Boolean, defaultName: String? = null): List<String> {
         val result = ArrayList<String>()
 
         result.addNamesByExpression(expression, validator)
@@ -74,7 +74,7 @@ public object KotlinNameSuggester {
         return result
     }
 
-    public fun suggestIterationVariableNames(collection: JetExpression, elementType: JetType, validator: (String) -> Boolean, defaultName: String?): Collection<String> {
+    public fun suggestIterationVariableNames(collection: KtExpression, elementType: KtType, validator: (String) -> Boolean, defaultName: String?): Collection<String> {
         val result = LinkedHashSet<String>()
 
         suggestNamesByExpressionOnly(collection, { true })
@@ -133,10 +133,10 @@ public object KotlinNameSuggester {
         }
     }
 
-    private fun MutableCollection<String>.addNamesByType(type: JetType, validator: (String) -> Boolean) {
+    private fun MutableCollection<String>.addNamesByType(type: KtType, validator: (String) -> Boolean) {
         var type = TypeUtils.makeNotNullable(type) // wipe out '?'
         val builtIns = type.builtIns
-        val typeChecker = JetTypeChecker.DEFAULT
+        val typeChecker = KotlinTypeChecker.DEFAULT
         if (ErrorUtils.containsErrorType(type)) return
 
         if (typeChecker.equalTypes(builtIns.getBooleanType(), type)) {
@@ -261,18 +261,18 @@ public object KotlinNameSuggester {
         return matcher.replaceAll("")
     }
 
-    private fun MutableCollection<String>.addNamesByExpression(expression: JetExpression?, validator: (String) -> Boolean) {
+    private fun MutableCollection<String>.addNamesByExpression(expression: KtExpression?, validator: (String) -> Boolean) {
         if (expression == null) return
 
-        val expression = JetPsiUtil.safeDeparenthesize(expression)
+        val expression = KtPsiUtil.safeDeparenthesize(expression)
         when (expression) {
-            is JetSimpleNameExpression -> addCamelNames(expression.getReferencedName(), validator)
+            is KtSimpleNameExpression -> addCamelNames(expression.getReferencedName(), validator)
 
-            is JetQualifiedExpression -> addNamesByExpression(expression.getSelectorExpression(), validator)
+            is KtQualifiedExpression -> addNamesByExpression(expression.getSelectorExpression(), validator)
 
-            is JetCallExpression -> addNamesByExpression(expression.getCalleeExpression(), validator)
+            is KtCallExpression -> addNamesByExpression(expression.getCalleeExpression(), validator)
 
-            is JetPostfixExpression -> addNamesByExpression(expression.getBaseExpression(), validator)
+            is KtPostfixExpression -> addNamesByExpression(expression.getBaseExpression(), validator)
         }
     }
 
@@ -289,9 +289,9 @@ public object KotlinNameSuggester {
     public fun isIdentifier(name: String?): Boolean {
         if (name == null || name.isEmpty()) return false
 
-        val lexer = JetLexer()
+        val lexer = KotlinLexer()
         lexer.start(name, 0, name.length())
-        if (lexer.getTokenType() !== JetTokens.IDENTIFIER) return false
+        if (lexer.getTokenType() !== KtTokens.IDENTIFIER) return false
         lexer.advance()
         return lexer.getTokenType() == null
     }
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/NameValidators.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/NameValidators.kt
index 95de7cd2788..95eb3582627 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/NameValidators.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/NameValidators.kt
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 import org.jetbrains.kotlin.psi.psiUtil.siblings
 import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.utils.asJetScope
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import java.util.Collections
@@ -58,14 +58,14 @@ public class CollectingNameValidator @JvmOverloads constructor(
 }
 
 public class NewDeclarationNameValidator(
-        private val visibleDeclarationsContext: JetElement?,
+        private val visibleDeclarationsContext: KtElement?,
         private val checkDeclarationsIn: Sequence<PsiElement>,
         private val target: NewDeclarationNameValidator.Target
 ) : (String) -> Boolean {
 
     public constructor(container: PsiElement, anchor: PsiElement?, target: NewDeclarationNameValidator.Target)
         : this(
-            (anchor ?: container).parentsWithSelf.firstIsInstanceOrNull<JetElement>(),
+            (anchor ?: container).parentsWithSelf.firstIsInstanceOrNull<KtElement>(),
             anchor?.siblings() ?: container.allChildren,
             target)
 
@@ -84,11 +84,11 @@ public class NewDeclarationNameValidator(
         }
 
         return checkDeclarationsIn.none {
-            it.findDescendantOfType<JetNamedDeclaration> { it.isConflicting(identifier) } != null
+            it.findDescendantOfType<KtNamedDeclaration> { it.isConflicting(identifier) } != null
         }
     }
 
-    private fun JetScope.hasConflict(name: Name): Boolean {
+    private fun KtScope.hasConflict(name: Name): Boolean {
         val inDeclaration = getContainingDeclaration()
 
         fun DeclarationDescriptor.isVisible(): Boolean {
@@ -107,12 +107,12 @@ public class NewDeclarationNameValidator(
         }
     }
 
-    private fun JetNamedDeclaration.isConflicting(name: Name): Boolean {
+    private fun KtNamedDeclaration.isConflicting(name: Name): Boolean {
         if (getNameAsName() != name) return false
-        if (this is JetCallableDeclaration && getReceiverTypeReference() != null) return false
+        if (this is KtCallableDeclaration && getReceiverTypeReference() != null) return false
         return when(target) {
-            Target.VARIABLES -> this is JetVariableDeclaration
-            Target.FUNCTIONS_AND_CLASSES -> this is JetNamedFunction || this is JetClassOrObject
+            Target.VARIABLES -> this is KtVariableDeclaration
+            Target.FUNCTIONS_AND_CLASSES -> this is KtNamedFunction || this is KtClassOrObject
         }
     }
 }
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/OptionalParametersHelper.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/OptionalParametersHelper.kt
index 99d8054625b..c063479ef1b 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/OptionalParametersHelper.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/OptionalParametersHelper.kt
@@ -22,9 +22,9 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetParameter
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtParameter
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.ValueArgument
 import org.jetbrains.kotlin.psi.psiUtil.forEachDescendantOfType
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -74,10 +74,10 @@ public object OptionalParametersHelper {
         return argumentExpression.getText() == expression.getText() //TODO
     }
 
-    private fun DefaultValue.substituteArguments(resolvedCall: ResolvedCall<out CallableDescriptor>): JetExpression {
+    private fun DefaultValue.substituteArguments(resolvedCall: ResolvedCall<out CallableDescriptor>): KtExpression {
         if (parameterUsages.isEmpty()) return expression
 
-        val key = Key<JetExpression>("SUBSTITUTION")
+        val key = Key<KtExpression>("SUBSTITUTION")
 
         for ((parameter, usages) in parameterUsages) {
             val resolvedArgument = resolvedCall.getValueArguments()[parameter]!!
@@ -90,10 +90,10 @@ public object OptionalParametersHelper {
 
         var expressionCopy = expression.copied()
 
-        expression.forEachDescendantOfType<JetExpression> { it.putCopyableUserData(key, null) }
+        expression.forEachDescendantOfType<KtExpression> { it.putCopyableUserData(key, null) }
 
-        val replacements = ArrayList<Pair<JetExpression, JetExpression>>()
-        expressionCopy.forEachDescendantOfType<JetExpression> {
+        val replacements = ArrayList<Pair<KtExpression, KtExpression>>()
+        expressionCopy.forEachDescendantOfType<KtExpression> {
             val replacement = it.getCopyableUserData(key)
             if (replacement != null) {
                 replacements.add(it to replacement)
@@ -101,7 +101,7 @@ public object OptionalParametersHelper {
         }
 
         for ((expression, replacement) in replacements) {
-            val replaced = expression.replace(replacement) as JetExpression
+            val replaced = expression.replace(replacement) as KtExpression
             if (expression == expressionCopy) {
                 expressionCopy = replaced
             }
@@ -111,11 +111,11 @@ public object OptionalParametersHelper {
     }
 
     public data class DefaultValue(
-            public val expression: JetExpression,
-            public val parameterUsages: Map<ValueParameterDescriptor, Collection<JetExpression>>
+            public val expression: KtExpression,
+            public val parameterUsages: Map<ValueParameterDescriptor, Collection<KtExpression>>
     )
 
-    public fun defaultParameterValueExpression(parameter: ValueParameterDescriptor, project: Project): JetExpression? {
+    public fun defaultParameterValueExpression(parameter: ValueParameterDescriptor, project: Project): KtExpression? {
         if (!parameter.hasDefaultValue()) return null
 
         if (!parameter.declaresDefaultValue()) {
@@ -125,7 +125,7 @@ public object OptionalParametersHelper {
 
         //TODO: parameter in overriding method!
         //TODO: it's a temporary code while we don't have default values accessible from descriptors
-        val declaration = DescriptorToSourceUtilsIde.getAnyDeclaration(project, parameter)?.getNavigationElement() as? JetParameter
+        val declaration = DescriptorToSourceUtilsIde.getAnyDeclaration(project, parameter)?.getNavigationElement() as? KtParameter
         return declaration?.defaultValue
     }
 
@@ -136,10 +136,10 @@ public object OptionalParametersHelper {
 
         val allParameters = parameter.getContainingDeclaration().getValueParameters().toSet()
 
-        val parameterUsages = HashMap<ValueParameterDescriptor, MutableCollection<JetExpression>>()
+        val parameterUsages = HashMap<ValueParameterDescriptor, MutableCollection<KtExpression>>()
 
         val bindingContext = expression.analyze(BodyResolveMode.PARTIAL)
-        expression.forEachDescendantOfType<JetSimpleNameExpression> {
+        expression.forEachDescendantOfType<KtSimpleNameExpression> {
             val target = bindingContext[BindingContext.REFERENCE_TARGET, it]
             if (target is ValueParameterDescriptor && target in allParameters) {
                 parameterUsages.getOrPut(target) { ArrayList() }.add(it)
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/Utils.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/Utils.kt
index 42d09667578..547065e34c1 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/Utils.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/Utils.kt
@@ -41,13 +41,13 @@ import org.jetbrains.kotlin.resolve.calls.context.CheckArgumentTypesMode
 import org.jetbrains.kotlin.resolve.calls.context.ContextDependency
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus
-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.resolve.scopes.receivers.ThisReceiver
 import org.jetbrains.kotlin.resolve.scopes.utils.asJetScope
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
 import java.util.*
@@ -93,7 +93,7 @@ public fun Call.mapArgumentsToParameters(targetDescriptor: CallableDescriptor):
     return map
 }
 
-public fun ThisReceiver.asExpression(resolutionScope: JetScope, psiFactory: JetPsiFactory): JetExpression? {
+public fun ThisReceiver.asExpression(resolutionScope: KtScope, psiFactory: KtPsiFactory): KtExpression? {
     val expressionFactory = resolutionScope.getImplicitReceiversWithInstanceToExpression()
                                     .entrySet()
                                     .firstOrNull { it.key.getContainingDeclaration() == this.getDeclarationDescriptor() }
@@ -103,34 +103,34 @@ public fun ThisReceiver.asExpression(resolutionScope: JetScope, psiFactory: JetP
 
 public fun PsiElement.getResolutionScope(bindingContext: BindingContext, resolutionFacade: ResolutionFacade): LexicalScope {
     for (parent in parentsWithSelf) {
-        if (parent is JetElement) {
+        if (parent is KtElement) {
             val scope = bindingContext[BindingContext.LEXICAL_SCOPE, parent]
             if (scope != null) return scope
         }
 
-        if (parent is JetClassBody) {
+        if (parent is KtClassBody) {
             val classDescriptor = bindingContext[BindingContext.CLASS, parent.getParent()] as? ClassDescriptorWithResolutionScopes
             if (classDescriptor != null) {
                 return classDescriptor.getScopeForMemberDeclarationResolution()
             }
         }
 
-        if (parent is JetFile) {
+        if (parent is KtFile) {
             return resolutionFacade.getFileTopLevelScope(parent)
         }
     }
     error("Not in JetFile")
 }
 
-public fun JetImportDirective.targetDescriptors(): Collection<DeclarationDescriptor> {
-    val nameExpression = importedReference?.getQualifiedElementSelector() as? JetSimpleNameExpression ?: return emptyList()
+public fun KtImportDirective.targetDescriptors(): Collection<DeclarationDescriptor> {
+    val nameExpression = importedReference?.getQualifiedElementSelector() as? KtSimpleNameExpression ?: return emptyList()
     return nameExpression.mainReference.resolveToDescriptors(nameExpression.analyze())
 }
 
 public fun Call.resolveCandidates(
         bindingContext: BindingContext,
         resolutionFacade: ResolutionFacade,
-        expectedType: JetType = expectedType(this, bindingContext),
+        expectedType: KtType = expectedType(this, bindingContext),
         filterOutWrongReceiver: Boolean = true,
         filterOutByVisibility: Boolean = true
 ): Collection<ResolvedCall<FunctionDescriptor>> {
@@ -150,7 +150,7 @@ public fun Call.resolveCandidates(
 
     var candidates = results.allCandidates!!
 
-    if (callElement is JetConstructorDelegationCall) { // for "this(...)" delegation call exclude caller from candidates
+    if (callElement is KtConstructorDelegationCall) { // for "this(...)" delegation call exclude caller from candidates
         inDescriptor as ConstructorDescriptor
         candidates = candidates.filter { it.resultingDescriptor.original != inDescriptor.original }
     }
@@ -169,17 +169,17 @@ public fun Call.resolveCandidates(
     return candidates
 }
 
-private fun expectedType(call: Call, bindingContext: BindingContext): JetType {
-    return (call.callElement as? JetExpression)?.let {
+private fun expectedType(call: Call, bindingContext: BindingContext): KtType {
+    return (call.callElement as? KtExpression)?.let {
         bindingContext[BindingContext.EXPECTED_EXPRESSION_TYPE, it.getQualifiedExpressionForSelectorOrThis()]
     } ?: TypeUtils.NO_EXPECTED_TYPE
 }
 
-fun JetCallableDeclaration.canOmitDeclaredType(initializerOrBodyExpression: JetExpression, canChangeTypeToSubtype: Boolean): Boolean {
+fun KtCallableDeclaration.canOmitDeclaredType(initializerOrBodyExpression: KtExpression, canChangeTypeToSubtype: Boolean): Boolean {
     val declaredType = (resolveToDescriptor() as? CallableDescriptor)?.returnType ?: return false
     val bindingContext = initializerOrBodyExpression.analyze()
     val scope = initializerOrBodyExpression.getResolutionScope(bindingContext, initializerOrBodyExpression.getResolutionFacade()).asJetScope()
     val expressionType = initializerOrBodyExpression.computeTypeInContext(scope) ?: return false
-    if (JetTypeChecker.DEFAULT.equalTypes(expressionType, declaredType)) return true
+    if (KotlinTypeChecker.DEFAULT.equalTypes(expressionType, declaredType)) return true
     return canChangeTypeToSubtype && expressionType.isSubtypeOf(declaredType)
 }
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/descriptorUtils.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/descriptorUtils.kt
index 2591bba7a4f..a9d5207d5fd 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/descriptorUtils.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/descriptorUtils.kt
@@ -20,9 +20,9 @@ import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.psiUtil.getReceiverExpression
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.OverridingUtil
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
 fun DeclarationDescriptorWithVisibility.isVisible(
         from: DeclarationDescriptor,
         bindingContext: BindingContext? = null,
-        element: JetSimpleNameExpression? = null
+        element: KtSimpleNameExpression? = null
 ): Boolean {
     if (Visibilities.isVisible(ReceiverValue.IRRELEVANT_RECEIVER, this, from)) return true
     if (bindingContext == null || element == null) return false
@@ -97,15 +97,15 @@ public fun compareDescriptors(project: Project, currentDescriptor: DeclarationDe
     return false
 }
 
-public fun Visibility.toKeywordToken(): JetModifierKeywordToken {
+public fun Visibility.toKeywordToken(): KtModifierKeywordToken {
     val normalized = normalize()
     when (normalized) {
-        Visibilities.PUBLIC -> return JetTokens.PUBLIC_KEYWORD
-        Visibilities.PROTECTED -> return JetTokens.PROTECTED_KEYWORD
-        Visibilities.INTERNAL -> return JetTokens.INTERNAL_KEYWORD
+        Visibilities.PUBLIC -> return KtTokens.PUBLIC_KEYWORD
+        Visibilities.PROTECTED -> return KtTokens.PROTECTED_KEYWORD
+        Visibilities.INTERNAL -> return KtTokens.INTERNAL_KEYWORD
         else -> {
             if (Visibilities.isPrivate(normalized)) {
-                return JetTokens.PRIVATE_KEYWORD
+                return KtTokens.PRIVATE_KEYWORD
             }
             error("Unexpected visibility '$normalized'")
         }
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideImplementMembersHandler.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideImplementMembersHandler.kt
index cdafa0b3eec..4731e65528a 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideImplementMembersHandler.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideImplementMembersHandler.kt
@@ -28,13 +28,13 @@ import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.quickfix.insertMembersAfter
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 
 public abstract class OverrideImplementMembersHandler : LanguageCodeInsightActionHandler {
 
-    public fun collectMembersToGenerate(classOrObject: JetClassOrObject): Collection<OverrideMemberChooserObject> {
+    public fun collectMembersToGenerate(classOrObject: KtClassOrObject): Collection<OverrideMemberChooserObject> {
         val descriptor = classOrObject.resolveToDescriptor() as? ClassDescriptor ?: return emptySet()
         return collectMembersToGenerate(descriptor, classOrObject.project)
     }
@@ -52,9 +52,9 @@ public abstract class OverrideImplementMembersHandler : LanguageCodeInsightActio
     protected abstract fun getChooserTitle(): String
 
     override fun isValidFor(editor: Editor, file: PsiFile): Boolean {
-        if (file !is JetFile) return false
+        if (file !is KtFile) return false
         val elementAtCaret = file.findElementAt(editor.caretModel.offset)
-        val classOrObject = elementAtCaret?.getNonStrictParentOfType<JetClassOrObject>()
+        val classOrObject = elementAtCaret?.getNonStrictParentOfType<KtClassOrObject>()
         return classOrObject != null
     }
 
@@ -62,7 +62,7 @@ public abstract class OverrideImplementMembersHandler : LanguageCodeInsightActio
 
     public fun invoke(project: Project, editor: Editor, file: PsiFile, implementAll: Boolean) {
         val elementAtCaret = file.findElementAt(editor.caretModel.offset)
-        val classOrObject = elementAtCaret?.getNonStrictParentOfType<JetClassOrObject>()!!
+        val classOrObject = elementAtCaret?.getNonStrictParentOfType<KtClassOrObject>()!!
 
         val members = collectMembersToGenerate(classOrObject)
         if (members.isEmpty() && !implementAll) {
@@ -91,7 +91,7 @@ public abstract class OverrideImplementMembersHandler : LanguageCodeInsightActio
     override fun startInWriteAction(): Boolean = false
 
     companion object {
-        public fun generateMembers(editor: Editor, classOrObject: JetClassOrObject, selectedElements: Collection<OverrideMemberChooserObject>) {
+        public fun generateMembers(editor: Editor, classOrObject: KtClassOrObject, selectedElements: Collection<OverrideMemberChooserObject>) {
             val project = classOrObject.project
             insertMembersAfter(editor, classOrObject, selectedElements.map { it.generateMember(project) })
         }
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideMemberChooserObject.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideMemberChooserObject.kt
index dfd03ef3511..7bba25ebd82 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideMemberChooserObject.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideMemberChooserObject.kt
@@ -76,7 +76,7 @@ interface OverrideMemberChooserObject : ClassMember {
     }
 }
 
-fun OverrideMemberChooserObject.generateMember(project: Project, asConstructorParameter: Boolean = false): JetCallableDeclaration {
+fun OverrideMemberChooserObject.generateMember(project: Project, asConstructorParameter: Boolean = false): KtCallableDeclaration {
     val descriptor = immediateSuper
     if (asConstructorParameter) {
         assert(descriptor is PropertyDescriptor) { "asConstructorParameter is valid only for PropertyDescriptor" }
@@ -100,7 +100,7 @@ private val OVERRIDE_RENDERER = DescriptorRenderer.withOptions {
     typeNormalizer = IdeDescriptorRenderers.APPROXIMATE_FLEXIBLE_TYPES
 }
 
-private fun generateProperty(project: Project, descriptor: PropertyDescriptor, bodyType: OverrideMemberChooserObject.BodyType): JetProperty {
+private fun generateProperty(project: Project, descriptor: PropertyDescriptor, bodyType: OverrideMemberChooserObject.BodyType): KtProperty {
     val newDescriptor = descriptor.copy(descriptor.containingDeclaration, Modality.OPEN, descriptor.visibility,
                                         descriptor.kind, /* copyOverrides = */ true) as PropertyDescriptor
     newDescriptor.addOverriddenDescriptor(descriptor)
@@ -113,17 +113,17 @@ private fun generateProperty(project: Project, descriptor: PropertyDescriptor, b
             append("\nset(value) {}")
         }
     }
-    return JetPsiFactory(project).createProperty(OVERRIDE_RENDERER.render(newDescriptor) + body)
+    return KtPsiFactory(project).createProperty(OVERRIDE_RENDERER.render(newDescriptor) + body)
 }
 
-private fun generateConstructorParameter(project: Project, descriptor: PropertyDescriptor): JetParameter {
+private fun generateConstructorParameter(project: Project, descriptor: PropertyDescriptor): KtParameter {
     val newDescriptor = descriptor.copy(descriptor.containingDeclaration, Modality.OPEN, descriptor.visibility,
                                         descriptor.kind, /* copyOverrides = */ true) as PropertyDescriptor
     newDescriptor.addOverriddenDescriptor(descriptor)
-    return JetPsiFactory(project).createParameter(OVERRIDE_RENDERER.render(newDescriptor))
+    return KtPsiFactory(project).createParameter(OVERRIDE_RENDERER.render(newDescriptor))
 }
 
-private fun generateFunction(project: Project, descriptor: FunctionDescriptor, bodyType: OverrideMemberChooserObject.BodyType): JetNamedFunction {
+private fun generateFunction(project: Project, descriptor: FunctionDescriptor, bodyType: OverrideMemberChooserObject.BodyType): KtNamedFunction {
     val newDescriptor = descriptor.copy(descriptor.containingDeclaration, Modality.OPEN, descriptor.visibility,
                                         descriptor.kind, /* copyOverrides = */ true)
     newDescriptor.addOverriddenDescriptor(descriptor)
@@ -135,7 +135,7 @@ private fun generateFunction(project: Project, descriptor: FunctionDescriptor, b
 
     val body = "{" + (if (returnsNotUnit && bodyType != OverrideMemberChooserObject.BodyType.EMPTY) "return " else "") + delegation + "}"
 
-    return JetPsiFactory(project).createFunction(OVERRIDE_RENDERER.render(newDescriptor) + body)
+    return KtPsiFactory(project).createFunction(OVERRIDE_RENDERER.render(newDescriptor) + body)
 }
 
 public fun generateUnsupportedOrSuperCall(descriptor: CallableMemberDescriptor, bodyType: OverrideMemberChooserObject.BodyType): String {
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/packageUtils.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/packageUtils.kt
index b24329b45f1..cd5531ee625 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/packageUtils.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/packageUtils.kt
@@ -21,7 +21,7 @@ import com.intellij.psi.PsiDirectory
 import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiPackage
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
 public fun PsiDirectory.getPackage(): PsiPackage? = JavaDirectoryService.getInstance()!!.getPackage(this)
 
@@ -30,4 +30,4 @@ public fun PsiFile.getFqNameByDirectory(): FqName {
     return qualifiedNameByDirectory?.let { FqName(it) } ?: FqName.ROOT
 }
 
-public fun JetFile.packageMatchesDirectory(): Boolean = getPackageFqName() == getFqNameByDirectory()
\ No newline at end of file
+public fun KtFile.packageMatchesDirectory(): Boolean = getPackageFqName() == getFqNameByDirectory()
\ No newline at end of file
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiClassToDescriptor.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiClassToDescriptor.kt
index 7682de8c63b..edd18d5baa7 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiClassToDescriptor.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiClassToDescriptor.kt
@@ -23,12 +23,12 @@ import org.jetbrains.kotlin.idea.caches.resolve.KotlinLightClassForDecompiledDec
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.resolve.frontendService
 import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 
 public fun ResolutionFacade.psiClassToDescriptor(
         psiClass: PsiClass,
-        declarationTranslator: (JetClassOrObject) -> JetClassOrObject? = { it }
+        declarationTranslator: (KtClassOrObject) -> KtClassOrObject? = { it }
 ): ClassifierDescriptor? {
     return if (psiClass is KotlinLightClass && psiClass !is KotlinLightClassForDecompiledDeclaration) {
         val origin = psiClass.getOrigin () ?: return null
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiModificationUtils.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiModificationUtils.kt
index 10736d22be6..17b0ef97910 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiModificationUtils.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiModificationUtils.kt
@@ -22,8 +22,8 @@ import com.intellij.psi.impl.source.codeStyle.CodeEditUtil
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getFunctionLiteralArgumentName
@@ -38,29 +38,29 @@ public inline fun <reified T: PsiElement> PsiElement.replaced(newElement: T): T
     return if (result is T)
         result
     else
-        (result as JetParenthesizedExpression).getExpression() as T
+        (result as KtParenthesizedExpression).getExpression() as T
 }
 
 @Suppress("UNCHECKED_CAST")
 public fun <T: PsiElement> T.copied(): T = copy() as T
 
-public fun JetFunctionLiteralArgument.moveInsideParentheses(bindingContext: BindingContext): JetCallExpression {
+public fun KtFunctionLiteralArgument.moveInsideParentheses(bindingContext: BindingContext): KtCallExpression {
     return moveInsideParenthesesAndReplaceWith(this.getArgumentExpression(), bindingContext)
 }
 
-public fun JetFunctionLiteralArgument.moveInsideParenthesesAndReplaceWith(
-        replacement: JetExpression,
+public fun KtFunctionLiteralArgument.moveInsideParenthesesAndReplaceWith(
+        replacement: KtExpression,
         bindingContext: BindingContext
-): JetCallExpression = moveInsideParenthesesAndReplaceWith(replacement, getFunctionLiteralArgumentName(bindingContext))
+): KtCallExpression = moveInsideParenthesesAndReplaceWith(replacement, getFunctionLiteralArgumentName(bindingContext))
 
-public fun JetFunctionLiteralArgument.moveInsideParenthesesAndReplaceWith(
-        replacement: JetExpression,
+public fun KtFunctionLiteralArgument.moveInsideParenthesesAndReplaceWith(
+        replacement: KtExpression,
         functionLiteralArgumentName: Name?
-): JetCallExpression {
-    val oldCallExpression = getParent() as JetCallExpression
-    val newCallExpression = oldCallExpression.copy() as JetCallExpression
+): KtCallExpression {
+    val oldCallExpression = getParent() as KtCallExpression
+    val newCallExpression = oldCallExpression.copy() as KtCallExpression
 
-    val psiFactory = JetPsiFactory(getProject())
+    val psiFactory = KtPsiFactory(getProject())
     val argument = if (newCallExpression.getValueArgumentsInParentheses().any { it.isNamed() }) {
         psiFactory.createArgument(replacement, functionLiteralArgumentName)
     }
@@ -80,17 +80,17 @@ public fun JetFunctionLiteralArgument.moveInsideParenthesesAndReplaceWith(
     else {
         functionLiteralArgument.replace(valueArgumentList)
     }
-    return oldCallExpression.replace(newCallExpression) as JetCallExpression
+    return oldCallExpression.replace(newCallExpression) as KtCallExpression
 }
 
-public fun JetCallExpression.moveFunctionLiteralOutsideParentheses() {
+public fun KtCallExpression.moveFunctionLiteralOutsideParentheses() {
     assert(getFunctionLiteralArguments().isEmpty())
     val argumentList = getValueArgumentList()!!
     val argument = argumentList.getArguments().last()
     val expression = argument.getArgumentExpression()!!
     assert(expression.unpackFunctionLiteral() != null)
 
-    val dummyCall = JetPsiFactory(this).createExpressionByPattern("foo()$0:'{}'", expression) as JetCallExpression
+    val dummyCall = KtPsiFactory(this).createExpressionByPattern("foo()$0:'{}'", expression) as KtCallExpression
     val functionLiteralArgument = dummyCall.getFunctionLiteralArguments().single()
     this.add(functionLiteralArgument)
     if (argumentList.getArguments().size() > 1) {
@@ -101,9 +101,9 @@ public fun JetCallExpression.moveFunctionLiteralOutsideParentheses() {
     }
 }
 
-public fun JetBlockExpression.appendElement(element: JetElement, addNewLine: Boolean = false): JetElement {
+public fun KtBlockExpression.appendElement(element: KtElement, addNewLine: Boolean = false): KtElement {
     val rBrace = getRBrace()
-    val newLine = JetPsiFactory(this).createNewLine()
+    val newLine = KtPsiFactory(this).createNewLine()
     val anchor = if (rBrace == null) {
         val lastChild = getLastChild()
         if (lastChild !is PsiWhiteSpace) addAfter(newLine, lastChild)!! else lastChild
@@ -111,7 +111,7 @@ public fun JetBlockExpression.appendElement(element: JetElement, addNewLine: Boo
     else {
         rBrace.getPrevSibling()!!
     }
-    val addedElement = addAfter(element, anchor)!! as JetElement
+    val addedElement = addAfter(element, anchor)!! as KtElement
     if (addNewLine) {
         addAfter(newLine, addedElement)
     }
@@ -159,21 +159,21 @@ public fun PsiElement.deleteSingle() {
     CodeEditUtil.removeChild(getParent()?.getNode() ?: return, getNode() ?: return)
 }
 
-public fun JetClass.getOrCreateCompanionObject() : JetObjectDeclaration {
+public fun KtClass.getOrCreateCompanionObject() : KtObjectDeclaration {
     getCompanionObjects().firstOrNull()?.let { return it }
-    return addDeclaration(JetPsiFactory(this).createCompanionObject()) as JetObjectDeclaration
+    return addDeclaration(KtPsiFactory(this).createCompanionObject()) as KtObjectDeclaration
 }
 
 //TODO: code style option whether to insert redundant 'public' keyword or not
-public fun JetDeclaration.setVisibility(visibilityModifier: JetModifierKeywordToken) {
-    val defaultVisibilityKeyword = if (hasModifier(JetTokens.OVERRIDE_KEYWORD)) {
+public fun KtDeclaration.setVisibility(visibilityModifier: KtModifierKeywordToken) {
+    val defaultVisibilityKeyword = if (hasModifier(KtTokens.OVERRIDE_KEYWORD)) {
         (resolveToDescriptor() as? CallableMemberDescriptor)
                 ?.overriddenDescriptors
                 ?.let { OverridingUtil.findMaxVisibility(it) }
                 ?.toKeywordToken()
     }
     else {
-        JetTokens.DEFAULT_VISIBILITY_KEYWORD
+        KtTokens.DEFAULT_VISIBILITY_KEYWORD
     }
 
     if (visibilityModifier == defaultVisibilityKeyword) {
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/quickfix/QuickFixUtil.java b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/quickfix/QuickFixUtil.java
index 6ef41f9f4e6..a67cd138f10 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/quickfix/QuickFixUtil.java
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/quickfix/QuickFixUtil.java
@@ -37,8 +37,8 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.types.DeferredType;
-import org.jetbrains.kotlin.types.JetType;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.KtType;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 public class QuickFixUtil {
     private QuickFixUtil() {
@@ -58,12 +58,12 @@ public class QuickFixUtil {
     }
 
     @Nullable
-    public static JetType getDeclarationReturnType(JetNamedDeclaration declaration) {
+    public static KtType getDeclarationReturnType(KtNamedDeclaration declaration) {
         PsiFile file = declaration.getContainingFile();
-        if (!(file instanceof JetFile)) return null;
+        if (!(file instanceof KtFile)) return null;
         DeclarationDescriptor descriptor = ResolutionUtils.resolveToDescriptor(declaration);
         if (!(descriptor instanceof CallableDescriptor)) return null;
-        JetType type = ((CallableDescriptor) descriptor).getReturnType();
+        KtType type = ((CallableDescriptor) descriptor).getReturnType();
         if (type instanceof DeferredType) {
             type = ((DeferredType) type).getDelegate();
         }
@@ -71,17 +71,17 @@ public class QuickFixUtil {
     }
 
     @Nullable
-    public static JetType findLowerBoundOfOverriddenCallablesReturnTypes(@NotNull CallableDescriptor descriptor) {
-        JetType matchingReturnType = null;
+    public static KtType findLowerBoundOfOverriddenCallablesReturnTypes(@NotNull CallableDescriptor descriptor) {
+        KtType matchingReturnType = null;
         for (CallableDescriptor overriddenDescriptor : ((CallableDescriptor) descriptor).getOverriddenDescriptors()) {
-            JetType overriddenReturnType = overriddenDescriptor.getReturnType();
+            KtType overriddenReturnType = overriddenDescriptor.getReturnType();
             if (overriddenReturnType == null) {
                 return null;
             }
-            if (matchingReturnType == null || JetTypeChecker.DEFAULT.isSubtypeOf(overriddenReturnType, matchingReturnType)) {
+            if (matchingReturnType == null || KotlinTypeChecker.DEFAULT.isSubtypeOf(overriddenReturnType, matchingReturnType)) {
                 matchingReturnType = overriddenReturnType;
             }
-            else if (!JetTypeChecker.DEFAULT.isSubtypeOf(matchingReturnType, overriddenReturnType)) {
+            else if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(matchingReturnType, overriddenReturnType)) {
                 return null;
             }
         }
@@ -100,23 +100,23 @@ public class QuickFixUtil {
     }
 
     @Nullable
-    public static JetParameter getParameterDeclarationForValueArgument(
+    public static KtParameter getParameterDeclarationForValueArgument(
             @NotNull ResolvedCall<?> resolvedCall,
             @Nullable ValueArgument valueArgument
     ) {
         PsiElement declaration = safeGetDeclaration(CallUtilKt.getParameterForArgument(resolvedCall, valueArgument));
-        return declaration instanceof JetParameter ? (JetParameter) declaration : null;
+        return declaration instanceof KtParameter ? (KtParameter) declaration : null;
     }
 
-    private static boolean equalOrLastInThenOrElse(JetExpression thenOrElse, JetExpression expression) {
+    private static boolean equalOrLastInThenOrElse(KtExpression thenOrElse, KtExpression expression) {
         if (thenOrElse == expression) return true;
-        return thenOrElse instanceof JetBlockExpression && expression.getParent() == thenOrElse &&
-               PsiTreeUtil.getNextSiblingOfType(expression, JetExpression.class) == null;
+        return thenOrElse instanceof KtBlockExpression && expression.getParent() == thenOrElse &&
+               PsiTreeUtil.getNextSiblingOfType(expression, KtExpression.class) == null;
     }
 
     @Nullable
-    public static JetIfExpression getParentIfForBranch(@Nullable JetExpression expression) {
-        JetIfExpression ifExpression = PsiTreeUtil.getParentOfType(expression, JetIfExpression.class, true);
+    public static KtIfExpression getParentIfForBranch(@Nullable KtExpression expression) {
+        KtIfExpression ifExpression = PsiTreeUtil.getParentOfType(expression, KtIfExpression.class, true);
         if (ifExpression == null) return null;
         if (equalOrLastInThenOrElse(ifExpression.getThen(), expression)
             || equalOrLastInThenOrElse(ifExpression.getElse(), expression)) {
@@ -125,13 +125,13 @@ public class QuickFixUtil {
         return null;
     }
 
-    public static boolean canEvaluateTo(JetExpression parent, JetExpression child) {
+    public static boolean canEvaluateTo(KtExpression parent, KtExpression child) {
         if (parent == null || child == null) {
             return false;
         }
         while (parent != child) {
-            if (child.getParent() instanceof JetParenthesizedExpression) {
-                child = (JetExpression) child.getParent();
+            if (child.getParent() instanceof KtParenthesizedExpression) {
+                child = (KtExpression) child.getParent();
                 continue;
             }
             child = getParentIfForBranch(child);
@@ -140,22 +140,22 @@ public class QuickFixUtil {
         return true;
     }
 
-    public static boolean canFunctionOrGetterReturnExpression(@NotNull JetDeclaration functionOrGetter, @NotNull JetExpression expression) {
-        if (functionOrGetter instanceof JetFunctionLiteral) {
-            JetBlockExpression functionLiteralBody = ((JetFunctionLiteral) functionOrGetter).getBodyExpression();
+    public static boolean canFunctionOrGetterReturnExpression(@NotNull KtDeclaration functionOrGetter, @NotNull KtExpression expression) {
+        if (functionOrGetter instanceof KtFunctionLiteral) {
+            KtBlockExpression functionLiteralBody = ((KtFunctionLiteral) functionOrGetter).getBodyExpression();
             PsiElement returnedElement = functionLiteralBody == null ? null : functionLiteralBody.getLastChild();
-            return returnedElement instanceof JetExpression && canEvaluateTo((JetExpression) returnedElement, expression);
+            return returnedElement instanceof KtExpression && canEvaluateTo((KtExpression) returnedElement, expression);
         }
         else {
-            if (functionOrGetter instanceof JetWithExpressionInitializer && canEvaluateTo(((JetWithExpressionInitializer) functionOrGetter).getInitializer(), expression)) {
+            if (functionOrGetter instanceof KtWithExpressionInitializer && canEvaluateTo(((KtWithExpressionInitializer) functionOrGetter).getInitializer(), expression)) {
                 return true;
             }
-            JetReturnExpression returnExpression = PsiTreeUtil.getParentOfType(expression, JetReturnExpression.class);
+            KtReturnExpression returnExpression = PsiTreeUtil.getParentOfType(expression, KtReturnExpression.class);
             return returnExpression != null && canEvaluateTo(returnExpression.getReturnedExpression(), expression);
         }
     }
 
-    public static String renderTypeWithFqNameOnClash(JetType type, String nameToCheckAgainst) {
+    public static String renderTypeWithFqNameOnClash(KtType type, String nameToCheckAgainst) {
         FqName typeFqName = DescriptorUtils.getFqNameSafe(DescriptorUtils.getClassDescriptorForType(type));
         FqName fqNameToCheckAgainst = new FqName(nameToCheckAgainst);
         DescriptorRenderer renderer = typeFqName.shortName().equals(fqNameToCheckAgainst.shortName())
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/util/DescriptorMemberChooserObject.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/util/DescriptorMemberChooserObject.kt
index c9091b5baee..955f91d2953 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/util/DescriptorMemberChooserObject.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/util/DescriptorMemberChooserObject.kt
@@ -27,10 +27,10 @@ import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.JetDescriptorIconProvider
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.NameShortness
 import org.jetbrains.kotlin.renderer.render
@@ -45,16 +45,16 @@ public open class DescriptorMemberChooserObject(
     override fun getParentNodeDelegate(): MemberChooserObject {
         val parent = descriptor.containingDeclaration ?: error("No parent for $descriptor")
 
-        val declaration = if (psiElement is JetDeclaration) { // kotlin
-            PsiTreeUtil.getStubOrPsiParentOfType(psiElement, javaClass<JetNamedDeclaration>())
-                ?: PsiTreeUtil.getStubOrPsiParentOfType(psiElement, javaClass<JetFile>())
+        val declaration = if (psiElement is KtDeclaration) { // kotlin
+            PsiTreeUtil.getStubOrPsiParentOfType(psiElement, javaClass<KtNamedDeclaration>())
+                ?: PsiTreeUtil.getStubOrPsiParentOfType(psiElement, javaClass<KtFile>())
         }
         else { // java or compiled
             (psiElement as PsiMember).containingClass
         } ?: error("No parent for $psiElement")
 
         return when (declaration) {
-            is JetFile -> PsiElementMemberChooserObject(declaration, declaration.name)
+            is KtFile -> PsiElementMemberChooserObject(declaration, declaration.name)
             else -> DescriptorMemberChooserObject(declaration, parent)
         }
     }
@@ -82,9 +82,9 @@ public open class DescriptorMemberChooserObject(
 
         public fun getIcon(declaration: PsiElement?, descriptor: DeclarationDescriptor): Icon {
             if (declaration != null && declaration.isValid) {
-                val isClass = declaration is PsiClass || declaration is JetClass
+                val isClass = declaration is PsiClass || declaration is KtClass
                 val flags = if (isClass) 0 else Iconable.ICON_FLAG_VISIBILITY
-                if (declaration is JetDeclaration) {
+                if (declaration is KtDeclaration) {
                     // kotlin declaration
                     // visibility and abstraction better detect by a descriptor
                     return JetDescriptorIconProvider.getIcon(descriptor, declaration, flags)
diff --git a/idea/idea-repl/src/org/jetbrains/kotlin/console/KotlinConsoleRunner.kt b/idea/idea-repl/src/org/jetbrains/kotlin/console/KotlinConsoleRunner.kt
index 488ecb3fa73..63ec3c6034f 100644
--- a/idea/idea-repl/src/org/jetbrains/kotlin/console/KotlinConsoleRunner.kt
+++ b/idea/idea-repl/src/org/jetbrains/kotlin/console/KotlinConsoleRunner.kt
@@ -55,7 +55,7 @@ import org.jetbrains.kotlin.console.highlight.KotlinReplOutputHighlighter
 import org.jetbrains.kotlin.console.highlight.ReplColors
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.completion.doNotComplete
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import java.awt.Color
 import java.awt.Font
 import kotlin.properties.Delegates
@@ -162,7 +162,7 @@ public class KotlinConsoleRunner(
 
     private fun disableCompletion(consoleView: LanguageConsoleView) {
         val consoleFile = consoleView.virtualFile
-        val jetFile = PsiManager.getInstance(project).findFile(consoleFile) as? JetFile ?: return
+        val jetFile = PsiManager.getInstance(project).findFile(consoleFile) as? KtFile ?: return
         jetFile.doNotComplete = true
     }
 
diff --git a/idea/idea-repl/src/org/jetbrains/kotlin/console/gutter/ReplIcons.kt b/idea/idea-repl/src/org/jetbrains/kotlin/console/gutter/ReplIcons.kt
index 0553ac38389..dd1a6436868 100644
--- a/idea/idea-repl/src/org/jetbrains/kotlin/console/gutter/ReplIcons.kt
+++ b/idea/idea-repl/src/org/jetbrains/kotlin/console/gutter/ReplIcons.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.console.gutter
 
 import com.intellij.icons.AllIcons
-import org.jetbrains.kotlin.idea.JetIcons
+import org.jetbrains.kotlin.idea.KtIcons
 import javax.swing.Icon
 
 public data class IconWithTooltip(val icon: Icon, val tooltip: String?)
@@ -25,7 +25,7 @@ public data class IconWithTooltip(val icon: Icon, val tooltip: String?)
 public object ReplIcons {
     public val BUILD_WARNING_INDICATOR: IconWithTooltip = IconWithTooltip(AllIcons.Ide.Warning_notifications, null)
     public val HISTORY_INDICATOR: IconWithTooltip = IconWithTooltip(AllIcons.General.MessageHistory, "History of executed commands")
-    public val EDITOR_INDICATOR: IconWithTooltip = IconWithTooltip(JetIcons.LAUNCH, "Write your commands here")
+    public val EDITOR_INDICATOR: IconWithTooltip = IconWithTooltip(KtIcons.LAUNCH, "Write your commands here")
     public val EDITOR_READLINE_INDICATOR: IconWithTooltip = IconWithTooltip(AllIcons.General.Balloon, "Waiting for input...")
     public val COMMAND_MARKER: IconWithTooltip = IconWithTooltip(AllIcons.General.Run, "Executed command")
     public val READLINE_MARKER: IconWithTooltip = IconWithTooltip(AllIcons.Icons.Ide.SpeedSearchPrompt, "Input line")
diff --git a/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/AstAccessControl.kt b/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/AstAccessControl.kt
index 9a19e402fc4..45212badd74 100644
--- a/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/AstAccessControl.kt
+++ b/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/AstAccessControl.kt
@@ -23,7 +23,7 @@ import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.VirtualFileFilter
 import com.intellij.psi.PsiManager
 import com.intellij.psi.impl.PsiManagerImpl
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import kotlin.test.fail
 
@@ -56,7 +56,7 @@ public object AstAccessControl {
         val manager = (PsiManager.getInstance(project) as PsiManagerImpl)
         val filter = VirtualFileFilter {
             file ->
-            if (file!!.getFileType() != JetFileType.INSTANCE || file in allowedFiles) {
+            if (file!!.getFileType() != KotlinFileType.INSTANCE || file in allowedFiles) {
                 false
             }
             else {
diff --git a/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/DirectiveBasedActionUtils.kt b/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/DirectiveBasedActionUtils.kt
index 33708cc8479..c4a6d4c7770 100644
--- a/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/DirectiveBasedActionUtils.kt
+++ b/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/DirectiveBasedActionUtils.kt
@@ -22,11 +22,11 @@ import com.intellij.testFramework.UsefulTestCase
 import org.jetbrains.kotlin.diagnostics.Severity
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
 import org.jetbrains.kotlin.idea.highlighter.IdeErrorMessages
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 
 public object DirectiveBasedActionUtils {
-    public fun checkForUnexpectedErrors(file: JetFile) {
+    public fun checkForUnexpectedErrors(file: KtFile) {
         if (InTextDirectivesUtils.findLinesWithPrefixesRemoved(file.getText(), "// DISABLE-ERRORS").isNotEmpty()) {
             return
         }
diff --git a/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/testUtils.kt b/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/testUtils.kt
index e29bf801639..f7cded80a3c 100644
--- a/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/testUtils.kt
+++ b/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/testUtils.kt
@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.idea.decompiler.JetClassFileViewProvider
 import org.jetbrains.kotlin.idea.decompiler.JetClsFile
 import org.jetbrains.kotlin.idea.js.KotlinJavaScriptLibraryManager
 import org.jetbrains.kotlin.idea.references.BuiltInsReferenceResolver
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import java.util.*
 
 public enum class ModuleKind {
@@ -75,7 +75,7 @@ public fun Module.configureAs(kind: ModuleKind) {
     }
 }
 
-public fun JetFile.dumpTextWithErrors(): String {
+public fun KtFile.dumpTextWithErrors(): String {
     val diagnostics = analyzeFullyAndGetResult().bindingContext.getDiagnostics()
     val errors = diagnostics.filter { it.getSeverity() == Severity.ERROR }
     if (errors.isEmpty()) return getText()
diff --git a/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/navigation/KotlinAndroidGotoDeclarationHandler.java b/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/navigation/KotlinAndroidGotoDeclarationHandler.java
index bfc5190e2c7..d29d11c8a1d 100644
--- a/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/navigation/KotlinAndroidGotoDeclarationHandler.java
+++ b/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/navigation/KotlinAndroidGotoDeclarationHandler.java
@@ -35,7 +35,7 @@ import org.jetbrains.android.util.AndroidResourceUtil;
 import org.jetbrains.android.util.AndroidUtils;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -46,7 +46,7 @@ import java.util.List;
 public class KotlinAndroidGotoDeclarationHandler implements GotoDeclarationHandler {
     @Override
     public PsiElement[] getGotoDeclarationTargets(@Nullable PsiElement sourceElement, int offset, Editor editor) {
-        JetSimpleNameExpression referenceExpression = GotoResourceHelperKt.getReferenceExpression(sourceElement);
+        KtSimpleNameExpression referenceExpression = GotoResourceHelperKt.getReferenceExpression(sourceElement);
         if (referenceExpression == null) {
             return null;
         }
diff --git a/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/navigation/gotoResourceHelper.kt b/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/navigation/gotoResourceHelper.kt
index 68b373128f7..20bcc5c0cb6 100644
--- a/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/navigation/gotoResourceHelper.kt
+++ b/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/navigation/gotoResourceHelper.kt
@@ -19,41 +19,41 @@ package org.jetbrains.kotlin.android.navigation
 import org.jetbrains.android.util.AndroidResourceUtil
 import com.intellij.psi.PsiElement
 import org.jetbrains.android.facet.AndroidFacet
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.psi.PsiClass
 import org.jetbrains.android.util.AndroidUtils
 import com.android.SdkConstants
 import org.jetbrains.android.augment.AndroidPsiElementFinder
 import org.jetbrains.kotlin.idea.references.mainReference
-import org.jetbrains.kotlin.psi.JetDotQualifiedExpression
+import org.jetbrains.kotlin.psi.KtDotQualifiedExpression
 import org.jetbrains.kotlin.psi.psiUtil.getReceiverExpression
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 
-fun getReferenceExpression(element: PsiElement?): JetSimpleNameExpression? {
-    return PsiTreeUtil.getParentOfType<JetSimpleNameExpression>(element, javaClass<JetSimpleNameExpression>())
+fun getReferenceExpression(element: PsiElement?): KtSimpleNameExpression? {
+    return PsiTreeUtil.getParentOfType<KtSimpleNameExpression>(element, javaClass<KtSimpleNameExpression>())
 }
 
 // given 'R.a.b' returns info for all three parts of the expression 'a', 'b', 'R'
 fun getInfo(
-        referenceExpression: JetSimpleNameExpression,
+        referenceExpression: KtSimpleNameExpression,
         facet: AndroidFacet
 ): AndroidResourceUtil.MyReferredResourceFieldInfo? {
     val info = getReferredInfo(referenceExpression, facet)
     if (info != null) return info
 
     val topMostQualified = referenceExpression.getParentQualified().getParentQualified() ?: return null
-    val selectorCandidate = topMostQualified.getSelectorExpression() as? JetSimpleNameExpression ?: return null
+    val selectorCandidate = topMostQualified.getSelectorExpression() as? KtSimpleNameExpression ?: return null
     return getReferredInfo(selectorCandidate, facet)
 }
 
-private fun JetExpression?.getParentQualified(): JetDotQualifiedExpression? {
-    return this?.getParent() as? JetDotQualifiedExpression
+private fun KtExpression?.getParentQualified(): KtDotQualifiedExpression? {
+    return this?.getParent() as? KtDotQualifiedExpression
 }
 
 // returns info if passed expression is 'b' in 'R.a.b'
 private fun getReferredInfo(
-        lastPart: JetSimpleNameExpression,
+        lastPart: KtSimpleNameExpression,
         facet: AndroidFacet
 ): AndroidResourceUtil.MyReferredResourceFieldInfo? {
     val resFieldName = lastPart.getReferencedName()
@@ -96,14 +96,14 @@ private fun getReferredInfo(
     return AndroidResourceUtil.MyReferredResourceFieldInfo(resClassName, resFieldName, false, fromManifest)
 }
 
-private fun getReceiverAsSimpleNameExpression(exp: JetSimpleNameExpression): JetSimpleNameExpression? {
+private fun getReceiverAsSimpleNameExpression(exp: KtSimpleNameExpression): KtSimpleNameExpression? {
     val receiver = exp.getReceiverExpression()
     return when (receiver) {
-        is JetSimpleNameExpression -> {
+        is KtSimpleNameExpression -> {
             receiver
         }
-        is JetDotQualifiedExpression -> {
-            receiver.getSelectorExpression() as? JetSimpleNameExpression
+        is KtDotQualifiedExpression -> {
+            receiver.getSelectorExpression() as? KtSimpleNameExpression
         }
         else -> null
     }
diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml
index 239204fd269..8f3107ff759 100644
--- a/idea/src/META-INF/plugin.xml
+++ b/idea/src/META-INF/plugin.xml
@@ -309,8 +309,8 @@
     <lang.foldingBuilder language="kotlin" implementationClass="org.jetbrains.kotlin.idea.KotlinFoldingBuilder"/>
     <lang.formatter language="kotlin" implementationClass="org.jetbrains.kotlin.idea.formatter.JetFormattingModelBuilder"/>
     <lang.findUsagesProvider language="kotlin" implementationClass="org.jetbrains.kotlin.idea.findUsages.JetFindUsagesProvider"/>
-    <lang.elementManipulator forClass="org.jetbrains.kotlin.psi.JetStringTemplateExpression"
-                             implementationClass="org.jetbrains.kotlin.psi.psiUtil.JetStringTemplateExpressionManipulator"/>
+    <lang.elementManipulator forClass="org.jetbrains.kotlin.psi.KtStringTemplateExpression"
+                             implementationClass="org.jetbrains.kotlin.psi.psiUtil.KtStringTemplateExpressionManipulator"/>
     <fileStructureGroupRuleProvider implementation="org.jetbrains.kotlin.idea.findUsages.KotlinDeclarationGroupRuleProvider"/>
     <importFilteringRule implementation="org.jetbrains.kotlin.idea.findUsages.JetImportFilteringRule"/>
     <lang.refactoringSupport language="kotlin" implementationClass="org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringSupportProvider"/>
@@ -384,7 +384,7 @@
 
     <weigher key="completion" implementationClass="org.jetbrains.kotlin.idea.completion.KotlinLookupElementProximityWeigher" id="kotlin.proximity" order="after proximity"/>
 
-    <psi.referenceContributor language="kotlin" implementation="org.jetbrains.kotlin.idea.references.JetReferenceContributor"/>
+    <psi.referenceContributor language="kotlin" implementation="org.jetbrains.kotlin.idea.references.KotlinReferenceContributor"/>
 
     <renamePsiElementProcessor id="KotlinClass"
                                implementation="org.jetbrains.kotlin.idea.refactoring.rename.RenameKotlinClassProcessor"
@@ -465,15 +465,15 @@
 
     <iconProvider implementation="org.jetbrains.kotlin.idea.JetIconProvider"/>
     <itemPresentationProvider implementationClass="org.jetbrains.kotlin.idea.presentation.JetFunctionPresenter"
-                              forClass="org.jetbrains.kotlin.psi.JetFunction"/>
+                              forClass="org.jetbrains.kotlin.psi.KtFunction"/>
     <itemPresentationProvider implementationClass="org.jetbrains.kotlin.idea.presentation.JetClassPresenter"
-                              forClass="org.jetbrains.kotlin.psi.JetClass"/>
+                              forClass="org.jetbrains.kotlin.psi.KtClass"/>
     <itemPresentationProvider implementationClass="org.jetbrains.kotlin.idea.presentation.JetObjectPresenter"
-                              forClass="org.jetbrains.kotlin.psi.JetObjectDeclaration"/>
+                              forClass="org.jetbrains.kotlin.psi.KtObjectDeclaration"/>
     <itemPresentationProvider implementationClass="org.jetbrains.kotlin.idea.presentation.JetPropertyPresenter"
-                              forClass="org.jetbrains.kotlin.psi.JetProperty"/>
+                              forClass="org.jetbrains.kotlin.psi.KtProperty"/>
     <itemPresentationProvider implementationClass="org.jetbrains.kotlin.idea.presentation.JetParameterPresenter"
-                              forClass="org.jetbrains.kotlin.psi.JetParameter"/>
+                              forClass="org.jetbrains.kotlin.psi.KtParameter"/>
     <gotoTargetRendererProvider id="JetGotoTargetRenderProvider" implementation="org.jetbrains.kotlin.idea.JetGotoTargetRenderProvider"
                                 order="first"/>
     <elementDescriptionProvider implementation="org.jetbrains.kotlin.idea.findUsages.JetElementDescriptionProvider" order="first"/>
@@ -533,7 +533,7 @@
     <java.elementFinder implementation="org.jetbrains.kotlin.asJava.JavaElementFinder"/>
     <java.shortNamesCache implementation="org.jetbrains.kotlin.idea.caches.JetShortNamesCache"/>
 
-    <stubElementTypeHolder class="org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes"/>
+    <stubElementTypeHolder class="org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes"/>
     <stubIndex implementation="org.jetbrains.kotlin.idea.stubindex.JetExactPackagesIndex"/>
     <stubIndex implementation="org.jetbrains.kotlin.idea.stubindex.JetTopLevelClassByPackageIndex"/>
     <stubIndex implementation="org.jetbrains.kotlin.idea.stubindex.JetTopLevelFunctionByPackageIndex"/>
diff --git a/idea/src/org/jetbrains/kotlin/idea/JetCommenter.java b/idea/src/org/jetbrains/kotlin/idea/JetCommenter.java
index 3146e4d32f2..3bc00692c01 100644
--- a/idea/src/org/jetbrains/kotlin/idea/JetCommenter.java
+++ b/idea/src/org/jetbrains/kotlin/idea/JetCommenter.java
@@ -20,7 +20,7 @@ import com.intellij.lang.CodeDocumentationAwareCommenter;
 import com.intellij.psi.PsiComment;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.kotlin.kdoc.psi.api.KDoc;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
 public class JetCommenter implements CodeDocumentationAwareCommenter {
     @Override
@@ -50,17 +50,17 @@ public class JetCommenter implements CodeDocumentationAwareCommenter {
 
     @Override
     public IElementType getLineCommentTokenType() {
-        return JetTokens.EOL_COMMENT;
+        return KtTokens.EOL_COMMENT;
     }
 
     @Override
     public IElementType getBlockCommentTokenType() {
-        return JetTokens.BLOCK_COMMENT;
+        return KtTokens.BLOCK_COMMENT;
     }
 
     @Override
     public IElementType getDocumentationCommentTokenType() {
-        return JetTokens.DOC_COMMENT;
+        return KtTokens.DOC_COMMENT;
     }
 
     @Override
diff --git a/idea/src/org/jetbrains/kotlin/idea/JetFileFactory.java b/idea/src/org/jetbrains/kotlin/idea/JetFileFactory.java
index 5d560f61147..0e0a7a9e319 100644
--- a/idea/src/org/jetbrains/kotlin/idea/JetFileFactory.java
+++ b/idea/src/org/jetbrains/kotlin/idea/JetFileFactory.java
@@ -24,6 +24,6 @@ import org.jetbrains.annotations.NotNull;
 public class JetFileFactory extends FileTypeFactory {
     @Override
     public void createFileTypes(@NotNull FileTypeConsumer consumer) {
-        consumer.consume(JetFileType.INSTANCE, "kt;kts");
+        consumer.consume(KotlinFileType.INSTANCE, "kt;kts");
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/JetPairMatcher.java b/idea/src/org/jetbrains/kotlin/idea/JetPairMatcher.java
index 0e9b443c246..7d670ca0b70 100644
--- a/idea/src/org/jetbrains/kotlin/idea/JetPairMatcher.java
+++ b/idea/src/org/jetbrains/kotlin/idea/JetPairMatcher.java
@@ -22,14 +22,14 @@ import com.intellij.psi.PsiFile;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
 public class JetPairMatcher implements PairedBraceMatcher {
     private final BracePair[] pairs = new BracePair[]{
-            new BracePair(JetTokens.LPAR, JetTokens.RPAR, false),
-            new BracePair(JetTokens.LONG_TEMPLATE_ENTRY_START, JetTokens.LONG_TEMPLATE_ENTRY_END, false),
-            new BracePair(JetTokens.LBRACE, JetTokens.RBRACE, true),
-            new BracePair(JetTokens.LBRACKET, JetTokens.RBRACKET, false),
+            new BracePair(KtTokens.LPAR, KtTokens.RPAR, false),
+            new BracePair(KtTokens.LONG_TEMPLATE_ENTRY_START, KtTokens.LONG_TEMPLATE_ENTRY_END, false),
+            new BracePair(KtTokens.LBRACE, KtTokens.RBRACE, true),
+            new BracePair(KtTokens.LBRACKET, KtTokens.RBRACKET, false),
     };
 
     @Override
@@ -39,19 +39,19 @@ public class JetPairMatcher implements PairedBraceMatcher {
 
     @Override
     public boolean isPairedBracesAllowedBeforeType(@NotNull IElementType lbraceType, @Nullable IElementType contextType) {
-        if (lbraceType.equals(JetTokens.LONG_TEMPLATE_ENTRY_START)) {
+        if (lbraceType.equals(KtTokens.LONG_TEMPLATE_ENTRY_START)) {
             // KotlinTypedHandler insert paired brace in this case
             return false;
         }
 
-        return  JetTokens.WHITE_SPACE_OR_COMMENT_BIT_SET.contains(contextType)
-                || contextType == JetTokens.SEMICOLON
-                || contextType == JetTokens.COMMA
-                || contextType == JetTokens.RPAR
-                || contextType == JetTokens.RBRACKET
-                || contextType == JetTokens.RBRACE
-                || contextType == JetTokens.LBRACE
-                || contextType == JetTokens.LONG_TEMPLATE_ENTRY_END;
+        return KtTokens.WHITE_SPACE_OR_COMMENT_BIT_SET.contains(contextType)
+               || contextType == KtTokens.SEMICOLON
+               || contextType == KtTokens.COMMA
+               || contextType == KtTokens.RPAR
+               || contextType == KtTokens.RBRACKET
+               || contextType == KtTokens.RBRACE
+               || contextType == KtTokens.LBRACE
+               || contextType == KtTokens.LONG_TEMPLATE_ENTRY_END;
     }
 
     @Override
diff --git a/idea/src/org/jetbrains/kotlin/idea/KotlinFoldingBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/KotlinFoldingBuilder.kt
index bea46a3f205..12439c6260f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/KotlinFoldingBuilder.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/KotlinFoldingBuilder.kt
@@ -25,12 +25,12 @@ import com.intellij.openapi.project.DumbAware
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiWhiteSpace
-import org.jetbrains.kotlin.JetNodeTypes
+import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.kdoc.lexer.KDocTokens
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetFunctionLiteral
-import org.jetbrains.kotlin.psi.JetImportList
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtFunctionLiteral
+import org.jetbrains.kotlin.psi.KtImportList
 import org.jetbrains.kotlin.psi.psiUtil.allChildren
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.psi.psiUtil.startOffset
 public class KotlinFoldingBuilder : CustomFoldingBuilder(), DumbAware {
     override fun buildLanguageFoldRegions(descriptors: MutableList<FoldingDescriptor>,
                                           root: PsiElement, document: Document, quick: Boolean) {
-        if (root !is JetFile) {
+        if (root !is KtFile) {
             return
         }
         val imports = root.getImportDirectives()
@@ -76,14 +76,14 @@ public class KotlinFoldingBuilder : CustomFoldingBuilder(), DumbAware {
     private fun needFolding(node: ASTNode): Boolean {
         val type = node.getElementType()
         val parentType = node.getTreeParent()?.getElementType()
-        return type == JetNodeTypes.FUNCTION_LITERAL ||
-               (type == JetNodeTypes.BLOCK && parentType != JetNodeTypes.FUNCTION_LITERAL) ||
-               type == JetNodeTypes.CLASS_BODY || type == JetTokens.BLOCK_COMMENT || type == KDocTokens.KDOC
+        return type == KtNodeTypes.FUNCTION_LITERAL ||
+               (type == KtNodeTypes.BLOCK && parentType != KtNodeTypes.FUNCTION_LITERAL) ||
+               type == KtNodeTypes.CLASS_BODY || type == KtTokens.BLOCK_COMMENT || type == KDocTokens.KDOC
     }
 
     private fun getRangeToFold(node: ASTNode): TextRange {
-        if (node.getElementType() == JetNodeTypes.FUNCTION_LITERAL) {
-            val psi = node.getPsi() as? JetFunctionLiteral
+        if (node.getElementType() == KtNodeTypes.FUNCTION_LITERAL) {
+            val psi = node.getPsi() as? KtFunctionLiteral
             val lbrace = psi?.getLBrace()
             val rbrace = psi?.getRBrace()
             if (lbrace != null && rbrace != null) {
@@ -97,21 +97,21 @@ public class KotlinFoldingBuilder : CustomFoldingBuilder(), DumbAware {
         document.getLineNumber(textRange.getStartOffset()) == document.getLineNumber(textRange.getEndOffset())
 
     override fun getLanguagePlaceholderText(node: ASTNode, range: TextRange): String = when {
-        node.getElementType() == JetTokens.BLOCK_COMMENT -> "/.../"
+        node.getElementType() == KtTokens.BLOCK_COMMENT -> "/.../"
         node.getElementType() == KDocTokens.KDOC -> "/**...*/"
-        node.getPsi() is JetImportList -> "..."
+        node.getPsi() is KtImportList -> "..."
         else ->  "{...}"
     }
 
     override fun isRegionCollapsedByDefault(node: ASTNode): Boolean {
         val settings = JavaCodeFoldingSettings.getInstance()
 
-        if (node.getPsi() is JetImportList) {
+        if (node.getPsi() is KtImportList) {
             return settings.isCollapseImports()
         }
 
         val type = node.getElementType()
-        if (type == JetTokens.BLOCK_COMMENT || type == KDocTokens.KDOC) {
+        if (type == KtTokens.BLOCK_COMMENT || type == KDocTokens.KDOC) {
             if (isFirstElementInFile(node.getPsi())) {
                 return settings.isCollapseFileHeader()
             }
@@ -121,11 +121,11 @@ public class KotlinFoldingBuilder : CustomFoldingBuilder(), DumbAware {
     }
 
     override fun isCustomFoldingRoot(node: ASTNode)
-        = node.getElementType() == JetNodeTypes.BLOCK || node.getElementType() == JetNodeTypes.CLASS_BODY
+        = node.getElementType() == KtNodeTypes.BLOCK || node.getElementType() == KtNodeTypes.CLASS_BODY
 
     private fun isFirstElementInFile(element: PsiElement): Boolean {
         val parent = element.getParent()
-        if (parent is JetFile) {
+        if (parent is KtFile) {
             val firstNonWhiteSpace = parent.allChildren.firstOrNull {
                 it.getTextLength() != 0 && it !is PsiWhiteSpace
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/KotlinQuickDocumentationProvider.kt b/idea/src/org/jetbrains/kotlin/idea/KotlinQuickDocumentationProvider.kt
index 2a9af75db63..978e428b6d2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/KotlinQuickDocumentationProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/KotlinQuickDocumentationProvider.kt
@@ -31,9 +31,9 @@ import org.jetbrains.kotlin.idea.core.completion.DeclarationLookupObject
 import org.jetbrains.kotlin.idea.kdoc.KDocFinder
 import org.jetbrains.kotlin.idea.kdoc.KDocRenderer
 import org.jetbrains.kotlin.idea.kdoc.resolveKDocLink
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetReferenceExpression
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtReferenceExpression
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
@@ -54,7 +54,7 @@ public class KotlinQuickDocumentationProvider : AbstractDocumentationProvider()
     }
 
     override fun getDocumentationElementForLink(psiManager: PsiManager, link: String, context: PsiElement?): PsiElement? {
-        if (context !is JetElement) {
+        if (context !is KtElement) {
             return null
         }
 
@@ -88,7 +88,7 @@ public class KotlinQuickDocumentationProvider : AbstractDocumentationProvider()
         }
 
         private fun getText(element: PsiElement, originalElement: PsiElement?, quickNavigation: Boolean): String? {
-            if (element is JetDeclaration) {
+            if (element is KtDeclaration) {
                 return renderKotlinDeclaration(element, quickNavigation)
             }
             else if (element is KotlinLightElement<*, *>) {
@@ -97,7 +97,7 @@ public class KotlinQuickDocumentationProvider : AbstractDocumentationProvider()
             }
 
             if (quickNavigation) {
-                val referenceExpression = originalElement?.getNonStrictParentOfType<JetReferenceExpression>()
+                val referenceExpression = originalElement?.getNonStrictParentOfType<KtReferenceExpression>()
                 if (referenceExpression != null) {
                     val context = referenceExpression.analyze(BodyResolveMode.PARTIAL)
                     val declarationDescriptor = context[BindingContext.REFERENCE_TARGET, referenceExpression]
@@ -113,7 +113,7 @@ public class KotlinQuickDocumentationProvider : AbstractDocumentationProvider()
             return null
         }
 
-        private fun renderKotlinDeclaration(declaration: JetDeclaration, quickNavigation: Boolean): String {
+        private fun renderKotlinDeclaration(declaration: KtDeclaration, quickNavigation: Boolean): String {
             val context = declaration.analyze(BodyResolveMode.PARTIAL)
             val declarationDescriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, declaration]
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/PluginStartupComponent.java b/idea/src/org/jetbrains/kotlin/idea/PluginStartupComponent.java
index 2684a0b2b45..2f425dc59cd 100644
--- a/idea/src/org/jetbrains/kotlin/idea/PluginStartupComponent.java
+++ b/idea/src/org/jetbrains/kotlin/idea/PluginStartupComponent.java
@@ -65,7 +65,7 @@ public class PluginStartupComponent implements ApplicationComponent {
             @Override
             public void documentChanged(DocumentEvent e) {
                 VirtualFile virtualFile = FileDocumentManager.getInstance().getFile(e.getDocument());
-                if (virtualFile != null && virtualFile.getFileType() == JetFileType.INSTANCE) {
+                if (virtualFile != null && virtualFile.getFileType() == KotlinFileType.INSTANCE) {
                     KotlinPluginUpdater.Companion.getInstance().kotlinFileEdited();
                 }
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt
index e7f48374eb6..0203deef9e3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt
@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.j2k.ConverterSettings
 import org.jetbrains.kotlin.j2k.JavaToKotlinConverter
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import java.io.File
 import java.io.IOException
 import java.util.ArrayList
@@ -74,7 +74,7 @@ public class JavaToKotlinAction : AnAction() {
             return result
         }
 
-        fun convertFiles(javaFiles: List<PsiJavaFile>, project: Project, enableExternalCodeProcessing: Boolean = true): List<JetFile> {
+        fun convertFiles(javaFiles: List<PsiJavaFile>, project: Project, enableExternalCodeProcessing: Boolean = true): List<KtFile> {
             ApplicationManager.getApplication().saveAll()
 
             var converterResult: JavaToKotlinConverter.FilesResult? = null
@@ -121,7 +121,7 @@ public class JavaToKotlinAction : AnAction() {
                     FileEditorManager.getInstance(project).openFile(it, true)
                 }
 
-                newFiles.map { it.toPsiFile(project) as JetFile }
+                newFiles.map { it.toPsiFile(project) as KtFile }
             }
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/KotlinAddImportAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/KotlinAddImportAction.kt
index 9efd16a239a..bbf301d8b15 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/KotlinAddImportAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/KotlinAddImportAction.kt
@@ -39,13 +39,13 @@ import org.jetbrains.kotlin.idea.JetDescriptorIconProvider
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.core.ImportableFqNameClassifier
 import org.jetbrains.kotlin.idea.imports.importableFqName
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 
 /**
  * Automatically adds import directive to the file for resolving reference.
@@ -54,7 +54,7 @@ import org.jetbrains.kotlin.psi.JetSimpleNameExpression
 public class KotlinAddImportAction(
         private val project: Project,
         private val editor: Editor,
-        private val element: JetSimpleNameExpression,
+        private val element: KtSimpleNameExpression,
         candidates: Collection<DeclarationDescriptor>
 ) : QuestionAction {
 
@@ -156,7 +156,7 @@ public class KotlinAddImportAction(
             val descriptor = selectedVariant.descriptorToImport
             // for class or package we use ShortenReferences because we not necessary insert an import but may want to insert partly qualified name
             if (descriptor is ClassDescriptor || descriptor is PackageViewDescriptor) {
-                element.mainReference.bindToFqName(descriptor.importableFqName!!, JetSimpleNameReference.ShorteningMode.FORCED_SHORTENING)
+                element.mainReference.bindToFqName(descriptor.importableFqName!!, KtSimpleNameReference.ShorteningMode.FORCED_SHORTENING)
             }
             else {
                 ImportInsertHelper.getInstance(project).importDescriptor(file, descriptor)
@@ -164,7 +164,7 @@ public class KotlinAddImportAction(
         }
     }
 
-    private class Prioritizer(private val file: JetFile) {
+    private class Prioritizer(private val file: KtFile) {
         private val classifier = ImportableFqNameClassifier(file)
         private val proximityComparator = PsiProximityComparator(file)
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/KotlinQualifiedNameProvider.kt b/idea/src/org/jetbrains/kotlin/idea/actions/KotlinQualifiedNameProvider.kt
index c5c8e644a2f..278f1aefeec 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/KotlinQualifiedNameProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/KotlinQualifiedNameProvider.kt
@@ -20,21 +20,21 @@ import com.intellij.ide.actions.QualifiedNameProvider
 import com.intellij.psi.PsiElement
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 
 public class KotlinQualifiedNameProvider: QualifiedNameProvider {
     override fun adjustElementToCopy(element: PsiElement?) = null
 
     override fun getQualifiedName(element: PsiElement?): String? {
         when (element) {
-            is JetClassOrObject -> return element.getFqName()?.asString()
-            is JetNamedFunction, is JetProperty -> {
-                val descriptor = (element as JetDeclaration).resolveToDescriptor()
+            is KtClassOrObject -> return element.getFqName()?.asString()
+            is KtNamedFunction, is KtProperty -> {
+                val descriptor = (element as KtDeclaration).resolveToDescriptor()
                 val fqNameUnsafe = DescriptorUtils.getFqName(descriptor)
                 if (fqNameUnsafe.isSafe()) {
                     return fqNameUnsafe.asString()
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/NewKotlinFileAction.java b/idea/src/org/jetbrains/kotlin/idea/actions/NewKotlinFileAction.java
index 245d908ab8d..866ecab3c7c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/NewKotlinFileAction.java
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/NewKotlinFileAction.java
@@ -31,15 +31,15 @@ import com.intellij.openapi.roots.ProjectRootManager;
 import com.intellij.psi.PsiDirectory;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.kotlin.idea.JetBundle;
-import org.jetbrains.kotlin.idea.JetFileType;
-import org.jetbrains.kotlin.idea.JetIcons;
+import org.jetbrains.kotlin.idea.KotlinFileType;
+import org.jetbrains.kotlin.idea.KtIcons;
 import org.jetbrains.kotlin.idea.configuration.ConfigureKotlinInProjectUtils;
 
 import java.util.Map;
 
 public class NewKotlinFileAction extends CreateFileFromTemplateAction implements DumbAware {
     public NewKotlinFileAction() {
-        super(JetBundle.message("new.kotlin.file.action"), "Creates new Kotlin file or class", JetFileType.INSTANCE.getIcon());
+        super(JetBundle.message("new.kotlin.file.action"), "Creates new Kotlin file or class", KotlinFileType.INSTANCE.getIcon());
     }
 
     @Override
@@ -56,11 +56,11 @@ public class NewKotlinFileAction extends CreateFileFromTemplateAction implements
     protected void buildDialog(Project project, PsiDirectory directory, CreateFileFromTemplateDialog.Builder builder) {
         builder
                 .setTitle("New Kotlin File/Class")
-                .addKind("File", JetFileType.INSTANCE.getIcon(), "Kotlin File")
-                .addKind("Class", JetIcons.CLASS, "Kotlin Class")
-                .addKind("Interface", JetIcons.TRAIT, "Kotlin Interface")
-                .addKind("Enum class", JetIcons.ENUM, "Kotlin Enum")
-                .addKind("Object", JetIcons.OBJECT, "Kotlin Object");
+                .addKind("File", KotlinFileType.INSTANCE.getIcon(), "Kotlin File")
+                .addKind("Class", KtIcons.CLASS, "Kotlin Class")
+                .addKind("Interface", KtIcons.TRAIT, "Kotlin Interface")
+                .addKind("Enum class", KtIcons.ENUM, "Kotlin Enum")
+                .addKind("Object", KtIcons.OBJECT, "Kotlin Object");
     }
 
     @Override
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/ShowExpressionTypeAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/ShowExpressionTypeAction.kt
index 3ef8bbab4a7..2929a4a5725 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/ShowExpressionTypeAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/ShowExpressionTypeAction.kt
@@ -27,15 +27,15 @@ import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.parents
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 @Deprecated("Remove once we no longer support IDEA 14.1")
 public class ShowExpressionTypeAction : AnAction() {
@@ -46,14 +46,14 @@ public class ShowExpressionTypeAction : AnAction() {
         val type = if (editor.getSelectionModel().hasSelection()) {
             val startOffset = editor.getSelectionModel().getSelectionStart()
             val endOffset = editor.getSelectionModel().getSelectionEnd()
-            val expression = CodeInsightUtilCore.findElementInRange<JetExpression>(psiFile, startOffset, endOffset, javaClass<JetExpression>(), KotlinLanguage.INSTANCE) ?: return
+            val expression = CodeInsightUtilCore.findElementInRange<KtExpression>(psiFile, startOffset, endOffset, javaClass<KtExpression>(), KotlinLanguage.INSTANCE) ?: return
             typeByExpression(expression)
         }
         else {
             val offset = editor.getCaretModel().getOffset()
             val token = psiFile.findElementAt(offset) ?: return
             val pair = token.parents
-                               .filterIsInstance<JetExpression>()
+                               .filterIsInstance<KtExpression>()
                                .map { it to typeByExpression(it) }
                                .firstOrNull { it.second != null } ?: return
             val (expression, type) = pair
@@ -76,16 +76,16 @@ public class ShowExpressionTypeAction : AnAction() {
 
         val editor = e.getData<Editor>(CommonDataKeys.EDITOR)
         val psiFile = e.getData<PsiFile>(CommonDataKeys.PSI_FILE)
-        e.getPresentation().setEnabled(editor != null && psiFile is JetFile)
+        e.getPresentation().setEnabled(editor != null && psiFile is KtFile)
     }
 
     companion object {
-        fun renderTypeHint(type: JetType) = "<html>" + DescriptorRenderer.HTML.renderType(type) + "</html>"
+        fun renderTypeHint(type: KtType) = "<html>" + DescriptorRenderer.HTML.renderType(type) + "</html>"
 
-        fun typeByExpression(expression: JetExpression): JetType? {
+        fun typeByExpression(expression: KtExpression): KtType? {
             val bindingContext = expression.analyze()
 
-            if (expression is JetCallableDeclaration) {
+            if (expression is KtCallableDeclaration) {
                 val descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, expression] as? CallableDescriptor
                 if (descriptor != null) {
                     return descriptor.getReturnType()
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/ShowKotlinBytecodeAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/ShowKotlinBytecodeAction.kt
index 6c67b344dd2..c4ba1aca4e8 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/ShowKotlinBytecodeAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/ShowKotlinBytecodeAction.kt
@@ -22,8 +22,8 @@ import com.intellij.openapi.actionSystem.CommonDataKeys
 import com.intellij.openapi.wm.ToolWindowAnchor
 import com.intellij.openapi.wm.ToolWindowManager
 import com.intellij.ui.content.ContentFactory
-import org.jetbrains.kotlin.idea.JetFileType
-import org.jetbrains.kotlin.idea.JetIcons
+import org.jetbrains.kotlin.idea.KotlinFileType
+import org.jetbrains.kotlin.idea.KtIcons
 import org.jetbrains.kotlin.idea.internal.KotlinBytecodeToolWindow
 
 public class ShowKotlinBytecodeAction(): AnAction() {
@@ -36,7 +36,7 @@ public class ShowKotlinBytecodeAction(): AnAction() {
         var toolWindow = toolWindowManager.getToolWindow(TOOLWINDOW_ID)
         if (toolWindow == null) {
             toolWindow = toolWindowManager.registerToolWindow("Kotlin Bytecode", true, ToolWindowAnchor.RIGHT)
-            toolWindow.setIcon(JetIcons.SMALL_LOGO_13)
+            toolWindow.setIcon(KtIcons.SMALL_LOGO_13)
 
             val contentManager = toolWindow.getContentManager()
             val contentFactory = ContentFactory.SERVICE.getInstance()
@@ -47,6 +47,6 @@ public class ShowKotlinBytecodeAction(): AnAction() {
 
     override fun update(e: AnActionEvent) {
         val file = e.getData(CommonDataKeys.PSI_FILE)
-        e.getPresentation().setEnabled(e.getProject() != null && file?.getFileType() == JetFileType.INSTANCE)
+        e.getPresentation().setEnabled(e.getProject() != null && file?.getFileType() == KotlinFileType.INSTANCE)
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateActionBase.kt b/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateActionBase.kt
index 163e5e2d982..258f302d904 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateActionBase.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateActionBase.kt
@@ -25,8 +25,8 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 
 abstract class KotlinGenerateActionBase() : CodeInsightAction(), CodeInsightActionHandler {
@@ -46,17 +46,17 @@ abstract class KotlinGenerateActionBase() : CodeInsightAction(), CodeInsightActi
     }
 
     override fun isValidForFile(project: Project, editor: Editor, file: PsiFile): Boolean {
-        if (file !is JetFile || file.isCompiled) return false
+        if (file !is KtFile || file.isCompiled) return false
 
         val targetClass = getTargetClass(editor, file) ?: return false
         return targetClass.canRefactor() && isValidForClass(targetClass)
     }
 
-    protected open fun getTargetClass(editor: Editor, file: PsiFile): JetClassOrObject? {
-        return file.findElementAt(editor.caretModel.offset)?.getNonStrictParentOfType<JetClassOrObject>()
+    protected open fun getTargetClass(editor: Editor, file: PsiFile): KtClassOrObject? {
+        return file.findElementAt(editor.caretModel.offset)?.getNonStrictParentOfType<KtClassOrObject>()
     }
 
-    protected abstract fun isValidForClass(targetClass: JetClassOrObject): Boolean
+    protected abstract fun isValidForClass(targetClass: KtClassOrObject): Boolean
 
     override fun startInWriteAction() = false
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateEqualsAndHashcodeAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateEqualsAndHashcodeAction.kt
index 30cd2c5819c..110719ceb30 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateEqualsAndHashcodeAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateEqualsAndHashcodeAction.kt
@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.idea.quickfix.insertMembersAfter
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
@@ -92,16 +92,16 @@ class KotlinGenerateEqualsAndHashcodeAction : KotlinGenerateMemberActionBase<Kot
             val variablesForHashCode: List<VariableDescriptor>
     )
 
-    override fun isValidForClass(targetClass: JetClassOrObject): Boolean {
-        return targetClass is JetClass && targetClass !is JetEnumEntry && !targetClass.isAnnotation()
-                && !targetClass.hasModifier(JetTokens.DATA_KEYWORD)
+    override fun isValidForClass(targetClass: KtClassOrObject): Boolean {
+        return targetClass is KtClass && targetClass !is KtEnumEntry && !targetClass.isAnnotation()
+                && !targetClass.hasModifier(KtTokens.DATA_KEYWORD)
                 && targetClass.getPropertiesToUse().isNotEmpty()
     }
 
-    private fun JetClassOrObject.getPropertiesToUse(): List<JetNamedDeclaration> {
-        return ArrayList<JetNamedDeclaration>().apply {
+    private fun KtClassOrObject.getPropertiesToUse(): List<KtNamedDeclaration> {
+        return ArrayList<KtNamedDeclaration>().apply {
             getPrimaryConstructorParameters().filterTo(this) { it.hasValOrVar() }
-            declarations.filterIsInstance<JetProperty>().filterTo(this) f@ {
+            declarations.filterIsInstance<KtProperty>().filterTo(this) f@ {
                 val descriptor = it.resolveToDescriptor()
                 when (descriptor) {
                     is ValueParameterDescriptor -> true
@@ -113,7 +113,7 @@ class KotlinGenerateEqualsAndHashcodeAction : KotlinGenerateMemberActionBase<Kot
     }
 
     private fun confirmRewrite(
-            targetClass: JetClass,
+            targetClass: KtClass,
             equalsDescriptor: FunctionDescriptor,
             hashCodeDescriptor: FunctionDescriptor
     ): Boolean {
@@ -125,8 +125,8 @@ class KotlinGenerateEqualsAndHashcodeAction : KotlinGenerateMemberActionBase<Kot
                                         Messages.getQuestionIcon()) == Messages.YES
     }
 
-    override fun prepareMembersInfo(klass: JetClassOrObject, project: Project, editor: Editor?): Info? {
-        if (klass !is JetClass) throw AssertionError("Not a class: ${klass.getElementTextWithContext()}")
+    override fun prepareMembersInfo(klass: KtClassOrObject, project: Project, editor: Editor?): Info? {
+        if (klass !is KtClass) throw AssertionError("Not a class: ${klass.getElementTextWithContext()}")
 
         val context = klass.analyzeFully()
         val classDescriptor = context.get(BindingContext.CLASS, klass) ?: return null
@@ -171,13 +171,13 @@ class KotlinGenerateEqualsAndHashcodeAction : KotlinGenerateMemberActionBase<Kot
 
     private fun FunctionDescriptor.isMemberOfAny() = containingDeclaration == builtIns.any
 
-    private fun generateFunctionSkeleton(descriptor: FunctionDescriptor, project: Project): JetNamedFunction {
+    private fun generateFunctionSkeleton(descriptor: FunctionDescriptor, project: Project): KtNamedFunction {
         return OverrideMemberChooserObject
                 .create(project, descriptor, descriptor, OverrideMemberChooserObject.BodyType.EMPTY)
-                .generateMember(project) as JetNamedFunction
+                .generateMember(project) as KtNamedFunction
     }
 
-    private fun generateEquals(project: Project, info: Info): JetNamedFunction? {
+    private fun generateEquals(project: Project, info: Info): KtNamedFunction? {
         with(info) {
             if (!needEquals) return null
 
@@ -218,12 +218,12 @@ class KotlinGenerateEqualsAndHashcodeAction : KotlinGenerateMemberActionBase<Kot
                 append("return true")
             }
 
-            equalsFun.bodyExpression!!.replace(JetPsiFactory(project).createExpression("{\n$bodyText\n}"))
+            equalsFun.bodyExpression!!.replace(KtPsiFactory(project).createExpression("{\n$bodyText\n}"))
 
             return equalsFun
         }
     }
-    private fun generateHashCode(project: Project, info: Info): JetNamedFunction? {
+    private fun generateHashCode(project: Project, info: Info): KtNamedFunction? {
         fun VariableDescriptor.genVariableHashCode(parenthesesNeeded: Boolean): String {
             val ref = name.asString().quoteIfNeeded()
             val isNullable = TypeUtils.isNullableType(type)
@@ -267,20 +267,20 @@ class KotlinGenerateEqualsAndHashcodeAction : KotlinGenerateMemberActionBase<Kot
                 }.toString()
             } else "return $initialValue"
 
-            hashCodeFun.bodyExpression!!.replace(JetPsiFactory(project).createExpression("{\n$bodyText\n}"))
+            hashCodeFun.bodyExpression!!.replace(KtPsiFactory(project).createExpression("{\n$bodyText\n}"))
 
             return hashCodeFun
         }
     }
 
-    override fun generateMembers(project: Project, editor: Editor?, info: Info): List<JetDeclaration> {
-        val targetClass = info.classDescriptor.source.getPsi() as JetClass
-        val prototypes = ArrayList<JetDeclaration>(2)
+    override fun generateMembers(project: Project, editor: Editor?, info: Info): List<KtDeclaration> {
+        val targetClass = info.classDescriptor.source.getPsi() as KtClass
+        val prototypes = ArrayList<KtDeclaration>(2)
                 .apply {
                     addIfNotNull(generateEquals(project, info))
                     addIfNotNull(generateHashCode(project, info))
                 }
-        val anchor = with(targetClass.declarations) { lastIsInstanceOrNull<JetNamedFunction>() ?: lastOrNull() }
+        val anchor = with(targetClass.declarations) { lastIsInstanceOrNull<KtNamedFunction>() ?: lastOrNull() }
         return insertMembersAfter(editor, targetClass, prototypes, anchor)
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateEqualsWizard.kt b/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateEqualsWizard.kt
index da9588bd2d4..03256381616 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateEqualsWizard.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateEqualsWizard.kt
@@ -27,8 +27,8 @@ import com.intellij.ui.NonFocusableCheckBox
 import com.intellij.util.containers.HashMap
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberInfo
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberSelectionPanel
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.isInheritable
 import org.jetbrains.kotlin.utils.keysToMap
 import javax.swing.JLabel
@@ -36,21 +36,21 @@ import javax.swing.JPanel
 
 class KotlinGenerateEqualsWizard(
         project: Project,
-        klass: JetClass,
-        properties: List<JetNamedDeclaration>,
+        klass: KtClass,
+        properties: List<KtNamedDeclaration>,
         needEquals: Boolean,
         needHashCode: Boolean
-) : AbstractGenerateEqualsWizard<JetClass, JetNamedDeclaration, KotlinMemberInfo>(
+) : AbstractGenerateEqualsWizard<KtClass, KtNamedDeclaration, KotlinMemberInfo>(
         project, KotlinGenerateEqualsWizard.BuilderImpl(klass, properties, needEquals, needHashCode)
 ) {
-    private object MemberInfoModelImpl : AbstractMemberInfoModel<JetNamedDeclaration, KotlinMemberInfo>()
+    private object MemberInfoModelImpl : AbstractMemberInfoModel<KtNamedDeclaration, KotlinMemberInfo>()
 
     private class BuilderImpl(
-            private val klass: JetClass,
-            properties: List<JetNamedDeclaration>,
+            private val klass: KtClass,
+            properties: List<KtNamedDeclaration>,
             needEquals: Boolean,
             needHashCode: Boolean
-    ) : AbstractGenerateEqualsWizard.Builder<JetClass, JetNamedDeclaration, KotlinMemberInfo>() {
+    ) : AbstractGenerateEqualsWizard.Builder<KtClass, KtNamedDeclaration, KotlinMemberInfo>() {
         private val equalsPanel: KotlinMemberSelectionPanel?
         private val hashCodePanel: KotlinMemberSelectionPanel?
 
@@ -72,7 +72,7 @@ class KotlinGenerateEqualsWizard(
             } else null
         }
 
-        private fun createMemberInfo(it: JetNamedDeclaration) = KotlinMemberInfo(it).apply { isChecked = true }
+        private fun createMemberInfo(it: KtNamedDeclaration) = KotlinMemberInfo(it).apply { isChecked = true }
 
         override fun getPsiClass() = klass
 
@@ -80,7 +80,7 @@ class KotlinGenerateEqualsWizard(
 
         override fun getFieldsToHashCode() = membersToHashCode
 
-        override fun getFieldsToNonNull() = HashMap<JetNamedDeclaration, KotlinMemberInfo>()
+        override fun getFieldsToNonNull() = HashMap<KtNamedDeclaration, KotlinMemberInfo>()
 
         override fun getEqualsPanel() = equalsPanel
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateMemberActionBase.kt b/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateMemberActionBase.kt
index 8ac603e22c6..d2edab4322e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateMemberActionBase.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateMemberActionBase.kt
@@ -24,13 +24,13 @@ import com.intellij.openapi.fileEditor.FileDocumentManager
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtDeclaration
 
 abstract class KotlinGenerateMemberActionBase<Info : Any> : KotlinGenerateActionBase() {
-    protected abstract fun prepareMembersInfo(klass: JetClassOrObject, project: Project, editor: Editor?): Info?
+    protected abstract fun prepareMembersInfo(klass: KtClassOrObject, project: Project, editor: Editor?): Info?
 
-    protected abstract fun generateMembers(project: Project, editor: Editor?, info: Info): List<JetDeclaration>
+    protected abstract fun generateMembers(project: Project, editor: Editor?, info: Info): List<KtDeclaration>
 
     override fun invoke(project: Project, editor: Editor, file: PsiFile) {
         if (!CodeInsightUtilBase.prepareEditorForWrite(editor)) return
@@ -39,7 +39,7 @@ abstract class KotlinGenerateMemberActionBase<Info : Any> : KotlinGenerateAction
         doInvoke(project, editor, targetClass)
     }
 
-    fun doInvoke(project: Project, editor: Editor?, targetClass: JetClassOrObject) {
+    fun doInvoke(project: Project, editor: Editor?, targetClass: KtClassOrObject) {
         val membersInfo = prepareMembersInfo(targetClass, project, editor) ?: return
 
         project.executeWriteCommand(commandName, this) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateSecondaryConstructorAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateSecondaryConstructorAction.kt
index 55a39e8514a..38041385e33 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateSecondaryConstructorAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateSecondaryConstructorAction.kt
@@ -42,10 +42,10 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny
 import org.jetbrains.kotlin.resolve.source.getPsi
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.types.Variance
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.substitutions.getTypeSubstitutor
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import org.jetbrains.kotlin.utils.addToStdlib.lastIsInstanceOrNull
@@ -59,13 +59,13 @@ class KotlinGenerateSecondaryConstructorAction : KotlinGenerateMemberActionBase<
             val classDescriptor: ClassDescriptor
     )
 
-    override fun isValidForClass(targetClass: JetClassOrObject): Boolean {
-        return targetClass is JetClass && targetClass !is JetEnumEntry && !targetClass.isInterface() && !targetClass.isAnnotation()
+    override fun isValidForClass(targetClass: KtClassOrObject): Boolean {
+        return targetClass is KtClass && targetClass !is KtEnumEntry && !targetClass.isInterface() && !targetClass.isAnnotation()
     }
 
-    private fun shouldPreselect(element: PsiElement) = element is JetProperty && !element.isVar
+    private fun shouldPreselect(element: PsiElement) = element is KtProperty && !element.isVar
 
-    private fun chooseSuperConstructors(klass: JetClassOrObject, classDescriptor: ClassDescriptor): List<DescriptorMemberChooserObject> {
+    private fun chooseSuperConstructors(klass: KtClassOrObject, classDescriptor: ClassDescriptor): List<DescriptorMemberChooserObject> {
         val project = klass.project
         val superClassDescriptor = classDescriptor.getSuperClassNotAny() ?: return emptyList()
         val candidates = superClassDescriptor.constructors
@@ -82,9 +82,9 @@ class KotlinGenerateSecondaryConstructorAction : KotlinGenerateMemberActionBase<
         }
     }
 
-    private fun choosePropertiesToInitialize(klass: JetClassOrObject, context: BindingContext): List<DescriptorMemberChooserObject> {
+    private fun choosePropertiesToInitialize(klass: KtClassOrObject, context: BindingContext): List<DescriptorMemberChooserObject> {
         val candidates = klass.declarations
-                .filterIsInstance<JetProperty>()
+                .filterIsInstance<KtProperty>()
                 .filter { it.isVar || context.diagnostics.forElement(it).any { it.factory in Errors.MUST_BE_INITIALIZED_DIAGNOSTICS } }
                 .map { context.get(BindingContext.VARIABLE, it) as PropertyDescriptor }
                 .map { DescriptorMemberChooserObject(it.source.getPsi()!!, it) }
@@ -100,7 +100,7 @@ class KotlinGenerateSecondaryConstructorAction : KotlinGenerateMemberActionBase<
         }
     }
 
-    override fun prepareMembersInfo(klass: JetClassOrObject, project: Project, editor: Editor?): Info? {
+    override fun prepareMembersInfo(klass: KtClassOrObject, project: Project, editor: Editor?): Info? {
         val context = klass.analyzeFully()
         val classDescriptor = context.get(BindingContext.CLASS, klass) ?: return null
         val superConstructors = chooseSuperConstructors(klass, classDescriptor).map { it.descriptor as ConstructorDescriptor }
@@ -108,15 +108,15 @@ class KotlinGenerateSecondaryConstructorAction : KotlinGenerateMemberActionBase<
         return Info(propertiesToInitialize, superConstructors, classDescriptor)
     }
 
-    override fun generateMembers(project: Project, editor: Editor?, info: Info): List<JetDeclaration> {
-        val targetClass = info.classDescriptor.source.getPsi() as? JetClass ?: return emptyList()
+    override fun generateMembers(project: Project, editor: Editor?, info: Info): List<KtDeclaration> {
+        val targetClass = info.classDescriptor.source.getPsi() as? KtClass ?: return emptyList()
 
         fun Info.findAnchor(): PsiElement? {
-            targetClass.declarations.lastIsInstanceOrNull<JetSecondaryConstructor>()?.let { return it }
+            targetClass.declarations.lastIsInstanceOrNull<KtSecondaryConstructor>()?.let { return it }
             val lastPropertyToInitialize = propertiesToInitialize.lastOrNull()?.source?.getPsi()
-            val declarationsAfter = lastPropertyToInitialize?.siblings()?.filterIsInstance<JetDeclaration>() ?: targetClass.declarations.asSequence()
-            val firstNonProperty = declarationsAfter.firstOrNull { it !is JetProperty } ?: return null
-            return firstNonProperty.siblings(forward = false).firstIsInstanceOrNull<JetProperty>() ?: targetClass.getOrCreateBody().lBrace
+            val declarationsAfter = lastPropertyToInitialize?.siblings()?.filterIsInstance<KtDeclaration>() ?: targetClass.declarations.asSequence()
+            val firstNonProperty = declarationsAfter.firstOrNull { it !is KtProperty } ?: return null
+            return firstNonProperty.siblings(forward = false).firstIsInstanceOrNull<KtProperty>() ?: targetClass.getOrCreateBody().lBrace
         }
 
         return with(info) {
@@ -139,19 +139,19 @@ class KotlinGenerateSecondaryConstructorAction : KotlinGenerateMemberActionBase<
             classDescriptor: ClassDescriptor,
             propertiesToInitialize: List<PropertyDescriptor>,
             superConstructor: ConstructorDescriptor?
-    ): JetSecondaryConstructor? {
-        fun equalTypes(types1: Collection<JetType>, types2: Collection<JetType>): Boolean {
-            return types1.size == types2.size && (types1.zip(types2)).all { JetTypeChecker.DEFAULT.equalTypes(it.first, it.second) }
+    ): KtSecondaryConstructor? {
+        fun equalTypes(types1: Collection<KtType>, types2: Collection<KtType>): Boolean {
+            return types1.size == types2.size && (types1.zip(types2)).all { KotlinTypeChecker.DEFAULT.equalTypes(it.first, it.second) }
         }
 
         val constructorParamTypes = propertiesToInitialize.map { it.type } +
                 (superConstructor?.valueParameters?.map { it.varargElementType ?: it.type } ?: emptyList())
 
-        if (classDescriptor.constructors.any { it.source.getPsi() is JetConstructor<*>
+        if (classDescriptor.constructors.any { it.source.getPsi() is KtConstructor<*>
                 && equalTypes(it.valueParameters.map { it.varargElementType ?: it.type }, constructorParamTypes) }) return null
 
-        val targetClass = classDescriptor.source.getPsi() as JetClass
-        val psiFactory = JetPsiFactory(targetClass)
+        val targetClass = classDescriptor.source.getPsi() as KtClass
+        val psiFactory = KtPsiFactory(targetClass)
 
         val validator = CollectingNameValidator()
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateTestSupportActionBase.kt b/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateTestSupportActionBase.kt
index d2a92227f25..d952a68b1c3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateTestSupportActionBase.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateTestSupportActionBase.kt
@@ -50,10 +50,10 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.setupE
 import org.jetbrains.kotlin.idea.quickfix.insertMember
 import org.jetbrains.kotlin.idea.testIntegration.findSuitableFrameworks
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 import org.jetbrains.kotlin.utils.ifEmpty
 
@@ -61,9 +61,9 @@ abstract class KotlinGenerateTestSupportActionBase(
         private val methodKind : MethodKind
 ) : KotlinGenerateActionBase(), GenerateActionPopupTemplateInjector {
     companion object {
-        private fun findTargetClass(editor: Editor, file: PsiFile): JetClassOrObject? {
+        private fun findTargetClass(editor: Editor, file: PsiFile): KtClassOrObject? {
             val elementAtCaret = file.findElementAt(editor.caretModel.offset) ?: return null
-            return elementAtCaret.parentsWithSelf.filterIsInstance<JetClassOrObject>().firstOrNull { !it.isLocal() }
+            return elementAtCaret.parentsWithSelf.filterIsInstance<KtClassOrObject>().firstOrNull { !it.isLocal() }
         }
 
         private fun chooseAndPerform(editor: Editor, frameworks: List<TestFramework>, consumer: (TestFramework) -> Unit) {
@@ -94,37 +94,37 @@ abstract class KotlinGenerateTestSupportActionBase(
     }
 
     public class SetUp : KotlinGenerateTestSupportActionBase(MethodKind.SET_UP) {
-        override fun isApplicableTo(framework: TestFramework, targetClass: JetClassOrObject): Boolean {
+        override fun isApplicableTo(framework: TestFramework, targetClass: KtClassOrObject): Boolean {
             return framework.findSetUpMethod(targetClass.toLightClass()!!) == null
         }
     }
 
     public class Test : KotlinGenerateTestSupportActionBase(MethodKind.TEST) {
-        override fun isApplicableTo(framework: TestFramework, targetClass: JetClassOrObject) = true
+        override fun isApplicableTo(framework: TestFramework, targetClass: KtClassOrObject) = true
     }
 
     public class Data : KotlinGenerateTestSupportActionBase(MethodKind.DATA) {
-        override fun isApplicableTo(framework: TestFramework, targetClass: JetClassOrObject): Boolean {
+        override fun isApplicableTo(framework: TestFramework, targetClass: KtClassOrObject): Boolean {
             if (framework !is JavaTestFramework) return false
             return framework.findParametersMethod(targetClass.toLightClass()) == null
         }
     }
 
     public class TearDown : KotlinGenerateTestSupportActionBase(MethodKind.TEAR_DOWN) {
-        override fun isApplicableTo(framework: TestFramework, targetClass: JetClassOrObject): Boolean {
+        override fun isApplicableTo(framework: TestFramework, targetClass: KtClassOrObject): Boolean {
             return framework.findTearDownMethod(targetClass.toLightClass()!!) == null
         }
     }
 
-    override fun getTargetClass(editor: Editor, file: PsiFile): JetClassOrObject? {
+    override fun getTargetClass(editor: Editor, file: PsiFile): KtClassOrObject? {
         return findTargetClass(editor, file)
     }
 
-    override fun isValidForClass(targetClass: JetClassOrObject): Boolean {
+    override fun isValidForClass(targetClass: KtClassOrObject): Boolean {
         return findSuitableFrameworks(targetClass).any { isApplicableTo(it, targetClass) }
     }
 
-    protected abstract fun isApplicableTo(framework: TestFramework, targetClass: JetClassOrObject): Boolean
+    protected abstract fun isApplicableTo(framework: TestFramework, targetClass: KtClassOrObject): Boolean
 
     override fun invoke(project: Project, editor: Editor, file: PsiFile) {
         val klass = findTargetClass(editor, file) ?: return
@@ -133,7 +133,7 @@ abstract class KotlinGenerateTestSupportActionBase(
         chooseAndPerform(editor, frameworks) { doGenerate(editor, file, klass, it) }
     }
 
-    private fun doGenerate(editor: Editor, file: PsiFile, klass: JetClassOrObject, framework: TestFramework) {
+    private fun doGenerate(editor: Editor, file: PsiFile, klass: KtClassOrObject, framework: TestFramework) {
         val project = file.project
         val commandName = "Generate test function"
         project.executeWriteCommand(commandName) {
@@ -155,7 +155,7 @@ abstract class KotlinGenerateTestSupportActionBase(
                 val factory = PsiElementFactory.SERVICE.getInstance(project)
                 val psiMethod = factory.createMethodFromText(templateText, null)
                 psiMethod.throwsList.referenceElements.forEach { it.delete() }
-                val function = psiMethod.j2k() as? JetNamedFunction
+                val function = psiMethod.j2k() as? KtNamedFunction
                 if (function == null) {
                     HintManager.getInstance().showErrorHint(editor, "Couldn't convert Java template to Kotlin")
                     return@executeWriteCommand
@@ -170,10 +170,10 @@ abstract class KotlinGenerateTestSupportActionBase(
                     else -> generateUnsupportedOrSuperCall(overriddenDescriptors.first(), BodyType.QUALIFIED_SUPER)
                 }
                 functionInPlace.bodyExpression?.delete()
-                functionInPlace.add(JetPsiFactory(project).createBlock(bodyText))
+                functionInPlace.add(KtPsiFactory(project).createBlock(bodyText))
 
                 if (overriddenDescriptors.isNotEmpty()) {
-                    functionInPlace.addModifier(JetTokens.OVERRIDE_KEYWORD)
+                    functionInPlace.addModifier(KtTokens.OVERRIDE_KEYWORD)
                 }
 
                 setupEditorSelection(editor, functionInPlace)
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/internal/CheckPartialBodyResolveAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/internal/CheckPartialBodyResolveAction.kt
index 2d79366e684..1e21b6be761 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/internal/CheckPartialBodyResolveAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/internal/CheckPartialBodyResolveAction.kt
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.psi.psiUtil.siblings
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import java.util.ArrayList
 import javax.swing.SwingUtilities
@@ -62,7 +62,7 @@ public class CheckPartialBodyResolveAction : AnAction() {
                 project)
     }
 
-    private fun checkResolve(files: Collection<JetFile>, project: Project) {
+    private fun checkResolve(files: Collection<KtFile>, project: Project) {
         //TODO: drop resolve caches if any
         val progressIndicator = ProgressManager.getInstance().getProgressIndicator()
         for ((i, file) in files.withIndex()) {
@@ -104,21 +104,21 @@ public class CheckPartialBodyResolveAction : AnAction() {
         }
     }
 
-    private fun dumpResolve(file: JetFile, resolver: (JetElement, ResolutionFacade) -> BindingContext): String {
+    private fun dumpResolve(file: KtFile, resolver: (KtElement, ResolutionFacade) -> BindingContext): String {
         val builder = StringBuilder()
         val resolutionFacade = file.getResolutionFacade()
         val document = FileDocumentManager.getInstance().getDocument(file.getVirtualFile())!!
-        file.acceptChildren(object : JetVisitorVoid(){
-            override fun visitJetElement(element: JetElement) {
+        file.acceptChildren(object : KtVisitorVoid(){
+            override fun visitJetElement(element: KtElement) {
                 ProgressManager.checkCanceled()
                 element.acceptChildren(this)
             }
 
-            override fun visitExpression(expression: JetExpression) {
+            override fun visitExpression(expression: KtExpression) {
                 super.visitExpression(expression)
 
                 // do not try to resolve to declaration as it crashes on some declaration (namely JetClassInitializer)
-                if (expression is JetDeclaration) return
+                if (expression is KtDeclaration) return
 
                 if (!isValueNeeded(expression)) return
 
@@ -127,10 +127,10 @@ public class CheckPartialBodyResolveAction : AnAction() {
                 val offset = expression.getTextOffset()
                 val line = document.getLineNumber(offset)
                 val column = offset - document.getLineStartOffset(line)
-                val exprName = if (expression is JetNameReferenceExpression) expression.getReferencedName() else expression.javaClass.getSimpleName()
+                val exprName = if (expression is KtNameReferenceExpression) expression.getReferencedName() else expression.javaClass.getSimpleName()
                 builder.append("$exprName at (${line + 1}:${column + 1})")
 
-                if (expression is JetReferenceExpression) {
+                if (expression is KtReferenceExpression) {
                     val target = bindingContext[BindingContext.REFERENCE_TARGET, expression]
                     builder.append(" resolves to ${target?.presentation()}")
                 }
@@ -147,7 +147,7 @@ public class CheckPartialBodyResolveAction : AnAction() {
     }
 
     private fun DeclarationDescriptor.presentation() = DescriptorRenderer.FQ_NAMES_IN_TYPES.render(this)
-    private fun JetType.presentation() = DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(this)
+    private fun KtType.presentation() = DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(this)
 
     override fun update(e: AnActionEvent) {
         if (!KotlinInternalMode.enabled) {
@@ -158,17 +158,17 @@ public class CheckPartialBodyResolveAction : AnAction() {
         e.getPresentation().setEnabled(selectedKotlinFiles(e).any())
     }
 
-    private fun selectedKotlinFiles(e: AnActionEvent): Sequence<JetFile> {
+    private fun selectedKotlinFiles(e: AnActionEvent): Sequence<KtFile> {
         val virtualFiles = e.getData(CommonDataKeys.VIRTUAL_FILE_ARRAY) ?: return sequenceOf()
         val project = CommonDataKeys.PROJECT.getData(e.getDataContext()) ?: return sequenceOf()
         return allKotlinFiles(virtualFiles, project)
     }
 
-    private fun allKotlinFiles(filesOrDirs: Array<VirtualFile>, project: Project): Sequence<JetFile> {
+    private fun allKotlinFiles(filesOrDirs: Array<VirtualFile>, project: Project): Sequence<KtFile> {
         val manager = PsiManager.getInstance(project)
         return allFiles(filesOrDirs)
                 .asSequence()
-                .map { manager.findFile(it) as? JetFile }
+                .map { manager.findFile(it) as? KtFile }
                 .filterNotNull()
     }
 
@@ -186,17 +186,17 @@ public class CheckPartialBodyResolveAction : AnAction() {
     }
 
     //TODO: currently copied from PartialBodyResolveFilter - not good
-    private fun isValueNeeded(expression: JetExpression): Boolean {
+    private fun isValueNeeded(expression: KtExpression): Boolean {
         val parent = expression.getParent()
         return when (parent) {
-            is JetBlockExpression -> expression == parent.lastStatement() && isValueNeeded(parent)
+            is KtBlockExpression -> expression == parent.lastStatement() && isValueNeeded(parent)
 
-            is JetContainerNode -> { //TODO - not quite correct
-                val pparent = parent.getParent() as? JetExpression
+            is KtContainerNode -> { //TODO - not quite correct
+                val pparent = parent.getParent() as? KtExpression
                 pparent != null && isValueNeeded(pparent)
             }
 
-            is JetDeclarationWithBody -> {
+            is KtDeclarationWithBody -> {
                 if (expression == parent.getBodyExpression())
                     !parent.hasBlockBody() && !parent.hasDeclaredReturnType()
                 else
@@ -207,6 +207,6 @@ public class CheckPartialBodyResolveAction : AnAction() {
         }
     }
 
-    private fun JetBlockExpression.lastStatement(): JetExpression?
-            = getLastChild()?.siblings(forward = false)?.firstIsInstanceOrNull<JetExpression>()
+    private fun KtBlockExpression.lastStatement(): KtExpression?
+            = getLastChild()?.siblings(forward = false)?.firstIsInstanceOrNull<KtExpression>()
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/internal/CopyAsDiagnosticTestAction.java b/idea/src/org/jetbrains/kotlin/idea/actions/internal/CopyAsDiagnosticTestAction.java
index 1f351df7b88..571a40c651f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/internal/CopyAsDiagnosticTestAction.java
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/internal/CopyAsDiagnosticTestAction.java
@@ -25,7 +25,7 @@ import com.intellij.psi.PsiFile;
 import org.jetbrains.kotlin.checkers.CheckerTestUtil;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 
 import java.awt.*;
@@ -42,7 +42,7 @@ public class CopyAsDiagnosticTestAction extends AnAction {
         PsiFile psiFile = e.getData(CommonDataKeys.PSI_FILE);
         assert editor != null && psiFile != null;
 
-        BindingContext bindingContext = ResolutionUtils.analyzeFully((JetFile) psiFile);
+        BindingContext bindingContext = ResolutionUtils.analyzeFully((KtFile) psiFile);
 
         List<Diagnostic> diagnostics = CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(bindingContext, psiFile, false, null);
         String result = CheckerTestUtil.addDiagnosticMarkersToText(psiFile, diagnostics).toString();
@@ -61,7 +61,7 @@ public class CopyAsDiagnosticTestAction extends AnAction {
 
         Editor editor = e.getData(CommonDataKeys.EDITOR);
         PsiFile psiFile = e.getData(CommonDataKeys.PSI_FILE);
-        e.getPresentation().setEnabled(editor != null && psiFile instanceof JetFile);
+        e.getPresentation().setEnabled(editor != null && psiFile instanceof KtFile);
     }
 
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/internal/FindImplicitNothingAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/internal/FindImplicitNothingAction.kt
index 74830ca2c6f..b4f8e1c28ea 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/internal/FindImplicitNothingAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/internal/FindImplicitNothingAction.kt
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.resolve.calls.callUtil.getCalleeExpressionIfAny
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import com.intellij.usages.UsageViewManager
@@ -58,21 +58,21 @@ public class FindImplicitNothingAction : AnAction() {
                 project)
     }
 
-    private fun find(files: Collection<JetFile>, project: Project) {
+    private fun find(files: Collection<KtFile>, project: Project) {
         val progressIndicator = ProgressManager.getInstance().getProgressIndicator()
-        val found = ArrayList<JetCallExpression>()
+        val found = ArrayList<KtCallExpression>()
         for ((i, file) in files.withIndex()) {
             progressIndicator?.setText("Scanning files: $i of ${files.size()} file. ${found.size()} occurences found")
             progressIndicator?.setText2(file.getVirtualFile().getPath())
 
             val resolutionFacade = file.getResolutionFacade()
-            file.acceptChildren(object : JetVisitorVoid() {
-                override fun visitJetElement(element: JetElement) {
+            file.acceptChildren(object : KtVisitorVoid() {
+                override fun visitJetElement(element: KtElement) {
                     ProgressManager.checkCanceled()
                     element.acceptChildren(this)
                 }
 
-                override fun visitCallExpression(expression: JetCallExpression) {
+                override fun visitCallExpression(expression: KtCallExpression) {
                     expression.acceptChildren(this)
 
                     try {
@@ -107,13 +107,13 @@ public class FindImplicitNothingAction : AnAction() {
         }
     }
 
-    private fun JetExpression.hasExplicitNothing(bindingContext: BindingContext): Boolean {
+    private fun KtExpression.hasExplicitNothing(bindingContext: BindingContext): Boolean {
         val callee = getCalleeExpressionIfAny() ?: return false
         when (callee) {
-            is JetSimpleNameExpression -> {
+            is KtSimpleNameExpression -> {
                 val target = bindingContext[BindingContext.REFERENCE_TARGET, callee] ?: return false
                 val callableDescriptor = (target as? CallableDescriptor ?: return false).getOriginal()
-                val declaration = DescriptorToSourceUtils.descriptorToDeclaration(callableDescriptor) as? JetCallableDeclaration
+                val declaration = DescriptorToSourceUtils.descriptorToDeclaration(callableDescriptor) as? KtCallableDeclaration
                 if (declaration != null && declaration.getTypeReference() == null) return false // implicit type
                 val type = callableDescriptor.getReturnType() ?: return false
                 return type.isNothingOrNothingFunctionType()
@@ -125,7 +125,7 @@ public class FindImplicitNothingAction : AnAction() {
         }
     }
 
-    private fun JetType.isNothingOrNothingFunctionType(): Boolean {
+    private fun KtType.isNothingOrNothingFunctionType(): Boolean {
         return when {
             KotlinBuiltIns.isNothing(this) -> true
 
@@ -144,17 +144,17 @@ public class FindImplicitNothingAction : AnAction() {
         e.getPresentation().setEnabled(selectedKotlinFiles(e).any())
     }
 
-    private fun selectedKotlinFiles(e: AnActionEvent): Sequence<JetFile> {
+    private fun selectedKotlinFiles(e: AnActionEvent): Sequence<KtFile> {
         val virtualFiles = e.getData(CommonDataKeys.VIRTUAL_FILE_ARRAY) ?: return sequenceOf()
         val project = CommonDataKeys.PROJECT.getData(e.getDataContext()) ?: return sequenceOf()
         return allKotlinFiles(virtualFiles, project)
     }
 
-    private fun allKotlinFiles(filesOrDirs: Array<VirtualFile>, project: Project): Sequence<JetFile> {
+    private fun allKotlinFiles(filesOrDirs: Array<VirtualFile>, project: Project): Sequence<KtFile> {
         val manager = PsiManager.getInstance(project)
         return allFiles(filesOrDirs)
                 .asSequence()
-                .map { manager.findFile(it) as? JetFile }
+                .map { manager.findFile(it) as? KtFile }
                 .filterNotNull()
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/caches/JetGotoClassContributor.java b/idea/src/org/jetbrains/kotlin/idea/caches/JetGotoClassContributor.java
index 4b38a9718cb..d2acb839a32 100644
--- a/idea/src/org/jetbrains/kotlin/idea/caches/JetGotoClassContributor.java
+++ b/idea/src/org/jetbrains/kotlin/idea/caches/JetGotoClassContributor.java
@@ -25,9 +25,9 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.stubindex.JetClassShortNameIndex;
 import org.jetbrains.kotlin.idea.stubindex.JetSourceFilterScope;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetEnumEntry;
-import org.jetbrains.kotlin.psi.JetNamedDeclaration;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtEnumEntry;
+import org.jetbrains.kotlin.psi.KtNamedDeclaration;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -36,8 +36,8 @@ import java.util.List;
 public class JetGotoClassContributor implements GotoClassContributor {
     @Override
     public String getQualifiedName(NavigationItem item) {
-        if (item instanceof JetNamedDeclaration) {
-            JetNamedDeclaration jetClass = (JetNamedDeclaration) item;
+        if (item instanceof KtNamedDeclaration) {
+            KtNamedDeclaration jetClass = (KtNamedDeclaration) item;
             FqName name = jetClass.getFqName();
             if (name != null) {
                 return name.asString();
@@ -62,7 +62,7 @@ public class JetGotoClassContributor implements GotoClassContributor {
     @Override
     public NavigationItem[] getItemsByName(String name, String pattern, Project project, boolean includeNonProjectItems) {
         GlobalSearchScope scope = includeNonProjectItems ? GlobalSearchScope.allScope(project) : GlobalSearchScope.projectScope(project);
-        Collection<JetClassOrObject> classesOrObjects =
+        Collection<KtClassOrObject> classesOrObjects =
                 JetClassShortNameIndex.getInstance().get(name, project, JetSourceFilterScope.kotlinSourceAndClassFiles(scope, project));
 
         if (classesOrObjects.isEmpty()) {
@@ -70,8 +70,8 @@ public class JetGotoClassContributor implements GotoClassContributor {
         }
 
         List<NavigationItem> items = new ArrayList<NavigationItem>();
-        for (JetClassOrObject classOrObject : classesOrObjects) {
-            if (classOrObject != null && !(classOrObject instanceof JetEnumEntry)) {
+        for (KtClassOrObject classOrObject : classesOrObjects) {
+            if (classOrObject != null && !(classOrObject instanceof KtEnumEntry)) {
                 items.add(classOrObject);
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/CodeInsightUtils.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/CodeInsightUtils.java
index 9d77ef82822..50e08f0fede 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/CodeInsightUtils.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/CodeInsightUtils.java
@@ -31,11 +31,11 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.ClassKind;
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.scopes.receivers.Qualifier;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -46,33 +46,33 @@ import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.*;
 public class CodeInsightUtils {
 
     @Nullable
-    public static JetExpression findExpression(@NotNull PsiFile file, int startOffset, int endOffset) {
-        PsiElement element = findElementOfClassAtRange(file, startOffset, endOffset, JetExpression.class);
+    public static KtExpression findExpression(@NotNull PsiFile file, int startOffset, int endOffset) {
+        PsiElement element = findElementOfClassAtRange(file, startOffset, endOffset, KtExpression.class);
         if (element == null) return null;
 
         // TODO: Support binary operations in "Introduce..." refactorings
-        if (element instanceof JetOperationReferenceExpression
-            && ((JetOperationReferenceExpression) element).getReferencedNameElementType() != JetTokens.IDENTIFIER
-            && element.getParent() instanceof JetBinaryExpression) {
+        if (element instanceof KtOperationReferenceExpression
+            && ((KtOperationReferenceExpression) element).getReferencedNameElementType() != KtTokens.IDENTIFIER
+            && element.getParent() instanceof KtBinaryExpression) {
             return null;
         }
 
         // For cases like 'this@outerClass', don't return the label part
-        if (JetPsiUtil.isLabelIdentifierExpression(element)) {
-            element = PsiTreeUtil.getParentOfType(element, JetExpression.class);
+        if (KtPsiUtil.isLabelIdentifierExpression(element)) {
+            element = PsiTreeUtil.getParentOfType(element, KtExpression.class);
         }
 
-        if (element instanceof JetBlockExpression) {
-            List<JetExpression> statements = ((JetBlockExpression) element).getStatements();
+        if (element instanceof KtBlockExpression) {
+            List<KtExpression> statements = ((KtBlockExpression) element).getStatements();
             if (statements.size() == 1) {
-                JetExpression statement = statements.get(0);
+                KtExpression statement = statements.get(0);
                 if (statement.getText().equals(element.getText())) {
                     return statement;
                 }
             }
         }
 
-        JetExpression expression = (JetExpression) element;
+        KtExpression expression = (KtExpression) element;
 
         BindingContext context = ResolutionUtils.analyze(expression);
 
@@ -100,8 +100,8 @@ public class CodeInsightUtils {
         PsiElement parent = PsiTreeUtil.findCommonParent(element1, element2);
         if (parent == null) return PsiElement.EMPTY_ARRAY;
         while (true) {
-            if (parent instanceof JetBlockExpression) break;
-            if (parent == null || parent instanceof JetFile) return PsiElement.EMPTY_ARRAY;
+            if (parent instanceof KtBlockExpression) break;
+            if (parent == null || parent instanceof KtFile) return PsiElement.EMPTY_ARRAY;
             parent = parent.getParent();
         }
 
@@ -120,8 +120,8 @@ public class CodeInsightUtils {
         }
 
         for (PsiElement element : array) {
-            if (!(element instanceof JetExpression
-                  || element.getNode().getElementType() == JetTokens.SEMICOLON
+            if (!(element instanceof KtExpression
+                  || element.getNode().getElementType() == KtTokens.SEMICOLON
                   || element instanceof PsiWhiteSpace
                   || element instanceof PsiComment)) {
                 return PsiElement.EMPTY_ARRAY;
@@ -132,7 +132,7 @@ public class CodeInsightUtils {
     }
 
     @Nullable
-    public static PsiElement findElementOfClassAtRange(@NotNull PsiFile file, int startOffset, int endOffset, Class<JetExpression> aClass) {
+    public static PsiElement findElementOfClassAtRange(@NotNull PsiFile file, int startOffset, int endOffset, Class<KtExpression> aClass) {
         // When selected range is this@Fo<select>o</select> we'd like to return `@Foo`
         // But it's PSI looks like: (AT IDENTIFIER):JetLabel
         // So if we search parent starting exactly at IDENTIFIER then we find nothing
@@ -145,17 +145,17 @@ public class CodeInsightUtils {
         startOffset = element1.getTextRange().getStartOffset();
         endOffset = element2.getTextRange().getEndOffset();
 
-        JetExpression jetExpression = PsiTreeUtil.findElementOfClassAtRange(file, startOffset, endOffset, aClass);
-        if (jetExpression == null ||
-            jetExpression.getTextRange().getStartOffset() != startOffset ||
-            jetExpression.getTextRange().getEndOffset() != endOffset) {
+        KtExpression ktExpression = PsiTreeUtil.findElementOfClassAtRange(file, startOffset, endOffset, aClass);
+        if (ktExpression == null ||
+            ktExpression.getTextRange().getStartOffset() != startOffset ||
+            ktExpression.getTextRange().getEndOffset() != endOffset) {
             return null;
         }
-        return jetExpression;
+        return ktExpression;
     }
 
     private static PsiElement getParentLabelOrElement(@Nullable PsiElement element) {
-        if (element != null && element.getParent() instanceof JetLabelReferenceExpression) {
+        if (element != null && element.getParent() instanceof KtLabelReferenceExpression) {
             return element.getParent();
         }
         return element;
@@ -223,7 +223,7 @@ public class CodeInsightUtils {
     }
 
     @Nullable
-    public static String defaultInitializer(JetType type) {
+    public static String defaultInitializer(KtType type) {
         if (type.isMarkedNullable()) {
             return "null";
         }
@@ -294,7 +294,7 @@ public class CodeInsightUtils {
     public static PsiElement getTopmostElementAtOffset(@NotNull PsiElement element, int offset) {
         do {
             PsiElement parent = element.getParent();
-            if (parent == null || (parent.getTextOffset() < offset) || parent instanceof JetBlockExpression) {
+            if (parent == null || (parent.getTextOffset() < offset) || parent instanceof KtBlockExpression) {
                 break;
             }
             element = parent;
@@ -312,7 +312,7 @@ public class CodeInsightUtils {
         }
         do {
             PsiElement parent = element.getParent();
-            if (parent == null || (parent.getTextOffset() < offset) || parent instanceof JetBlockExpression) {
+            if (parent == null || (parent.getTextOffset() < offset) || parent instanceof KtBlockExpression) {
                 break;
             }
             if (klass.isInstance(parent)) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/GotoSuperActionHandler.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/GotoSuperActionHandler.java
index e96efedd851..0580a98fd90 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/GotoSuperActionHandler.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/GotoSuperActionHandler.java
@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.OverrideResolver;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collection;
 import java.util.List;
@@ -53,12 +53,12 @@ public class GotoSuperActionHandler implements CodeInsightActionHandler {
 
         PsiElement element = file.findElementAt(editor.getCaretModel().getOffset());
         if (element == null) return;
-        @SuppressWarnings("unchecked") JetDeclaration declaration =
+        @SuppressWarnings("unchecked") KtDeclaration declaration =
                 PsiTreeUtil.getParentOfType(element,
-                                            JetNamedFunction.class,
-                                            JetClass.class,
-                                            JetProperty.class,
-                                            JetObjectDeclaration.class);
+                                            KtNamedFunction.class,
+                                            KtClass.class,
+                                            KtProperty.class,
+                                            KtObjectDeclaration.class);
         if (declaration == null) return;
 
         DeclarationDescriptor descriptor = ResolutionUtils.resolveToDescriptor(declaration);
@@ -103,10 +103,10 @@ public class GotoSuperActionHandler implements CodeInsightActionHandler {
     private static List<PsiElement> findSuperDeclarations(DeclarationDescriptor descriptor) {
         Collection<? extends DeclarationDescriptor> superDescriptors;
         if (descriptor instanceof ClassDescriptor) {
-            Collection<JetType> supertypes = ((ClassDescriptor) descriptor).getTypeConstructor().getSupertypes();
-            List<ClassDescriptor> superclasses = ContainerUtil.mapNotNull(supertypes, new Function<JetType, ClassDescriptor>() {
+            Collection<KtType> supertypes = ((ClassDescriptor) descriptor).getTypeConstructor().getSupertypes();
+            List<ClassDescriptor> superclasses = ContainerUtil.mapNotNull(supertypes, new Function<KtType, ClassDescriptor>() {
                 @Override
-                public ClassDescriptor fun(JetType type) {
+                public ClassDescriptor fun(KtType type) {
                     ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
                     if (descriptor instanceof ClassDescriptor) {
                         return (ClassDescriptor) descriptor;
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/JetFunctionPsiElementCellRenderer.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/JetFunctionPsiElementCellRenderer.java
index b0c41664e1b..3583f6faa0a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/JetFunctionPsiElementCellRenderer.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/JetFunctionPsiElementCellRenderer.java
@@ -20,14 +20,14 @@ import com.intellij.ide.util.DefaultPsiElementCellRenderer;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 
 public class JetFunctionPsiElementCellRenderer extends DefaultPsiElementCellRenderer {
     @Override
     public String getElementText(PsiElement element) {
-        if (element instanceof JetNamedFunction) {
-            JetNamedFunction function = (JetNamedFunction) element;
+        if (element instanceof KtNamedFunction) {
+            KtNamedFunction function = (KtNamedFunction) element;
             DeclarationDescriptor descriptor = ResolutionUtils.resolveToDescriptor(function);
             return DescriptorRenderer.SHORT_NAMES_IN_TYPES.render(descriptor);
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/JetTypeDeclarationProvider.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/JetTypeDeclarationProvider.java
index f914a358744..4a6afa937fe 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/JetTypeDeclarationProvider.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/JetTypeDeclarationProvider.java
@@ -22,20 +22,20 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtElement;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public class JetTypeDeclarationProvider implements TypeDeclarationProvider {
     @Override
     public PsiElement[] getSymbolTypeDeclarations(PsiElement symbol) {
-        if (symbol instanceof JetElement && symbol.getContainingFile() instanceof JetFile) {
-            BindingContext bindingContext = ResolutionUtils.analyze((JetElement)symbol);
+        if (symbol instanceof KtElement && symbol.getContainingFile() instanceof KtFile) {
+            BindingContext bindingContext = ResolutionUtils.analyze((KtElement)symbol);
             DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, symbol);
             if (descriptor instanceof CallableDescriptor) {
-                JetType type = ((CallableDescriptor) descriptor).getReturnType();
+                KtType type = ((CallableDescriptor) descriptor).getReturnType();
                 if (type != null) {
                     ClassifierDescriptor classifierDescriptor = type.getConstructor().getDeclarationDescriptor();
                     if (classifierDescriptor != null) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt
index 91d0c503fe1..e6f4aa29f7a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt
@@ -52,7 +52,7 @@ import org.jetbrains.kotlin.psi.psiUtil.elementsInRange
 import org.jetbrains.kotlin.psi.psiUtil.forEachDescendantOfType
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
@@ -65,9 +65,9 @@ import java.util.*
 public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<KotlinReferenceTransferableData>() {
     private val LOG = Logger.getInstance(javaClass<KotlinCopyPasteReferenceProcessor>())
 
-    private val IGNORE_REFERENCES_INSIDE: Array<Class<out JetElement>> = arrayOf(
-            javaClass<JetImportList>(),
-            javaClass<JetPackageDirective>()
+    private val IGNORE_REFERENCES_INSIDE: Array<Class<out KtElement>> = arrayOf(
+            javaClass<KtImportList>(),
+            javaClass<KtPackageDirective>()
     )
 
     override fun extractTransferableData(content: Transferable): List<KotlinReferenceTransferableData> {
@@ -93,7 +93,7 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
             startOffsets: IntArray,
             endOffsets: IntArray
     ): List<KotlinReferenceTransferableData> {
-        if (file !is JetFile || DumbService.getInstance(file.getProject()).isDumb()) return listOf()
+        if (file !is KtFile || DumbService.getInstance(file.getProject()).isDumb()) return listOf()
 
         val collectedData = try {
             collectReferenceData(file, startOffsets, endOffsets)
@@ -115,7 +115,7 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
     }
 
     public fun collectReferenceData(
-            file: JetFile,
+            file: KtFile,
             startOffsets: IntArray,
             endOffsets: IntArray
     ): List<KotlinReferenceData> {
@@ -130,19 +130,19 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
 
     private fun MutableCollection<KotlinReferenceData>.addReferenceDataInsideElement(
             element: PsiElement,
-            file: JetFile,
+            file: KtFile,
             startOffset: Int,
             startOffsets: IntArray,
             endOffsets: IntArray
     ) {
         if (PsiTreeUtil.getNonStrictParentOfType(element, *IGNORE_REFERENCES_INSIDE) != null) return
 
-        element.forEachDescendantOfType<JetElement>(canGoInside = { it.javaClass !in IGNORE_REFERENCES_INSIDE }) { element ->
+        element.forEachDescendantOfType<KtElement>(canGoInside = { it.javaClass !in IGNORE_REFERENCES_INSIDE }) { element ->
             val reference = element.mainReference ?: return@forEachDescendantOfType
 
             val descriptors = reference.resolveToDescriptors(element.analyze()) //TODO: we could use partial body resolve for all references together
             //check whether this reference is unambiguous
-            if (reference !is JetMultiReference<*> && descriptors.size() > 1) return@forEachDescendantOfType
+            if (reference !is KtMultiReference<*> && descriptors.size() > 1) return@forEachDescendantOfType
 
             for (descriptor in descriptors) {
                 val declarations = DescriptorToSourceUtilsIde.getAllDeclarations(file.getProject(), descriptor)
@@ -160,7 +160,7 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
     }
 
     private data class ReferenceToRestoreData(
-            val reference: JetReference,
+            val reference: KtReference,
             val refData: KotlinReferenceData
     )
 
@@ -176,14 +176,14 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
 
         val document = editor.getDocument()
         val file = PsiDocumentManager.getInstance(project).getPsiFile(document)
-        if (file !is JetFile) return
+        if (file !is KtFile) return
 
         val referenceData = values.single().data
 
         processReferenceData(project, file, bounds.getStartOffset(), referenceData)
     }
 
-    public fun processReferenceData(project: Project, file: JetFile, blockStart: Int, referenceData: Array<KotlinReferenceData>) {
+    public fun processReferenceData(project: Project, file: KtFile, blockStart: Int, referenceData: Array<KotlinReferenceData>) {
         PsiDocumentManager.getInstance(project).commitAllDocuments()
 
         val referencesPossibleToRestore = findReferencesToRestore(file, blockStart, referenceData)
@@ -197,7 +197,7 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
     }
 
     private fun findReferencesToRestore(file: PsiFile, blockStart: Int, referenceData: Array<out KotlinReferenceData>): List<ReferenceToRestoreData> {
-        if (file !is JetFile) return listOf()
+        if (file !is KtFile) return listOf()
 
         val fileResolutionScope = file.getResolutionFacade().getFileTopLevelScope(file)
         return referenceData.map {
@@ -209,14 +209,14 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
         }.filterNotNull()
     }
 
-    private fun findReference(data: KotlinReferenceData, file: JetFile, blockStart: Int): JetReference? {
+    private fun findReference(data: KotlinReferenceData, file: KtFile, blockStart: Int): KtReference? {
         val startOffset = data.startOffset + blockStart
         val endOffset = data.endOffset + blockStart
         val element = file.findElementAt(startOffset) ?: return null
         val desiredRange = TextRange(startOffset, endOffset)
         for (current in element.parentsWithSelf) {
             val range = current.range
-            if (current is JetElement && range == desiredRange) {
+            if (current is KtElement && range == desiredRange) {
                 current.mainReference?.let { return it }
             }
             if (range !in desiredRange) return null
@@ -224,7 +224,7 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
         return null
     }
 
-    private fun createReferenceToRestoreData(reference: JetReference, refData: KotlinReferenceData, file: JetFile, fileResolutionScope: JetScope): ReferenceToRestoreData? {
+    private fun createReferenceToRestoreData(reference: KtReference, refData: KotlinReferenceData, file: KtFile, fileResolutionScope: KtScope): ReferenceToRestoreData? {
         val originalFqName = FqName(refData.fqName)
 
         if (refData.kind == KotlinReferenceData.Kind.EXTENSION_FUNCTION) {
@@ -258,12 +258,12 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
         return ReferenceToRestoreData(reference, refData)
     }
 
-    private fun restoreReferences(referencesToRestore: Collection<ReferenceToRestoreData>, file: JetFile) {
+    private fun restoreReferences(referencesToRestore: Collection<ReferenceToRestoreData>, file: KtFile) {
         val importHelper = ImportInsertHelper.getInstance(file.getProject())
         val smartPointerManager = SmartPointerManager.getInstance(file.getProject())
 
         data class BindingRequest(
-                val pointer: SmartPsiElementPointer<JetSimpleNameExpression>,
+                val pointer: SmartPsiElementPointer<KtSimpleNameExpression>,
                 val fqName: FqName
         )
 
@@ -272,7 +272,7 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
         for ((reference, refData) in referencesToRestore) {
             val fqName = FqName(refData.fqName)
 
-            if (!refData.kind.isExtension() && reference is JetSimpleNameReference) {
+            if (!refData.kind.isExtension() && reference is KtSimpleNameReference) {
                 val pointer = smartPointerManager.createSmartPsiElementPointer(reference.getElement(), file)
                 bindingRequests.add(BindingRequest(pointer, fqName))
             }
@@ -287,7 +287,7 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
         }
         for ((pointer, fqName) in bindingRequests) {
             val reference = pointer.getElement()!!.mainReference
-            reference.bindToFqName(fqName, JetSimpleNameReference.ShorteningMode.DELAYED_SHORTENING)
+            reference.bindToFqName(fqName, KtSimpleNameReference.ShorteningMode.DELAYED_SHORTENING)
         }
         performDelayedShortening(file.getProject())
     }
@@ -295,14 +295,14 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
     private fun KotlinReferenceData.Kind.isExtension()
             = this == KotlinReferenceData.Kind.EXTENSION_FUNCTION || this == KotlinReferenceData.Kind.EXTENSION_PROPERTY
 
-    private fun findImportableDescriptors(fqName: FqName, file: JetFile): Collection<DeclarationDescriptor> {
+    private fun findImportableDescriptors(fqName: FqName, file: KtFile): Collection<DeclarationDescriptor> {
         return file.resolveImportReference(fqName).filterNot {
             /*TODO: temporary hack until we don't have ability to insert qualified reference into root package*/
             DescriptorUtils.getParentOfType(it, javaClass<PackageFragmentDescriptor>())?.fqName?.isRoot() ?: false
         }
     }
 
-    private fun findCallableToImport(fqName: FqName, file: JetFile): CallableDescriptor?
+    private fun findCallableToImport(fqName: FqName, file: KtFile): CallableDescriptor?
             = findImportableDescriptors(fqName, file).firstIsInstanceOrNull<CallableDescriptor>()
 
     private fun showRestoreReferencesDialog(project: Project, referencesToRestore: List<ReferenceToRestoreData>): Collection<ReferenceToRestoreData> {
@@ -329,7 +329,7 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
         return startOffsets.indices.map { TextRange(startOffsets[it], endOffsets[it]) }
     }
 
-    private fun PsiElement.isInCopiedArea(fileCopiedFrom: JetFile, startOffsets: IntArray, endOffsets: IntArray): Boolean {
+    private fun PsiElement.isInCopiedArea(fileCopiedFrom: KtFile, startOffsets: IntArray, endOffsets: IntArray): Boolean {
         if (getContainingFile() != fileCopiedFrom) return false
         return toTextRanges(startOffsets, endOffsets).any { this.range in it }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinExpressionTypeProvider.kt b/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinExpressionTypeProvider.kt
index a4841259987..80474ad9fc7 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinExpressionTypeProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinExpressionTypeProvider.kt
@@ -19,20 +19,20 @@ package org.jetbrains.kotlin.idea.codeInsight
 import com.intellij.lang.ExpressionTypeProvider
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.idea.actions.ShowExpressionTypeAction
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetFunction
-import org.jetbrains.kotlin.psi.JetStatementExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.psi.KtStatementExpression
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 
-class KotlinExpressionTypeProvider : ExpressionTypeProvider<JetExpression>() {
-    override fun getExpressionsAt(elementAt: PsiElement): List<JetExpression> =
-            elementAt.parentsWithSelf.filterIsInstance<JetExpression>().filterNot { it.shouldSkip() }.toArrayList()
+class KotlinExpressionTypeProvider : ExpressionTypeProvider<KtExpression>() {
+    override fun getExpressionsAt(elementAt: PsiElement): List<KtExpression> =
+            elementAt.parentsWithSelf.filterIsInstance<KtExpression>().filterNot { it.shouldSkip() }.toArrayList()
 
-    private fun JetExpression.shouldSkip(): Boolean {
-        return this is JetStatementExpression && this !is JetFunction
+    private fun KtExpression.shouldSkip(): Boolean {
+        return this is KtStatementExpression && this !is KtFunction
     }
 
-    override fun getInformationHint(element: JetExpression): String {
+    override fun getInformationHint(element: KtExpression): String {
         val type = ShowExpressionTypeAction.typeByExpression(element) ?: return "Type is unknown"
         return ShowExpressionTypeAction.renderTypeHint(type)
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/spellchecker/KotlinSpellcheckingStrategy.kt b/idea/src/org/jetbrains/kotlin/idea/codeInsight/spellchecker/KotlinSpellcheckingStrategy.kt
index 82d44741e76..85b1360213f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/spellchecker/KotlinSpellcheckingStrategy.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/spellchecker/KotlinSpellcheckingStrategy.kt
@@ -25,10 +25,10 @@ import com.intellij.spellchecker.tokenizer.SpellcheckingStrategy
 import com.intellij.spellchecker.tokenizer.SuppressibleSpellcheckingStrategy
 import com.intellij.spellchecker.tokenizer.Tokenizer
 import com.intellij.spellchecker.tokenizer.TokenizerBase
-import org.jetbrains.kotlin.psi.JetLiteralStringTemplateEntry
+import org.jetbrains.kotlin.psi.KtLiteralStringTemplateEntry
 
 class KotlinSpellcheckingStrategy: SpellcheckingStrategy() {
-    private val plainTextTokenizer = TokenizerBase<JetLiteralStringTemplateEntry>(PlainTextSplitter.getInstance())
+    private val plainTextTokenizer = TokenizerBase<KtLiteralStringTemplateEntry>(PlainTextSplitter.getInstance())
     private val emptyTokenizer = SpellcheckingStrategy.EMPTY_TOKENIZER
 
     override fun getTokenizer(element: PsiElement?): Tokenizer<out PsiElement?> {
@@ -37,7 +37,7 @@ class KotlinSpellcheckingStrategy: SpellcheckingStrategy() {
             element is PsiNameIdentifierOwner || element is PsiComment ->
                 super.getTokenizer(element)
 
-            element is JetLiteralStringTemplateEntry -> plainTextTokenizer
+            element is KtLiteralStringTemplateEntry -> plainTextTokenizer
 
             else ->
                 emptyTokenizer
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/KotlinSurrounderUtils.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/KotlinSurrounderUtils.java
index 6dec769e664..e12ed4b2fbe 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/KotlinSurrounderUtils.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/KotlinSurrounderUtils.java
@@ -22,7 +22,7 @@ import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils;
-import org.jetbrains.kotlin.psi.JetBlockExpression;
+import org.jetbrains.kotlin.psi.KtBlockExpression;
 
 public class KotlinSurrounderUtils {
     public static String SURROUND_WITH = JetBundle.message("surround.with");
@@ -32,7 +32,7 @@ public class KotlinSurrounderUtils {
     }
 
     public static void addStatementsInBlock(
-            @NotNull JetBlockExpression block,
+            @NotNull KtBlockExpression block,
             @NotNull PsiElement[] statements
     ) {
         PsiElement lBrace = block.getFirstChild();
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/MoveDeclarationsOutHelper.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/MoveDeclarationsOutHelper.java
index 596096e49b3..7dc0c943dc5 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/MoveDeclarationsOutHelper.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/MoveDeclarationsOutHelper.java
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.idea.util.ShortenReferences;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -48,10 +48,10 @@ public class MoveDeclarationsOutHelper {
         Project project = container.getProject();
 
         List<PsiElement> resultStatements = new ArrayList<PsiElement>();
-        List<JetProperty> propertiesDeclarations = new ArrayList<JetProperty>();
+        List<KtProperty> propertiesDeclarations = new ArrayList<KtProperty>();
 
         // Dummy element to add new declarations at the beginning
-        JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(project);
+        KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(project);
         PsiElement dummyFirstStatement = container.addBefore(psiFactory.createExpression("dummyStatement"), statements[0]);
 
         try {
@@ -60,14 +60,14 @@ public class MoveDeclarationsOutHelper {
 
             for (PsiElement statement : statements) {
                 if (needToDeclareOut(statement, lastStatementOffset, scope)) {
-                    if (statement instanceof JetProperty && ((JetProperty) statement).getInitializer() != null) {
-                        JetProperty property = (JetProperty) statement;
-                        JetProperty declaration = createVariableDeclaration(property, generateDefaultInitializers);
-                        declaration = (JetProperty) container.addBefore(declaration, dummyFirstStatement);
+                    if (statement instanceof KtProperty && ((KtProperty) statement).getInitializer() != null) {
+                        KtProperty property = (KtProperty) statement;
+                        KtProperty declaration = createVariableDeclaration(property, generateDefaultInitializers);
+                        declaration = (KtProperty) container.addBefore(declaration, dummyFirstStatement);
                         propertiesDeclarations.add(declaration);
                         container.addAfter(psiFactory.createNewLine(), declaration);
 
-                        JetBinaryExpression assignment = createVariableAssignment(property);
+                        KtBinaryExpression assignment = createVariableAssignment(property);
                         resultStatements.add(property.replace(assignment));
                     }
                     else {
@@ -91,22 +91,22 @@ public class MoveDeclarationsOutHelper {
     }
 
     @NotNull
-    private static JetBinaryExpression createVariableAssignment(@NotNull JetProperty property) {
+    private static KtBinaryExpression createVariableAssignment(@NotNull KtProperty property) {
         String propertyName = property.getName();
         assert propertyName != null : "Property should have a name " + property.getText();
-        JetBinaryExpression assignment = (JetBinaryExpression) JetPsiFactoryKt
-                .JetPsiFactory(property).createExpression(propertyName + " = x");
-        JetExpression right = assignment.getRight();
+        KtBinaryExpression assignment = (KtBinaryExpression) KtPsiFactoryKt
+                .KtPsiFactory(property).createExpression(propertyName + " = x");
+        KtExpression right = assignment.getRight();
         assert right != null : "Created binary expression should have a right part " + assignment.getText();
-        JetExpression initializer = property.getInitializer();
+        KtExpression initializer = property.getInitializer();
         assert initializer != null : "Initializer should exist for property " + property.getText();
         right.replace(initializer);
         return assignment;
     }
 
     @NotNull
-    private static JetProperty createVariableDeclaration(@NotNull JetProperty property, boolean generateDefaultInitializers) {
-        JetType propertyType = getPropertyType(property);
+    private static KtProperty createVariableDeclaration(@NotNull KtProperty property, boolean generateDefaultInitializers) {
+        KtType propertyType = getPropertyType(property);
         String defaultInitializer = null;
         if (generateDefaultInitializers && property.isVar()) {
             defaultInitializer = CodeInsightUtils.defaultInitializer(propertyType);
@@ -115,7 +115,7 @@ public class MoveDeclarationsOutHelper {
     }
 
     @NotNull
-    private static JetType getPropertyType(@NotNull JetProperty property) {
+    private static KtType getPropertyType(@NotNull KtProperty property) {
         BindingContext bindingContext = ResolutionUtils.analyze(property, BodyResolveMode.PARTIAL);
 
         VariableDescriptor propertyDescriptor = bindingContext.get(BindingContext.VARIABLE, property);
@@ -124,8 +124,8 @@ public class MoveDeclarationsOutHelper {
     }
 
     @NotNull
-    private static JetProperty createProperty(@NotNull JetProperty property, @NotNull JetType propertyType, @Nullable String initializer) {
-        JetTypeReference typeRef = property.getTypeReference();
+    private static KtProperty createProperty(@NotNull KtProperty property, @NotNull KtType propertyType, @Nullable String initializer) {
+        KtTypeReference typeRef = property.getTypeReference();
         String typeString = null;
         if (typeRef != null) {
             typeString = typeRef.getText();
@@ -134,13 +134,13 @@ public class MoveDeclarationsOutHelper {
             typeString = IdeDescriptorRenderers.SOURCE_CODE.renderType(propertyType);
         }
 
-        return JetPsiFactoryKt.JetPsiFactory(property).createProperty(property.getName(), typeString, property.isVar(), initializer);
+        return KtPsiFactoryKt.KtPsiFactory(property).createProperty(property.getName(), typeString, property.isVar(), initializer);
     }
 
     private static boolean needToDeclareOut(@NotNull PsiElement element, int lastStatementOffset, @NotNull SearchScope scope) {
-        if (element instanceof JetProperty ||
-            element instanceof JetClassOrObject ||
-            element instanceof JetFunction) {
+        if (element instanceof KtProperty ||
+            element instanceof KtClassOrObject ||
+            element instanceof KtFunction) {
 
             PsiReference[] refs = ReferencesSearch.search(element, scope, false).toArray(PsiReference.EMPTY_ARRAY);
             if (refs.length > 0) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinExpressionSurroundDescriptor.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinExpressionSurroundDescriptor.java
index 89a009d729e..c85137b5518 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinExpressionSurroundDescriptor.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinExpressionSurroundDescriptor.java
@@ -22,7 +22,7 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 
 public class KotlinExpressionSurroundDescriptor implements SurroundDescriptor {
 
@@ -37,7 +37,7 @@ public class KotlinExpressionSurroundDescriptor implements SurroundDescriptor {
     @Override
     @NotNull
     public PsiElement[] getElementsToSurround(PsiFile file, int startOffset, int endOffset) {
-        JetExpression expression = CodeInsightUtils.findExpression(file, startOffset, endOffset);
+        KtExpression expression = CodeInsightUtils.findExpression(file, startOffset, endOffset);
         if (expression == null) {
             return PsiElement.EMPTY_ARRAY;
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinExpressionSurrounder.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinExpressionSurrounder.java
index 5565379f132..c4aa60af131 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinExpressionSurrounder.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinExpressionSurrounder.java
@@ -24,11 +24,11 @@ import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
-import org.jetbrains.kotlin.psi.JetCallExpression;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetQualifiedExpression;
+import org.jetbrains.kotlin.psi.KtCallExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtQualifiedExpression;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.isUnit;
 
@@ -36,30 +36,30 @@ public abstract class KotlinExpressionSurrounder implements Surrounder {
 
     @Override
     public boolean isApplicable(@NotNull PsiElement[] elements) {
-        if (elements.length != 1 || !(elements[0] instanceof JetExpression)) {
+        if (elements.length != 1 || !(elements[0] instanceof KtExpression)) {
             return false;
         }
 
-        JetExpression expression = (JetExpression) elements[0];
-        if (expression instanceof JetCallExpression && expression.getParent() instanceof JetQualifiedExpression) {
+        KtExpression expression = (KtExpression) elements[0];
+        if (expression instanceof KtCallExpression && expression.getParent() instanceof KtQualifiedExpression) {
             return false;
         }
-        JetType type = ResolutionUtils.analyze(expression, BodyResolveMode.PARTIAL).getType(expression);
+        KtType type = ResolutionUtils.analyze(expression, BodyResolveMode.PARTIAL).getType(expression);
         if (type == null || isUnit(type)) {
             return false;
         }
         return isApplicable(expression);
     }
 
-    protected abstract boolean isApplicable(@NotNull JetExpression expression);
+    protected abstract boolean isApplicable(@NotNull KtExpression expression);
 
     @Nullable
     @Override
     public TextRange surroundElements(@NotNull Project project, @NotNull Editor editor, @NotNull PsiElement[] elements) {
         assert elements.length == 1 : "KotlinExpressionSurrounder should be applicable only for 1 expression: " + elements.length;
-        return surroundExpression(project, editor, (JetExpression) elements[0]);
+        return surroundExpression(project, editor, (KtExpression) elements[0]);
     }
 
     @Nullable
-    protected abstract TextRange surroundExpression(@NotNull Project project, @NotNull Editor editor, @NotNull JetExpression expression);
+    protected abstract TextRange surroundExpression(@NotNull Project project, @NotNull Editor editor, @NotNull KtExpression expression);
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinNotSurrounder.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinNotSurrounder.java
index cabf2fe34ba..3dbd3eaf184 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinNotSurrounder.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinNotSurrounder.java
@@ -25,12 +25,12 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetParenthesizedExpression;
-import org.jetbrains.kotlin.psi.JetPrefixExpression;
-import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtParenthesizedExpression;
+import org.jetbrains.kotlin.psi.KtPrefixExpression;
+import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public class KotlinNotSurrounder extends KotlinExpressionSurrounder {
     @Override
@@ -39,22 +39,22 @@ public class KotlinNotSurrounder extends KotlinExpressionSurrounder {
     }
 
     @Override
-    public boolean isApplicable(@NotNull JetExpression expression) {
-        JetType type = ResolutionUtils.analyze(expression, BodyResolveMode.PARTIAL).getType(expression);
+    public boolean isApplicable(@NotNull KtExpression expression) {
+        KtType type = ResolutionUtils.analyze(expression, BodyResolveMode.PARTIAL).getType(expression);
         return type != null && KotlinBuiltIns.isBoolean(type);
     }
 
     @Nullable
     @Override
-    public TextRange surroundExpression(@NotNull Project project, @NotNull Editor editor, @NotNull JetExpression expression) {
-        JetPrefixExpression prefixExpr = (JetPrefixExpression) JetPsiFactoryKt.JetPsiFactory(expression).createExpression("!(a)");
-        JetParenthesizedExpression parenthesizedExpression = (JetParenthesizedExpression) prefixExpr.getBaseExpression();
+    public TextRange surroundExpression(@NotNull Project project, @NotNull Editor editor, @NotNull KtExpression expression) {
+        KtPrefixExpression prefixExpr = (KtPrefixExpression) KtPsiFactoryKt.KtPsiFactory(expression).createExpression("!(a)");
+        KtParenthesizedExpression parenthesizedExpression = (KtParenthesizedExpression) prefixExpr.getBaseExpression();
         assert parenthesizedExpression != null : "JetParenthesizedExpression should exists for " + prefixExpr.getText() + " expression";
-        JetExpression expressionWithoutParentheses = parenthesizedExpression.getExpression();
+        KtExpression expressionWithoutParentheses = parenthesizedExpression.getExpression();
         assert expressionWithoutParentheses != null : "JetExpression should exists for " + parenthesizedExpression.getText() + " expression";
         expressionWithoutParentheses.replace(expression);
 
-        expression = (JetExpression) expression.replace(prefixExpr);
+        expression = (KtExpression) expression.replace(prefixExpr);
 
         CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(expression);
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinParenthesesSurrounder.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinParenthesesSurrounder.java
index a648213cdbc..916c7f2e7ab 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinParenthesesSurrounder.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinParenthesesSurrounder.java
@@ -23,9 +23,9 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.TextRange;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetParenthesizedExpression;
-import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtParenthesizedExpression;
+import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
 
 public class KotlinParenthesesSurrounder extends KotlinExpressionSurrounder {
     @Override
@@ -34,20 +34,20 @@ public class KotlinParenthesesSurrounder extends KotlinExpressionSurrounder {
     }
 
     @Override
-    public boolean isApplicable(@NotNull JetExpression expression) {
+    public boolean isApplicable(@NotNull KtExpression expression) {
         return true;
     }
 
     @Nullable
     @Override
-    public TextRange surroundExpression( @NotNull Project project, @NotNull Editor editor, @NotNull JetExpression expression) {
-        JetParenthesizedExpression parenthesizedExpression = (JetParenthesizedExpression) JetPsiFactoryKt
-                .JetPsiFactory(expression).createExpression("(a)");
-        JetExpression expressionWithoutParentheses = parenthesizedExpression.getExpression();
+    public TextRange surroundExpression( @NotNull Project project, @NotNull Editor editor, @NotNull KtExpression expression) {
+        KtParenthesizedExpression parenthesizedExpression = (KtParenthesizedExpression) KtPsiFactoryKt
+                .KtPsiFactory(expression).createExpression("(a)");
+        KtExpression expressionWithoutParentheses = parenthesizedExpression.getExpression();
         assert expressionWithoutParentheses != null : "JetExpression should exists for " + parenthesizedExpression.getText() + " expression";
         expressionWithoutParentheses.replace(expression);
 
-        expression = (JetExpression) expression.replace(parenthesizedExpression);
+        expression = (KtExpression) expression.replace(parenthesizedExpression);
 
         CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(expression);
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinRuntimeTypeCastSurrounder.kt b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinRuntimeTypeCastSurrounder.kt
index 209a6d30be3..d3801e49ff8 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinRuntimeTypeCastSurrounder.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinRuntimeTypeCastSurrounder.kt
@@ -36,23 +36,23 @@ import org.jetbrains.kotlin.idea.util.ShortenReferences
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 
 public class KotlinRuntimeTypeCastSurrounder: KotlinExpressionSurrounder() {
 
-    override fun isApplicable(expression: JetExpression): Boolean {
+    override fun isApplicable(expression: KtExpression): Boolean {
         if (!expression.isPhysical()) return false
         val file = expression.getContainingFile()
-        if (file !is JetCodeFragment) return false
+        if (file !is KtCodeFragment) return false
 
         val type = expression.analyze(BodyResolveMode.PARTIAL).getType(expression) ?: return false
 
-        return TypeUtils.canHaveSubtypes(JetTypeChecker.DEFAULT, type)
+        return TypeUtils.canHaveSubtypes(KotlinTypeChecker.DEFAULT, type)
     }
 
-    override fun surroundExpression(project: Project, editor: Editor, expression: JetExpression): TextRange? {
+    override fun surroundExpression(project: Project, editor: Editor, expression: KtExpression): TextRange? {
         val debuggerContext = DebuggerManagerEx.getInstanceEx(project).getContext()
         val debuggerSession = debuggerContext.getDebuggerSession()
         if (debuggerSession != null) {
@@ -70,12 +70,12 @@ public class KotlinRuntimeTypeCastSurrounder: KotlinExpressionSurrounder() {
 
     private inner class SurroundWithCastWorker(
             private val myEditor: Editor,
-            expression: JetExpression,
+            expression: KtExpression,
             context: DebuggerContextImpl,
             indicator: ProgressIndicator
     ): KotlinRuntimeTypeEvaluator(myEditor, expression, context, indicator) {
 
-        override fun typeCalculationFinished(type: JetType?) {
+        override fun typeCalculationFinished(type: KtType?) {
             if (type == null) return
 
             hold()
@@ -85,13 +85,13 @@ public class KotlinRuntimeTypeCastSurrounder: KotlinExpressionSurrounder() {
                     object : WriteCommandAction<Any>(project, CodeInsightBundle.message("command.name.surround.with.runtime.cast")) {
                         override fun run(result: Result<Any>) {
                             try {
-                                val factory = JetPsiFactory(myElement.getProject())
+                                val factory = KtPsiFactory(myElement.getProject())
 
                                 val fqName = DescriptorUtils.getFqName(type.getConstructor().getDeclarationDescriptor()!!)
-                                val parentCast = factory.createExpression("(expr as " + fqName.asString() + ")") as JetParenthesizedExpression
-                                val cast = parentCast.getExpression() as JetBinaryExpressionWithTypeRHS
+                                val parentCast = factory.createExpression("(expr as " + fqName.asString() + ")") as KtParenthesizedExpression
+                                val cast = parentCast.getExpression() as KtBinaryExpressionWithTypeRHS
                                 cast.getLeft().replace(myElement)
-                                val expr = myElement.replace(parentCast) as JetExpression
+                                val expr = myElement.replace(parentCast) as KtExpression
 
                                 ShortenReferences.DEFAULT.process(expr)
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinStringTemplateSurrounder.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinStringTemplateSurrounder.java
index 54373593ff6..6c9341726bb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinStringTemplateSurrounder.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinStringTemplateSurrounder.java
@@ -32,22 +32,22 @@ public class KotlinStringTemplateSurrounder extends KotlinExpressionSurrounder {
     }
 
     @Override
-    public boolean isApplicable(@NotNull JetExpression expression) {
-        return !(expression instanceof JetStringTemplateExpression);
+    public boolean isApplicable(@NotNull KtExpression expression) {
+        return !(expression instanceof KtStringTemplateExpression);
     }
 
     @Nullable
     @Override
-    public TextRange surroundExpression(@NotNull Project project, @NotNull Editor editor, @NotNull JetExpression expression) {
-        JetStringTemplateExpression stringTemplateExpression = (JetStringTemplateExpression) JetPsiFactoryKt.JetPsiFactory(expression).createExpression(
+    public TextRange surroundExpression(@NotNull Project project, @NotNull Editor editor, @NotNull KtExpression expression) {
+        KtStringTemplateExpression stringTemplateExpression = (KtStringTemplateExpression) KtPsiFactoryKt.KtPsiFactory(expression).createExpression(
                 getCodeTemplate(expression)
         );
-        JetStringTemplateEntry templateEntry = stringTemplateExpression.getEntries()[0];
-        JetExpression innerExpression = templateEntry.getExpression();
+        KtStringTemplateEntry templateEntry = stringTemplateExpression.getEntries()[0];
+        KtExpression innerExpression = templateEntry.getExpression();
         assert innerExpression != null : "JetExpression should exists for " + stringTemplateExpression.toString();
         innerExpression.replace(expression);
 
-        expression = (JetExpression) expression.replace(stringTemplateExpression);
+        expression = (KtExpression) expression.replace(stringTemplateExpression);
 
         CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(expression);
 
@@ -55,9 +55,9 @@ public class KotlinStringTemplateSurrounder extends KotlinExpressionSurrounder {
         return new TextRange(offset, offset);
     }
 
-    private String getCodeTemplate(JetExpression expression) {
+    private String getCodeTemplate(KtExpression expression) {
         if (expression.getChildren().length > 0 ||
-            expression instanceof JetConstantExpression) {
+            expression instanceof KtConstantExpression) {
             return "\"${a}\"";
         }
         return "\"$a\"";
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinWhenSurrounder.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinWhenSurrounder.java
index 74de14c88c0..ccc3ecdd774 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinWhenSurrounder.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinWhenSurrounder.java
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 public class KotlinWhenSurrounder extends KotlinExpressionSurrounder {
     @Override
@@ -38,25 +38,25 @@ public class KotlinWhenSurrounder extends KotlinExpressionSurrounder {
     }
 
     @Override
-    public boolean isApplicable(@NotNull JetExpression expression) {
+    public boolean isApplicable(@NotNull KtExpression expression) {
         return true;
     }
 
     @Nullable
     @Override
-    public TextRange surroundExpression(@NotNull Project project, @NotNull Editor editor, @NotNull JetExpression expression) {
-        JetWhenExpression whenExpression = (JetWhenExpression) JetPsiFactoryKt
-                .JetPsiFactory(expression).createExpression(getCodeTemplate(expression));
-        JetExpression subjectExpression = whenExpression.getSubjectExpression();
+    public TextRange surroundExpression(@NotNull Project project, @NotNull Editor editor, @NotNull KtExpression expression) {
+        KtWhenExpression whenExpression = (KtWhenExpression) KtPsiFactoryKt
+                .KtPsiFactory(expression).createExpression(getCodeTemplate(expression));
+        KtExpression subjectExpression = whenExpression.getSubjectExpression();
         assert subjectExpression != null : "JetExpression should exists for " + whenExpression.getText() + " expression";
         subjectExpression.replace(expression);
 
-        expression = (JetExpression) expression.replace(whenExpression);
+        expression = (KtExpression) expression.replace(whenExpression);
 
         CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(expression);
 
-        JetWhenEntry whenEntry = ((JetWhenExpression) expression).getEntries().get(0);
-        JetWhenCondition whenEntryCondition = whenEntry.getConditions()[0];
+        KtWhenEntry whenEntry = ((KtWhenExpression) expression).getEntries().get(0);
+        KtWhenCondition whenEntryCondition = whenEntry.getConditions()[0];
         assert whenEntryCondition != null : "JetExpression for first entry should exists: " + expression.getText();
         TextRange whenRange = whenEntryCondition.getTextRange();
         editor.getDocument().deleteString(whenRange.getStartOffset(), whenRange.getEndOffset());
@@ -64,8 +64,8 @@ public class KotlinWhenSurrounder extends KotlinExpressionSurrounder {
         return new TextRange(offset, offset);
     }
 
-    private String getCodeTemplate(JetExpression expression) {
-        JetType type = ResolutionUtils.analyze(expression, BodyResolveMode.PARTIAL).getType(expression);
+    private String getCodeTemplate(KtExpression expression) {
+        KtType type = ResolutionUtils.analyze(expression, BodyResolveMode.PARTIAL).getType(expression);
         if (type != null) {
             ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
             if (descriptor instanceof ClassDescriptor && ((ClassDescriptor) descriptor).getKind() == ClassKind.ENUM_CLASS) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinFunctionLiteralSurrounder.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinFunctionLiteralSurrounder.java
index c2b3c760ffa..8e69377f971 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinFunctionLiteralSurrounder.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinFunctionLiteralSurrounder.java
@@ -38,14 +38,14 @@ public class KotlinFunctionLiteralSurrounder extends KotlinStatementsSurrounder
             return null;
         }
 
-        JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(project);
-        JetCallExpression callExpression = (JetCallExpression) psiFactory.createExpression("run {\n}");
-        callExpression = (JetCallExpression) container.addAfter(callExpression, statements[statements.length - 1]);
+        KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(project);
+        KtCallExpression callExpression = (KtCallExpression) psiFactory.createExpression("run {\n}");
+        callExpression = (KtCallExpression) container.addAfter(callExpression, statements[statements.length - 1]);
         container.addBefore(psiFactory.createWhiteSpace(), callExpression);
 
-        JetFunctionLiteralExpression bodyExpression = callExpression.getFunctionLiteralArguments().get(0).getFunctionLiteral();
+        KtFunctionLiteralExpression bodyExpression = callExpression.getFunctionLiteralArguments().get(0).getFunctionLiteral();
         assert bodyExpression != null : "Body expression should exists for " + callExpression.getText();
-        JetBlockExpression blockExpression = bodyExpression.getBodyExpression();
+        KtBlockExpression blockExpression = bodyExpression.getBodyExpression();
         assert blockExpression != null : "JetBlockExpression should exists for " + callExpression.getText();
         //Add statements in function literal block
         KotlinSurrounderUtils.addStatementsInBlock(blockExpression, statements);
@@ -55,7 +55,7 @@ public class KotlinFunctionLiteralSurrounder extends KotlinStatementsSurrounder
 
         callExpression = CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(callExpression);
 
-        JetExpression literalName = callExpression.getCalleeExpression();
+        KtExpression literalName = callExpression.getCalleeExpression();
         assert literalName != null : "Run expression should have callee expression " + callExpression.getText();
         return literalName.getTextRange();
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinIfSurrounderBase.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinIfSurrounderBase.java
index b01a943cc2f..a7ec193a693 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinIfSurrounderBase.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinIfSurrounderBase.java
@@ -26,10 +26,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.codeInsight.surroundWith.KotlinSurrounderUtils;
 import org.jetbrains.kotlin.idea.codeInsight.surroundWith.MoveDeclarationsOutHelper;
-import org.jetbrains.kotlin.psi.JetBlockExpression;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetIfExpression;
-import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
+import org.jetbrains.kotlin.psi.KtBlockExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtIfExpression;
+import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
 
 public abstract class KotlinIfSurrounderBase extends KotlinStatementsSurrounder {
 
@@ -43,12 +43,12 @@ public abstract class KotlinIfSurrounderBase extends KotlinStatementsSurrounder
             return null;
         }
 
-        JetIfExpression ifExpression = (JetIfExpression) JetPsiFactoryKt.JetPsiFactory(project).createExpression(getCodeTemplate());
-        ifExpression = (JetIfExpression) container.addAfter(ifExpression, statements[statements.length - 1]);
+        KtIfExpression ifExpression = (KtIfExpression) KtPsiFactoryKt.KtPsiFactory(project).createExpression(getCodeTemplate());
+        ifExpression = (KtIfExpression) container.addAfter(ifExpression, statements[statements.length - 1]);
 
         // TODO move a comment for first statement
 
-        JetBlockExpression thenBranch = (JetBlockExpression) ifExpression.getThen();
+        KtBlockExpression thenBranch = (KtBlockExpression) ifExpression.getThen();
         assert thenBranch != null : "Then branch should exist for created if expression: " + ifExpression.getText();
         // Add statements in then branch of created if
         KotlinSurrounderUtils.addStatementsInBlock(thenBranch, statements);
@@ -58,7 +58,7 @@ public abstract class KotlinIfSurrounderBase extends KotlinStatementsSurrounder
 
         ifExpression = CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(ifExpression);
 
-        JetExpression condition = ifExpression.getCondition();
+        KtExpression condition = ifExpression.getCondition();
         assert condition != null : "Condition should exists for created if expression: " + ifExpression.getText();
         // Delete condition from created if
         TextRange range = condition.getTextRange();
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTryCatchFinallySurrounder.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTryCatchFinallySurrounder.java
index 2343bd10490..7d9f96dd230 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTryCatchFinallySurrounder.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTryCatchFinallySurrounder.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.codeInsight.surroundWith.statement;
 import com.intellij.codeInsight.CodeInsightBundle;
 import com.intellij.openapi.util.TextRange;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetTryExpression;
+import org.jetbrains.kotlin.psi.KtTryExpression;
 
 public class KotlinTryCatchFinallySurrounder extends KotlinTrySurrounderBase {
 
@@ -30,7 +30,7 @@ public class KotlinTryCatchFinallySurrounder extends KotlinTrySurrounderBase {
 
     @NotNull
     @Override
-    protected TextRange getTextRangeForCaret(@NotNull JetTryExpression expression) {
+    protected TextRange getTextRangeForCaret(@NotNull KtTryExpression expression) {
         return getCatchTypeParameterTextRange(expression);
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTryCatchSurrounder.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTryCatchSurrounder.java
index aff3a5a92ac..0425f91b9b1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTryCatchSurrounder.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTryCatchSurrounder.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.codeInsight.surroundWith.statement;
 import com.intellij.codeInsight.CodeInsightBundle;
 import com.intellij.openapi.util.TextRange;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetTryExpression;
+import org.jetbrains.kotlin.psi.KtTryExpression;
 
 public class KotlinTryCatchSurrounder extends KotlinTrySurrounderBase {
 
@@ -30,7 +30,7 @@ public class KotlinTryCatchSurrounder extends KotlinTrySurrounderBase {
 
     @NotNull
     @Override
-    protected TextRange getTextRangeForCaret(@NotNull JetTryExpression expression) {
+    protected TextRange getTextRangeForCaret(@NotNull KtTryExpression expression) {
         return getCatchTypeParameterTextRange(expression);
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTryFinallySurrounder.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTryFinallySurrounder.java
index 71c2837a6fc..3dce7d2922f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTryFinallySurrounder.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTryFinallySurrounder.java
@@ -23,9 +23,9 @@ import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetFinallySection;
-import org.jetbrains.kotlin.psi.JetTryExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtFinallySection;
+import org.jetbrains.kotlin.psi.KtTryExpression;
 
 public class KotlinTryFinallySurrounder extends KotlinTrySurrounderBase {
 
@@ -48,10 +48,10 @@ public class KotlinTryFinallySurrounder extends KotlinTrySurrounderBase {
 
     @NotNull
     @Override
-    protected TextRange getTextRangeForCaret(@NotNull JetTryExpression expression) {
-        JetFinallySection block = expression.getFinallyBlock();
+    protected TextRange getTextRangeForCaret(@NotNull KtTryExpression expression) {
+        KtFinallySection block = expression.getFinallyBlock();
         assert block != null : "Finally block should exists for " + expression.getText();
-        JetExpression blockExpression = block.getFinalExpression().getStatements().get(0);
+        KtExpression blockExpression = block.getFinalExpression().getStatements().get(0);
         return blockExpression.getTextRange();
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTrySurrounderBase.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTrySurrounderBase.java
index f450ae0b262..54bc66decf3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTrySurrounderBase.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinTrySurrounderBase.java
@@ -39,12 +39,12 @@ public abstract class KotlinTrySurrounderBase extends KotlinStatementsSurrounder
             return null;
         }
 
-        JetTryExpression tryExpression = (JetTryExpression) JetPsiFactoryKt.JetPsiFactory(project).createExpression(getCodeTemplate());
-        tryExpression = (JetTryExpression) container.addAfter(tryExpression, statements[statements.length - 1]);
+        KtTryExpression tryExpression = (KtTryExpression) KtPsiFactoryKt.KtPsiFactory(project).createExpression(getCodeTemplate());
+        tryExpression = (KtTryExpression) container.addAfter(tryExpression, statements[statements.length - 1]);
 
         // TODO move a comment for first statement
 
-        JetBlockExpression tryBlock = tryExpression.getTryBlock();
+        KtBlockExpression tryBlock = tryExpression.getTryBlock();
         // Add statements in try block of created try - catch - finally
         KotlinSurrounderUtils.addStatementsInBlock(tryBlock, statements);
 
@@ -59,12 +59,12 @@ public abstract class KotlinTrySurrounderBase extends KotlinStatementsSurrounder
     protected abstract String getCodeTemplate();
 
     @NotNull
-    protected abstract TextRange getTextRangeForCaret(@NotNull JetTryExpression expression);
+    protected abstract TextRange getTextRangeForCaret(@NotNull KtTryExpression expression);
 
-    protected static TextRange getCatchTypeParameterTextRange(@NotNull JetTryExpression expression) {
-        JetParameter parameter = expression.getCatchClauses().get(0).getCatchParameter();
+    protected static TextRange getCatchTypeParameterTextRange(@NotNull KtTryExpression expression) {
+        KtParameter parameter = expression.getCatchClauses().get(0).getCatchParameter();
         assert parameter != null : "Catch parameter should exists for " + expression.getText();
-        JetElement typeReference = parameter.getTypeReference();
+        KtElement typeReference = parameter.getTypeReference();
         assert typeReference != null : "Type reference for parameter should exists for " + expression.getText();
         return typeReference.getTextRange();
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinComponentUnwrapper.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinComponentUnwrapper.java
index 4148de1399d..7485bc9224e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinComponentUnwrapper.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinComponentUnwrapper.java
@@ -20,8 +20,8 @@ import com.intellij.psi.PsiElement;
 import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtElement;
+import org.jetbrains.kotlin.psi.KtExpression;
 
 public abstract class KotlinComponentUnwrapper extends KotlinUnwrapRemoveBase {
     public KotlinComponentUnwrapper(String key) {
@@ -29,29 +29,29 @@ public abstract class KotlinComponentUnwrapper extends KotlinUnwrapRemoveBase {
     }
 
     @Nullable
-    protected abstract JetExpression getExpressionToUnwrap(@NotNull JetElement target);
+    protected abstract KtExpression getExpressionToUnwrap(@NotNull KtElement target);
 
     @NotNull
-    protected JetElement getEnclosingElement(@NotNull JetElement element) {
+    protected KtElement getEnclosingElement(@NotNull KtElement element) {
         return element;
     }
 
     @Override
     public boolean isApplicableTo(PsiElement e) {
-        if (!(e instanceof JetElement)) return false;
+        if (!(e instanceof KtElement)) return false;
 
-        JetExpression expressionToUnwrap = getExpressionToUnwrap((JetElement) e);
+        KtExpression expressionToUnwrap = getExpressionToUnwrap((KtElement) e);
         return expressionToUnwrap != null && canExtractExpression(expressionToUnwrap,
-                                                                  (JetElement) getEnclosingElement((JetElement) e).getParent());
+                                                                  (KtElement) getEnclosingElement((KtElement) e).getParent());
     }
 
     @Override
     protected void doUnwrap(PsiElement element, Context context) throws IncorrectOperationException {
-        JetElement targetElement = (JetElement) element;
-        JetExpression expressionToUnwrap = getExpressionToUnwrap(targetElement);
+        KtElement targetElement = (KtElement) element;
+        KtExpression expressionToUnwrap = getExpressionToUnwrap(targetElement);
         assert expressionToUnwrap != null;
 
-        JetElement enclosingElement = getEnclosingElement(targetElement);
+        KtElement enclosingElement = getEnclosingElement(targetElement);
         context.extractFromExpression(expressionToUnwrap, enclosingElement);
         context.delete(enclosingElement);
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinLambdaUnwrapper.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinLambdaUnwrapper.java
index e48e97ada68..c3c48b0279b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinLambdaUnwrapper.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinLambdaUnwrapper.java
@@ -27,19 +27,19 @@ public class KotlinLambdaUnwrapper extends KotlinUnwrapRemoveBase {
         super(key);
     }
 
-    private static JetElement getLambdaEnclosingElement(@NotNull JetFunctionLiteralExpression lambda) {
+    private static KtElement getLambdaEnclosingElement(@NotNull KtFunctionLiteralExpression lambda) {
         PsiElement parent = lambda.getParent();
 
-        if (parent instanceof JetValueArgument) {
-            return PsiTreeUtil.getParentOfType(parent, JetCallExpression.class, true);
+        if (parent instanceof KtValueArgument) {
+            return PsiTreeUtil.getParentOfType(parent, KtCallExpression.class, true);
         }
 
-        if (parent instanceof JetCallExpression) {
-            return (JetElement) parent;
+        if (parent instanceof KtCallExpression) {
+            return (KtElement) parent;
         }
 
-        if (parent instanceof JetProperty && ((JetProperty) parent).isLocal()) {
-            return (JetElement) parent;
+        if (parent instanceof KtProperty && ((KtProperty) parent).isLocal()) {
+            return (KtElement) parent;
         }
 
         return lambda;
@@ -47,22 +47,22 @@ public class KotlinLambdaUnwrapper extends KotlinUnwrapRemoveBase {
 
     @Override
     public boolean isApplicableTo(PsiElement e) {
-        if (!(e instanceof JetFunctionLiteralExpression)) return false;
+        if (!(e instanceof KtFunctionLiteralExpression)) return false;
 
-        JetFunctionLiteralExpression lambda = (JetFunctionLiteralExpression) e;
-        JetBlockExpression body = lambda.getBodyExpression();
-        JetElement enclosingElement = getLambdaEnclosingElement((JetFunctionLiteralExpression) e);
+        KtFunctionLiteralExpression lambda = (KtFunctionLiteralExpression) e;
+        KtBlockExpression body = lambda.getBodyExpression();
+        KtElement enclosingElement = getLambdaEnclosingElement((KtFunctionLiteralExpression) e);
 
         if (body == null || enclosingElement == null) return false;
 
-        return canExtractExpression(body, (JetElement)enclosingElement.getParent());
+        return canExtractExpression(body, (KtElement)enclosingElement.getParent());
     }
 
     @Override
     protected void doUnwrap(PsiElement element, Context context) throws IncorrectOperationException {
-        JetFunctionLiteralExpression lambda = (JetFunctionLiteralExpression) element;
-        JetBlockExpression body = lambda.getBodyExpression();
-        JetElement enclosingExpression = getLambdaEnclosingElement(lambda);
+        KtFunctionLiteralExpression lambda = (KtFunctionLiteralExpression) element;
+        KtBlockExpression body = lambda.getBodyExpression();
+        KtElement enclosingExpression = getLambdaEnclosingElement(lambda);
 
         context.extractFromBlock(body, enclosingExpression);
         context.delete(enclosingExpression);
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinUnwrapRemoveBase.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinUnwrapRemoveBase.java
index 42ecb6e5c1b..d5f8836b549 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinUnwrapRemoveBase.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinUnwrapRemoveBase.java
@@ -23,9 +23,9 @@ import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil;
-import org.jetbrains.kotlin.psi.JetBlockExpression;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtBlockExpression;
+import org.jetbrains.kotlin.psi.KtElement;
+import org.jetbrains.kotlin.psi.KtExpression;
 
 import java.util.List;
 
@@ -43,15 +43,15 @@ public abstract class KotlinUnwrapRemoveBase extends AbstractUnwrapper<KotlinUnw
 
     @Override
     public String getDescription(PsiElement e) {
-        assert e instanceof JetElement;
-        return JetBundle.message(key, JetRefactoringUtil.getExpressionShortText((JetElement) e));
+        assert e instanceof KtElement;
+        return JetBundle.message(key, JetRefactoringUtil.getExpressionShortText((KtElement) e));
     }
 
-    protected boolean canExtractExpression(@NotNull JetExpression expression, @NotNull JetElement parent) {
-        if (expression instanceof JetBlockExpression) {
-            JetBlockExpression block = (JetBlockExpression) expression;
+    protected boolean canExtractExpression(@NotNull KtExpression expression, @NotNull KtElement parent) {
+        if (expression instanceof KtBlockExpression) {
+            KtBlockExpression block = (KtBlockExpression) expression;
 
-            return block.getStatements().size() <= 1 || parent instanceof JetBlockExpression;
+            return block.getStatements().size() <= 1 || parent instanceof KtBlockExpression;
         }
         return true;
     }
@@ -62,23 +62,23 @@ public abstract class KotlinUnwrapRemoveBase extends AbstractUnwrapper<KotlinUnw
             return element instanceof PsiWhiteSpace;
         }
 
-        public void extractFromBlock(@NotNull JetBlockExpression block, @NotNull JetElement from) throws IncorrectOperationException {
-            List<JetExpression> expressions = block.getStatements();
+        public void extractFromBlock(@NotNull KtBlockExpression block, @NotNull KtElement from) throws IncorrectOperationException {
+            List<KtExpression> expressions = block.getStatements();
             if (!expressions.isEmpty()) {
                 extract(expressions.get(0), expressions.get(expressions.size() - 1), from);
             }
         }
 
-        public void extractFromExpression(@NotNull JetExpression expression, @NotNull JetElement from) throws IncorrectOperationException {
-            if (expression instanceof JetBlockExpression) {
-                extractFromBlock((JetBlockExpression) expression, from);
+        public void extractFromExpression(@NotNull KtExpression expression, @NotNull KtElement from) throws IncorrectOperationException {
+            if (expression instanceof KtBlockExpression) {
+                extractFromBlock((KtBlockExpression) expression, from);
             }
             else {
                 extract(expression, expression, from);
             }
         }
 
-        public void replace(@NotNull JetElement originalElement, @NotNull JetElement newElement) {
+        public void replace(@NotNull KtElement originalElement, @NotNull KtElement newElement) {
             if (myIsEffective) {
                 originalElement.replace(newElement);
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinUnwrappers.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinUnwrappers.java
index 901c602687a..033e18aa1ca 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinUnwrappers.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinUnwrappers.java
@@ -33,7 +33,7 @@ public class KotlinUnwrappers {
 
         @Override
         public boolean isApplicableTo(PsiElement e) {
-            return e instanceof JetExpression && e.getParent() instanceof JetBlockExpression;
+            return e instanceof KtExpression && e.getParent() instanceof KtBlockExpression;
         }
     }
 
@@ -43,8 +43,8 @@ public class KotlinUnwrappers {
         }
 
         @Override
-        protected JetExpression getExpressionToUnwrap(@NotNull JetElement target) {
-            return target instanceof JetIfExpression ? ((JetIfExpression) target).getElse() : null;
+        protected KtExpression getExpressionToUnwrap(@NotNull KtElement target) {
+            return target instanceof KtIfExpression ? ((KtIfExpression) target).getElse() : null;
         }
     }
 
@@ -54,8 +54,8 @@ public class KotlinUnwrappers {
         }
 
         @Override
-        protected JetExpression getExpressionToUnwrap(@NotNull JetElement target) {
-            return target instanceof JetIfExpression ? ((JetIfExpression) target).getThen() : null;
+        protected KtExpression getExpressionToUnwrap(@NotNull KtElement target) {
+            return target instanceof KtIfExpression ? ((KtIfExpression) target).getThen() : null;
         }
     }
 
@@ -66,16 +66,16 @@ public class KotlinUnwrappers {
 
         @Override
         public boolean isApplicableTo(PsiElement e) {
-            return e instanceof JetIfExpression
-                   && ((JetIfExpression) e).getCondition() != null
-                   && ((JetIfExpression) e).getThen() != null
-                   && ((JetIfExpression) e).getElse() != null;
+            return e instanceof KtIfExpression
+                   && ((KtIfExpression) e).getCondition() != null
+                   && ((KtIfExpression) e).getThen() != null
+                   && ((KtIfExpression) e).getElse() != null;
         }
 
         @Override
         protected void doUnwrap(PsiElement element, Context context) throws IncorrectOperationException {
-            JetIfExpression ifExpr = (JetIfExpression) element;
-            context.replace(ifExpr, JetPsiFactoryKt.JetPsiFactory(ifExpr).createIf(ifExpr.getCondition(), ifExpr.getThen(), null));
+            KtIfExpression ifExpr = (KtIfExpression) element;
+            context.replace(ifExpr, KtPsiFactoryKt.KtPsiFactory(ifExpr).createIf(ifExpr.getCondition(), ifExpr.getThen(), null));
         }
     }
 
@@ -86,8 +86,8 @@ public class KotlinUnwrappers {
 
         @Override
         @Nullable
-        protected JetExpression getExpressionToUnwrap(@NotNull JetElement target) {
-            return target instanceof JetLoopExpression ? ((JetLoopExpression) target).getBody() : null;
+        protected KtExpression getExpressionToUnwrap(@NotNull KtElement target) {
+            return target instanceof KtLoopExpression ? ((KtLoopExpression) target).getBody() : null;
         }
     }
 
@@ -98,8 +98,8 @@ public class KotlinUnwrappers {
 
         @Override
         @Nullable
-        protected JetExpression getExpressionToUnwrap(@NotNull JetElement target) {
-            return target instanceof JetTryExpression ? ((JetTryExpression) target).getTryBlock() : null;
+        protected KtExpression getExpressionToUnwrap(@NotNull KtElement target) {
+            return target instanceof KtTryExpression ? ((KtTryExpression) target).getTryBlock() : null;
         }
     }
 
@@ -110,13 +110,13 @@ public class KotlinUnwrappers {
 
         @NotNull
         @Override
-        protected JetElement getEnclosingElement(@NotNull JetElement element) {
-            return (JetElement)element.getParent();
+        protected KtElement getEnclosingElement(@NotNull KtElement element) {
+            return (KtElement)element.getParent();
         }
 
         @Override
-        protected JetExpression getExpressionToUnwrap(@NotNull JetElement target) {
-            return target instanceof JetCatchClause ? ((JetCatchClause) target).getCatchBody() : null;
+        protected KtExpression getExpressionToUnwrap(@NotNull KtElement target) {
+            return target instanceof KtCatchClause ? ((KtCatchClause) target).getCatchBody() : null;
         }
     }
 
@@ -127,7 +127,7 @@ public class KotlinUnwrappers {
 
         @Override
         public boolean isApplicableTo(PsiElement e) {
-            return e instanceof JetCatchClause;
+            return e instanceof KtCatchClause;
         }
     }
 
@@ -138,18 +138,18 @@ public class KotlinUnwrappers {
 
         @Override
         public boolean isApplicableTo(PsiElement e) {
-            return super.isApplicableTo(e) && getEnclosingElement((JetElement)e).getParent() instanceof JetBlockExpression;
+            return super.isApplicableTo(e) && getEnclosingElement((KtElement)e).getParent() instanceof KtBlockExpression;
         }
 
         @NotNull
         @Override
-        protected JetElement getEnclosingElement(@NotNull JetElement element) {
-            return (JetElement)element.getParent();
+        protected KtElement getEnclosingElement(@NotNull KtElement element) {
+            return (KtElement)element.getParent();
         }
 
         @Override
-        protected JetExpression getExpressionToUnwrap(@NotNull JetElement target) {
-            return target instanceof JetFinallySection ? ((JetFinallySection) target).getFinalExpression() : null;
+        protected KtExpression getExpressionToUnwrap(@NotNull KtElement target) {
+            return target instanceof KtFinallySection ? ((KtFinallySection) target).getFinalExpression() : null;
         }
     }
 
@@ -160,7 +160,7 @@ public class KotlinUnwrappers {
 
         @Override
         public boolean isApplicableTo(PsiElement e) {
-            return e instanceof JetFinallySection;
+            return e instanceof KtFinallySection;
         }
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/AbstractJetUpDownMover.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/AbstractJetUpDownMover.java
index 83ad99698d4..c6c90a74742 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/AbstractJetUpDownMover.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/AbstractJetUpDownMover.java
@@ -29,9 +29,9 @@ import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.core.refactoring.JetRefactoringUtilKt;
-import org.jetbrains.kotlin.psi.JetBlockExpression;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetFunctionLiteral;
+import org.jetbrains.kotlin.psi.KtBlockExpression;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtFunctionLiteral;
 
 public abstract class AbstractJetUpDownMover extends LineMover {
     protected AbstractJetUpDownMover() {
@@ -57,8 +57,8 @@ public abstract class AbstractJetUpDownMover extends LineMover {
         int topExtension = 0;
         int bottomExtension = 0;
 
-        if (parent instanceof JetFunctionLiteral) {
-            JetBlockExpression block = ((JetFunctionLiteral) parent).getBodyExpression();
+        if (parent instanceof KtFunctionLiteral) {
+            KtBlockExpression block = ((KtFunctionLiteral) parent).getBodyExpression();
             if (block != null) {
                 PsiElement comment = null;
 
@@ -145,7 +145,7 @@ public abstract class AbstractJetUpDownMover extends LineMover {
         return lastElement;
     }
 
-    private static boolean checkCommentAtBlockBound(PsiElement blockElement, PsiElement comment, JetBlockExpression block) {
+    private static boolean checkCommentAtBlockBound(PsiElement blockElement, PsiElement comment, KtBlockExpression block) {
         return PsiTreeUtil.isAncestor(block, blockElement, true) && comment instanceof PsiComment;
     }
 
@@ -166,6 +166,6 @@ public abstract class AbstractJetUpDownMover extends LineMover {
 
     @Override
     public boolean checkAvailable(@NotNull Editor editor, @NotNull PsiFile file, @NotNull MoveInfo info, boolean down) {
-        return (file instanceof JetFile) && super.checkAvailable(editor, file, info, down);
+        return (file instanceof KtFile) && super.checkAvailable(editor, file, info, down);
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/JetDeclarationMover.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/JetDeclarationMover.java
index c15a0714738..8b5e338acc0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/JetDeclarationMover.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/JetDeclarationMover.java
@@ -25,7 +25,7 @@ import com.intellij.psi.*;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 
 import java.util.ArrayList;
@@ -73,21 +73,21 @@ public class JetDeclarationMover extends AbstractJetUpDownMover {
     }
 
     @NotNull
-    private static List<PsiElement> getDeclarationAnchors(@NotNull JetDeclaration declaration) {
+    private static List<PsiElement> getDeclarationAnchors(@NotNull KtDeclaration declaration) {
         final List<PsiElement> memberSuspects = new ArrayList<PsiElement>();
 
-        JetModifierList modifierList = declaration.getModifierList();
+        KtModifierList modifierList = declaration.getModifierList();
         if (modifierList != null) memberSuspects.add(modifierList);
 
-        if (declaration instanceof JetNamedDeclaration) {
-            PsiElement nameIdentifier = ((JetNamedDeclaration) declaration).getNameIdentifier();
+        if (declaration instanceof KtNamedDeclaration) {
+            PsiElement nameIdentifier = ((KtNamedDeclaration) declaration).getNameIdentifier();
             if (nameIdentifier != null) memberSuspects.add(nameIdentifier);
         }
 
         declaration.accept(
-                new JetVisitorVoid() {
+                new KtVisitorVoid() {
                     @Override
-                    public void visitAnonymousInitializer(@NotNull JetClassInitializer initializer) {
+                    public void visitAnonymousInitializer(@NotNull KtClassInitializer initializer) {
                         PsiElement brace = initializer.getOpenBraceNode();
                         if (brace != null) {
                             memberSuspects.add(brace);
@@ -95,32 +95,32 @@ public class JetDeclarationMover extends AbstractJetUpDownMover {
                     }
 
                     @Override
-                    public void visitNamedFunction(@NotNull JetNamedFunction function) {
+                    public void visitNamedFunction(@NotNull KtNamedFunction function) {
                         PsiElement equalsToken = function.getEqualsToken();
                         if (equalsToken != null) memberSuspects.add(equalsToken);
 
-                        JetTypeParameterList typeParameterList = function.getTypeParameterList();
+                        KtTypeParameterList typeParameterList = function.getTypeParameterList();
                         if (typeParameterList != null) memberSuspects.add(typeParameterList);
 
-                        JetTypeReference receiverTypeRef = function.getReceiverTypeReference();
+                        KtTypeReference receiverTypeRef = function.getReceiverTypeReference();
                         if (receiverTypeRef != null) memberSuspects.add(receiverTypeRef);
 
-                        JetTypeReference returnTypeRef = function.getTypeReference();
+                        KtTypeReference returnTypeRef = function.getTypeReference();
                         if (returnTypeRef != null) memberSuspects.add(returnTypeRef);
                     }
 
                     @Override
-                    public void visitProperty(@NotNull JetProperty property) {
+                    public void visitProperty(@NotNull KtProperty property) {
                         PsiElement valOrVarKeyword = property.getValOrVarKeyword();
                         if (valOrVarKeyword != null) memberSuspects.add(valOrVarKeyword);
 
-                        JetTypeParameterList typeParameterList = property.getTypeParameterList();
+                        KtTypeParameterList typeParameterList = property.getTypeParameterList();
                         if (typeParameterList != null) memberSuspects.add(typeParameterList);
 
-                        JetTypeReference receiverTypeRef = property.getReceiverTypeReference();
+                        KtTypeReference receiverTypeRef = property.getReceiverTypeReference();
                         if (receiverTypeRef != null) memberSuspects.add(receiverTypeRef);
 
-                        JetTypeReference returnTypeRef = property.getTypeReference();
+                        KtTypeReference returnTypeRef = property.getTypeReference();
                         if (returnTypeRef != null) memberSuspects.add(returnTypeRef);
                     }
                 }
@@ -130,17 +130,17 @@ public class JetDeclarationMover extends AbstractJetUpDownMover {
     }
 
     private static final Class[] DECLARATION_CONTAINER_CLASSES =
-            {JetClassBody.class, JetClassInitializer.class, JetFunction.class, JetPropertyAccessor.class, JetFile.class};
+            {KtClassBody.class, KtClassInitializer.class, KtFunction.class, KtPropertyAccessor.class, KtFile.class};
 
-    private static final Class[] CLASSBODYLIKE_DECLARATION_CONTAINER_CLASSES = {JetClassBody.class, JetFile.class};
+    private static final Class[] CLASSBODYLIKE_DECLARATION_CONTAINER_CLASSES = {KtClassBody.class, KtFile.class};
 
     @Nullable
-    private static JetDeclaration getMovableDeclaration(@Nullable PsiElement element) {
+    private static KtDeclaration getMovableDeclaration(@Nullable PsiElement element) {
         if (element == null) return null;
 
-        JetDeclaration declaration = PsiTreeUtil.getParentOfType(element, JetDeclaration.class, false);
-        if (declaration instanceof JetParameter) return null;
-        if (declaration instanceof JetTypeParameter) {
+        KtDeclaration declaration = PsiTreeUtil.getParentOfType(element, KtDeclaration.class, false);
+        if (declaration instanceof KtParameter) return null;
+        if (declaration instanceof KtTypeParameter) {
             return getMovableDeclaration(declaration.getParent());
         }
 
@@ -151,7 +151,7 @@ public class JetDeclarationMover extends AbstractJetUpDownMover {
 
     @Override
     protected boolean checkSourceElement(@NotNull PsiElement element) {
-        return element instanceof JetDeclaration;
+        return element instanceof KtDeclaration;
     }
 
     @Override
@@ -159,7 +159,7 @@ public class JetDeclarationMover extends AbstractJetUpDownMover {
         PsiElement first;
         PsiElement last;
 
-        if (element instanceof JetDeclaration) {
+        if (element instanceof KtDeclaration) {
             first = element.getFirstChild();
             last = element.getLastChild();
 
@@ -188,8 +188,8 @@ public class JetDeclarationMover extends AbstractJetUpDownMover {
 
         TextRange lineTextRange = new TextRange(doc.getLineStartOffset(oldRange.startLine),
                                                 doc.getLineEndOffset(oldRange.endLine));
-        if (element instanceof JetDeclaration) {
-            for (PsiElement anchor : getDeclarationAnchors((JetDeclaration) element)) {
+        if (element instanceof KtDeclaration) {
+            for (PsiElement anchor : getDeclarationAnchors((KtDeclaration) element)) {
                 TextRange suspectTextRange = anchor.getTextRange();
                 if (suspectTextRange != null && lineTextRange.intersects(suspectTextRange)) return new LineRange(startLine, endLine);
             }
@@ -211,27 +211,27 @@ public class JetDeclarationMover extends AbstractJetUpDownMover {
         PsiElement nextParent = null;
 
         // moving out of code block
-        if (sibling.getNode().getElementType() == (down ? JetTokens.RBRACE : JetTokens.LBRACE)) {
+        if (sibling.getNode().getElementType() == (down ? KtTokens.RBRACE : KtTokens.LBRACE)) {
             // elements which aren't immediately placed in class body can't leave the block
             PsiElement parent = sibling.getParent();
-            if (!(parent instanceof JetClassBody)) return null;
-            if (target instanceof JetEnumEntry) return null;
+            if (!(parent instanceof KtClassBody)) return null;
+            if (target instanceof KtEnumEntry) return null;
 
-            JetClassOrObject jetClassOrObject = (JetClassOrObject) parent.getParent();
-            assert jetClassOrObject != null;
+            KtClassOrObject ktClassOrObject = (KtClassOrObject) parent.getParent();
+            assert ktClassOrObject != null;
 
-            nextParent = jetClassOrObject.getParent();
+            nextParent = ktClassOrObject.getParent();
 
             if (!down) {
-                start = jetClassOrObject;
+                start = ktClassOrObject;
             }
         }
         // moving into code block
         // element may move only into class body
         else {
-            if (sibling instanceof JetClassOrObject) {
-                JetClassOrObject jetClassOrObject = (JetClassOrObject) sibling;
-                JetClassBody classBody = jetClassOrObject.getBody();
+            if (sibling instanceof KtClassOrObject) {
+                KtClassOrObject ktClassOrObject = (KtClassOrObject) sibling;
+                KtClassBody classBody = ktClassOrObject.getBody();
 
                 // confined elements can't leave their block
                 if (classBody != null) {
@@ -245,19 +245,19 @@ public class JetDeclarationMover extends AbstractJetUpDownMover {
         }
 
         if (nextParent != null) {
-            if (target instanceof JetClassInitializer && !(nextParent instanceof JetClassBody)) return null;
+            if (target instanceof KtClassInitializer && !(nextParent instanceof KtClassBody)) return null;
 
-            if (target instanceof JetEnumEntry) {
-                if (!(nextParent instanceof JetClassBody)) return null;
+            if (target instanceof KtEnumEntry) {
+                if (!(nextParent instanceof KtClassBody)) return null;
 
-                JetClassOrObject nextClassOrObject = (JetClassOrObject) nextParent.getParent();
+                KtClassOrObject nextClassOrObject = (KtClassOrObject) nextParent.getParent();
                 assert nextClassOrObject != null;
 
-                if (!nextClassOrObject.hasModifier(JetTokens.ENUM_KEYWORD)) return null;
+                if (!nextClassOrObject.hasModifier(KtTokens.ENUM_KEYWORD)) return null;
             }
         }
 
-        if (target instanceof JetPropertyAccessor && !(sibling instanceof JetPropertyAccessor)) return null;
+        if (target instanceof KtPropertyAccessor && !(sibling instanceof KtPropertyAccessor)) return null;
 
         return start != null && end != null ? new LineRange(start, end, editor.getDocument()) : null;
     }
@@ -271,12 +271,12 @@ public class JetDeclarationMover extends AbstractJetUpDownMover {
         Pair<PsiElement, PsiElement> psiRange = getElementRange(editor, file, oldRange);
         if (psiRange == null) return false;
 
-        JetDeclaration firstDecl = getMovableDeclaration(psiRange.getFirst());
+        KtDeclaration firstDecl = getMovableDeclaration(psiRange.getFirst());
         if (firstDecl == null) return false;
 
-        moveEnumConstant = firstDecl instanceof JetEnumEntry;
+        moveEnumConstant = firstDecl instanceof KtEnumEntry;
 
-        JetDeclaration lastDecl = getMovableDeclaration(psiRange.getSecond());
+        KtDeclaration lastDecl = getMovableDeclaration(psiRange.getSecond());
         if (lastDecl == null) return false;
 
         //noinspection ConstantConditions
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/JetExpressionMover.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/JetExpressionMover.java
index 21f72cbcbe0..a0c93bf18a1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/JetExpressionMover.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/JetExpressionMover.java
@@ -28,7 +28,7 @@ import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.core.refactoring.JetRefactoringUtilKt;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt;
 
@@ -36,10 +36,10 @@ import java.util.List;
 
 public class JetExpressionMover extends AbstractJetUpDownMover {
 
-    private static final Predicate<JetElement> IS_CALL_EXPRESSION = new Predicate<JetElement>() {
+    private static final Predicate<KtElement> IS_CALL_EXPRESSION = new Predicate<KtElement>() {
         @Override
-        public boolean apply(@Nullable JetElement input) {
-            return input instanceof JetCallExpression;
+        public boolean apply(@Nullable KtElement input) {
+            return input instanceof KtCallExpression;
         }
     };
 
@@ -47,9 +47,9 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
     }
 
     private final static Class[] MOVABLE_ELEMENT_CLASSES = {
-            JetExpression.class,
-            JetWhenEntry.class,
-            JetValueArgument.class,
+            KtExpression.class,
+            KtWhenEntry.class,
+            KtValueArgument.class,
             PsiComment.class
     };
 
@@ -57,31 +57,31 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
         @NotNull
         @Override
         public Boolean invoke(PsiElement element) {
-            return (!(element instanceof JetExpression)
-                    || element instanceof JetDeclaration
-                    || element instanceof JetBlockExpression
-                    || element.getParent() instanceof JetBlockExpression);
+            return (!(element instanceof KtExpression)
+                    || element instanceof KtDeclaration
+                    || element instanceof KtBlockExpression
+                    || element.getParent() instanceof KtBlockExpression);
         }
     };
 
     private final static Class[] BLOCKLIKE_ELEMENT_CLASSES =
-            {JetBlockExpression.class, JetWhenExpression.class, JetClassBody.class, JetFile.class};
+            {KtBlockExpression.class, KtWhenExpression.class, KtClassBody.class, KtFile.class};
 
     private final static Class[] FUNCTIONLIKE_ELEMENT_CLASSES =
-            {JetFunction.class, JetPropertyAccessor.class, JetClassInitializer.class};
+            {KtFunction.class, KtPropertyAccessor.class, KtClassInitializer.class};
 
-    private static final Predicate<JetElement> CHECK_BLOCK_LIKE_ELEMENT = new Predicate<JetElement>() {
+    private static final Predicate<KtElement> CHECK_BLOCK_LIKE_ELEMENT = new Predicate<KtElement>() {
         @Override
-        public boolean apply(@Nullable JetElement input) {
-            return (input instanceof JetBlockExpression || input instanceof JetClassBody)
+        public boolean apply(@Nullable KtElement input) {
+            return (input instanceof KtBlockExpression || input instanceof KtClassBody)
                    && !PsiTreeUtil.instanceOf(input.getParent(), FUNCTIONLIKE_ELEMENT_CLASSES);
         }
     };
 
-    private static final Predicate<JetElement> CHECK_BLOCK = new Predicate<JetElement>() {
+    private static final Predicate<KtElement> CHECK_BLOCK = new Predicate<KtElement>() {
         @Override
-        public boolean apply(@Nullable JetElement input) {
-            return input instanceof JetBlockExpression && !PsiTreeUtil.instanceOf(input.getParent(), FUNCTIONLIKE_ELEMENT_CLASSES);
+        public boolean apply(@Nullable KtElement input) {
+            return input instanceof KtBlockExpression && !PsiTreeUtil.instanceOf(input.getParent(), FUNCTIONLIKE_ELEMENT_CLASSES);
         }
     };
 
@@ -114,7 +114,7 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
                 nextElement = sibling;
             }
 
-            if (sibling instanceof JetExpression) {
+            if (sibling instanceof KtExpression) {
                 nextExpression = sibling;
                 break;
             }
@@ -141,7 +141,7 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
             @NotNull MoveInfo info
     ) {
         //noinspection unchecked
-        PsiElement prev = JetPsiUtil.getLastChildByType(block, JetExpression.class);
+        PsiElement prev = KtPsiUtil.getLastChildByType(block, KtExpression.class);
         if (prev == null) return BraceStatus.NOT_MOVABLE;
 
         Document doc = editor.getDocument();
@@ -170,18 +170,18 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
         if (closingBrace == null) return BraceStatus.NOT_FOUND;
 
         PsiElement blockLikeElement = closingBrace.getParent();
-        if (!(blockLikeElement instanceof JetBlockExpression)) return BraceStatus.NOT_MOVABLE;
+        if (!(blockLikeElement instanceof KtBlockExpression)) return BraceStatus.NOT_MOVABLE;
 
         PsiElement blockParent = blockLikeElement.getParent();
-        if (blockParent instanceof JetWhenEntry) return BraceStatus.NOT_FOUND;
+        if (blockParent instanceof KtWhenEntry) return BraceStatus.NOT_FOUND;
         if (PsiTreeUtil.instanceOf(blockParent, FUNCTIONLIKE_ELEMENT_CLASSES)) return BraceStatus.NOT_FOUND;
 
-        PsiElement enclosingExpression = PsiTreeUtil.getParentOfType(blockLikeElement, JetExpression.class);
+        PsiElement enclosingExpression = PsiTreeUtil.getParentOfType(blockLikeElement, KtExpression.class);
 
-        if (enclosingExpression instanceof JetDoWhileExpression) return BraceStatus.NOT_MOVABLE;
+        if (enclosingExpression instanceof KtDoWhileExpression) return BraceStatus.NOT_MOVABLE;
 
-        if (enclosingExpression instanceof JetIfExpression) {
-            JetIfExpression ifExpression = (JetIfExpression) enclosingExpression;
+        if (enclosingExpression instanceof KtIfExpression) {
+            KtIfExpression ifExpression = (KtIfExpression) enclosingExpression;
 
             if (blockLikeElement == ifExpression.getThen() && ifExpression.getElse() != null) return BraceStatus.NOT_MOVABLE;
         }
@@ -192,23 +192,23 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
     }
 
     @Nullable
-    private static JetBlockExpression findClosestBlock(@NotNull PsiElement anchor, boolean down, boolean strict) {
-        PsiElement current = PsiTreeUtil.getParentOfType(anchor, JetBlockExpression.class, strict);
+    private static KtBlockExpression findClosestBlock(@NotNull PsiElement anchor, boolean down, boolean strict) {
+        PsiElement current = PsiTreeUtil.getParentOfType(anchor, KtBlockExpression.class, strict);
         while (current != null) {
             PsiElement parent = current.getParent();
-            if (parent instanceof JetClassBody ||
-                parent instanceof JetClassInitializer ||
-                parent instanceof JetNamedFunction ||
-                (parent instanceof JetProperty && !((JetProperty) parent).isLocal())) {
+            if (parent instanceof KtClassBody ||
+                parent instanceof KtClassInitializer ||
+                parent instanceof KtNamedFunction ||
+                (parent instanceof KtProperty && !((KtProperty) parent).isLocal())) {
                 return null;
             }
 
-            if (parent instanceof JetBlockExpression) return (JetBlockExpression) parent;
+            if (parent instanceof KtBlockExpression) return (KtBlockExpression) parent;
 
             PsiElement sibling = down ? current.getNextSibling() : current.getPrevSibling();
             if (sibling != null) {
                 //noinspection unchecked
-                JetBlockExpression block = (JetBlockExpression) JetPsiUtil.getOutermostDescendantElement(sibling, down, CHECK_BLOCK);
+                KtBlockExpression block = (KtBlockExpression) KtPsiUtil.getOutermostDescendantElement(sibling, down, CHECK_BLOCK);
                 if (block != null) return block;
 
                 current = sibling;
@@ -222,12 +222,12 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
     }
 
     @Nullable
-    private static JetBlockExpression getDSLLambdaBlock(@NotNull PsiElement element, boolean down) {
-        JetCallExpression callExpression =
-                (JetCallExpression) JetPsiUtil.getOutermostDescendantElement(element, down, IS_CALL_EXPRESSION);
+    private static KtBlockExpression getDSLLambdaBlock(@NotNull PsiElement element, boolean down) {
+        KtCallExpression callExpression =
+                (KtCallExpression) KtPsiUtil.getOutermostDescendantElement(element, down, IS_CALL_EXPRESSION);
         if (callExpression == null) return null;
 
-        List<JetFunctionLiteralArgument> functionLiterals = callExpression.getFunctionLiteralArguments();
+        List<KtFunctionLiteralArgument> functionLiterals = callExpression.getFunctionLiteralArguments();
         if (functionLiterals.isEmpty()) return null;
 
         return functionLiterals.get(0).getFunctionLiteral().getBodyExpression();
@@ -235,9 +235,9 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
 
     @Nullable
     private static LineRange getExpressionTargetRange(@NotNull Editor editor, @NotNull PsiElement sibling, boolean down) {
-        if (sibling instanceof JetIfExpression && !down) {
-            JetExpression elseBranch = ((JetIfExpression) sibling).getElse();
-            if (elseBranch instanceof JetBlockExpression) {
+        if (sibling instanceof KtIfExpression && !down) {
+            KtExpression elseBranch = ((KtIfExpression) sibling).getElse();
+            if (elseBranch instanceof KtBlockExpression) {
                 sibling = elseBranch;
             }
         }
@@ -246,17 +246,17 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
         PsiElement end = sibling;
 
         // moving out of code block
-        if (sibling.getNode().getElementType() == (down ? JetTokens.RBRACE : JetTokens.LBRACE)) {
+        if (sibling.getNode().getElementType() == (down ? KtTokens.RBRACE : KtTokens.LBRACE)) {
             PsiElement parent = sibling.getParent();
-            if (!(parent instanceof JetBlockExpression || parent instanceof JetFunctionLiteral)) return null;
+            if (!(parent instanceof KtBlockExpression || parent instanceof KtFunctionLiteral)) return null;
 
-            JetBlockExpression newBlock;
-            if (parent instanceof JetFunctionLiteral) {
+            KtBlockExpression newBlock;
+            if (parent instanceof KtFunctionLiteral) {
                 //noinspection ConstantConditions
-                newBlock = findClosestBlock(((JetFunctionLiteral) parent).getBodyExpression(), down, false);
+                newBlock = findClosestBlock(((KtFunctionLiteral) parent).getBodyExpression(), down, false);
 
                 if (!down) {
-                    PsiElement arrow = ((JetFunctionLiteral) parent).getArrow();
+                    PsiElement arrow = ((KtFunctionLiteral) parent).getArrow();
                     if (arrow != null) {
                         end = arrow;
                     }
@@ -268,7 +268,7 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
             if (newBlock == null) return null;
 
             if (PsiTreeUtil.isAncestor(newBlock, parent, true)) {
-                PsiElement outermostParent = JetPsiUtil.getOutermostParent(parent, newBlock, true);
+                PsiElement outermostParent = KtPsiUtil.getOutermostParent(parent, newBlock, true);
 
                 if (down) {
                     end = outermostParent;
@@ -290,27 +290,27 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
         else {
             PsiElement blockLikeElement;
 
-            JetBlockExpression dslBlock = getDSLLambdaBlock(sibling, down);
+            KtBlockExpression dslBlock = getDSLLambdaBlock(sibling, down);
             if (dslBlock != null) {
                 // Use JetFunctionLiteral (since it contains braces)
                 blockLikeElement = dslBlock.getParent();
             } else {
                 // JetBlockExpression and other block-like elements
-                blockLikeElement = JetPsiUtil.getOutermostDescendantElement(sibling, down, CHECK_BLOCK_LIKE_ELEMENT);
+                blockLikeElement = KtPsiUtil.getOutermostDescendantElement(sibling, down, CHECK_BLOCK_LIKE_ELEMENT);
             }
 
             if (blockLikeElement != null) {
                 if (down) {
-                    end = JetPsiUtil.findChildByType(blockLikeElement, JetTokens.LBRACE);
-                    if (blockLikeElement instanceof JetFunctionLiteral) {
-                        PsiElement arrow = ((JetFunctionLiteral) blockLikeElement).getArrow();
+                    end = KtPsiUtil.findChildByType(blockLikeElement, KtTokens.LBRACE);
+                    if (blockLikeElement instanceof KtFunctionLiteral) {
+                        PsiElement arrow = ((KtFunctionLiteral) blockLikeElement).getArrow();
                         if (arrow != null) {
                             end = arrow;
                         }
                     }
                 }
                 else {
-                    start = JetPsiUtil.findChildByType(blockLikeElement, JetTokens.RBRACE);
+                    start = KtPsiUtil.findChildByType(blockLikeElement, KtTokens.RBRACE);
                 }
             }
         }
@@ -320,8 +320,8 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
 
     @Nullable
     private static LineRange getWhenEntryTargetRange(@NotNull Editor editor, @NotNull PsiElement sibling, boolean down) {
-        if (sibling.getNode().getElementType() == (down ? JetTokens.RBRACE : JetTokens.LBRACE) &&
-            PsiTreeUtil.getParentOfType(sibling, JetWhenEntry.class) == null) {
+        if (sibling.getNode().getElementType() == (down ? KtTokens.RBRACE : KtTokens.LBRACE) &&
+            PsiTreeUtil.getParentOfType(sibling, KtWhenEntry.class) == null) {
             return null;
         }
 
@@ -337,11 +337,11 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
     ) {
         PsiElement next = sibling;
 
-        if (next.getNode().getElementType() == JetTokens.COMMA) {
+        if (next.getNode().getElementType() == KtTokens.COMMA) {
             next = firstNonWhiteSibling(next, down);
         }
 
-        LineRange range = (next instanceof JetParameter || next instanceof JetValueArgument)
+        LineRange range = (next instanceof KtParameter || next instanceof KtValueArgument)
                           ? new LineRange(next, next, editor.getDocument())
                           : null;
 
@@ -359,15 +359,15 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
             @NotNull PsiElement sibling,
             boolean down
     ) {
-        if (elementToCheck instanceof JetParameter || elementToCheck instanceof JetValueArgument) {
+        if (elementToCheck instanceof KtParameter || elementToCheck instanceof KtValueArgument) {
             return getValueParamOrArgTargetRange(editor, elementToCheck, sibling, down);
         }
 
-        if (elementToCheck instanceof JetExpression || elementToCheck instanceof PsiComment) {
+        if (elementToCheck instanceof KtExpression || elementToCheck instanceof PsiComment) {
             return getExpressionTargetRange(editor, sibling, down);
         }
 
-        if (elementToCheck instanceof JetWhenEntry) {
+        if (elementToCheck instanceof KtWhenEntry) {
             return getWhenEntryTargetRange(editor, sibling, down);
         }
 
@@ -413,7 +413,7 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
     }
 
     private static boolean isForbiddenMove(@NotNull PsiElement element, boolean down) {
-        if (element instanceof JetParameter || element instanceof JetValueArgument) {
+        if (element instanceof KtParameter || element instanceof KtValueArgument) {
             return isLastOfItsKind(element, down);
         }
 
@@ -421,9 +421,9 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
     }
 
     private static boolean isBracelessBlock(@NotNull PsiElement element) {
-        if (!(element instanceof JetBlockExpression)) return false;
+        if (!(element instanceof KtBlockExpression)) return false;
 
-        JetBlockExpression block = (JetBlockExpression) element;
+        KtBlockExpression block = (KtBlockExpression) element;
 
         return block.getLBrace() == null && block.getRBrace() == null;
     }
@@ -461,15 +461,15 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
         }
 
         if (sibling == null) {
-            JetCallExpression callExpression = PsiTreeUtil.getParentOfType(element, JetCallExpression.class);
+            KtCallExpression callExpression = PsiTreeUtil.getParentOfType(element, KtCallExpression.class);
             if (callExpression != null) {
-                JetBlockExpression dslBlock = getDSLLambdaBlock(callExpression, down);
+                KtBlockExpression dslBlock = getDSLLambdaBlock(callExpression, down);
                 if (PsiTreeUtil.isAncestor(dslBlock, element, false)) {
                     //noinspection ConstantConditions
                     PsiElement blockParent = dslBlock.getParent();
                     return down
-                           ? JetPsiUtil.findChildByType(blockParent, JetTokens.RBRACE)
-                           : JetPsiUtil.findChildByType(blockParent, JetTokens.LBRACE);
+                           ? KtPsiUtil.findChildByType(blockParent, KtTokens.RBRACE)
+                           : KtPsiUtil.findChildByType(blockParent, KtTokens.LBRACE);
                 }
             }
 
@@ -513,7 +513,7 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
             return true;
         }
 
-        if ((firstElement instanceof JetParameter || firstElement instanceof JetValueArgument) &&
+        if ((firstElement instanceof KtParameter || firstElement instanceof KtValueArgument) &&
             PsiTreeUtil.isAncestor(lastElement, firstElement, false)) {
             lastElement = firstElement;
         }
@@ -536,7 +536,7 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
 
     private static PsiElement getComma(@NotNull PsiElement element) {
         PsiElement sibling = firstNonWhiteSibling(element, true);
-        return sibling != null && (sibling.getNode().getElementType() == JetTokens.COMMA) ? sibling : null;
+        return sibling != null && (sibling.getNode().getElementType() == KtTokens.COMMA) ? sibling : null;
     }
 
     private static void fixCommaIfNeeded(@NotNull PsiElement element, boolean willBeLast) {
@@ -548,7 +548,7 @@ public class JetExpressionMover extends AbstractJetUpDownMover {
             PsiElement parent = element.getParent();
             assert parent != null;
 
-            parent.addAfter(JetPsiFactoryKt.JetPsiFactory(parent.getProject()).createComma(), element);
+            parent.addAfter(KtPsiFactoryKt.KtPsiFactory(parent.getProject()).createComma(), element);
         }
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/compiler/JetCompilerManager.java b/idea/src/org/jetbrains/kotlin/idea/compiler/JetCompilerManager.java
index 898cea590f4..47999f42cba 100644
--- a/idea/src/org/jetbrains/kotlin/idea/compiler/JetCompilerManager.java
+++ b/idea/src/org/jetbrains/kotlin/idea/compiler/JetCompilerManager.java
@@ -28,7 +28,7 @@ import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.js.JavaScript;
 
 import java.io.PrintStream;
@@ -47,7 +47,7 @@ public class JetCompilerManager extends AbstractProjectComponent {
 
     public JetCompilerManager(Project project, CompilerManager manager) {
         super(project);
-        manager.addCompilableFileType(JetFileType.INSTANCE);
+        manager.addCompilableFileType(KotlinFileType.INSTANCE);
         manager.addCompilationStatusListener(new CompilationStatusListener() {
             @Override
             public void compilationFinished(boolean aborted, int errors, int warnings, CompileContext compileContext) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/configuration/ConfigureKotlinInProjectUtils.java b/idea/src/org/jetbrains/kotlin/idea/configuration/ConfigureKotlinInProjectUtils.java
index 0c28675fe6a..77040b74192 100644
--- a/idea/src/org/jetbrains/kotlin/idea/configuration/ConfigureKotlinInProjectUtils.java
+++ b/idea/src/org/jetbrains/kotlin/idea/configuration/ConfigureKotlinInProjectUtils.java
@@ -29,7 +29,7 @@ import com.intellij.psi.search.FileTypeIndex;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 
 import java.util.*;
 
@@ -59,13 +59,13 @@ public class ConfigureKotlinInProjectUtils {
             return Collections.emptyList();
         }
 
-        if (!FileTypeIndex.containsFileOfType(JetFileType.INSTANCE, GlobalSearchScope.projectScope(project))) {
+        if (!FileTypeIndex.containsFileOfType(KotlinFileType.INSTANCE, GlobalSearchScope.projectScope(project))) {
             return Collections.emptyList();
         }
 
         List<Module> modulesWithKotlin = Lists.newArrayList();
         for (Module module : ModuleManager.getInstance(project).getModules()) {
-            if (FileTypeIndex.containsFileOfType(JetFileType.INSTANCE, module.getModuleScope(true))) {
+            if (FileTypeIndex.containsFileOfType(KotlinFileType.INSTANCE, module.getModuleScope(true))) {
                 modulesWithKotlin.add(module);
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/configuration/KotlinSetupSDKNotificationProvider.kt b/idea/src/org/jetbrains/kotlin/idea/configuration/KotlinSetupSDKNotificationProvider.kt
index f896245dde1..d9b7635b11c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/configuration/KotlinSetupSDKNotificationProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/configuration/KotlinSetupSDKNotificationProvider.kt
@@ -33,7 +33,7 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiManager
 import com.intellij.ui.EditorNotificationPanel
 import com.intellij.ui.EditorNotifications
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 
@@ -53,7 +53,7 @@ public class KotlinSetupSDKNotificationProvider(
     override fun getKey(): Key<EditorNotificationPanel> = KEY
 
     override fun createNotificationPanel(file: VirtualFile, fileEditor: FileEditor): EditorNotificationPanel? {
-        if (file.fileType != JetFileType.INSTANCE) {
+        if (file.fileType != KotlinFileType.INSTANCE) {
             return null
         }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPastePostProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPastePostProcessor.kt
index e350d6e47e9..68fee7d2d81 100644
--- a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPastePostProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPastePostProcessor.kt
@@ -43,8 +43,8 @@ import org.jetbrains.kotlin.j2k.ConverterSettings
 import org.jetbrains.kotlin.j2k.JavaToKotlinConverter
 import org.jetbrains.kotlin.j2k.ParseContext
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import java.awt.datatransfer.Transferable
 import java.util.*
 
@@ -78,7 +78,7 @@ public class ConvertJavaCopyPastePostProcessor : CopyPastePostProcessor<TextBloc
         if (data !is CopiedJavaCode) return
 
         val document = editor.getDocument()
-        val targetFile = PsiDocumentManager.getInstance(project).getPsiFile(document) as? JetFile ?: return
+        val targetFile = PsiDocumentManager.getInstance(project).getPsiFile(document) as? KtFile ?: return
 
         data class Result(val text: String?, val referenceData: Collection<KotlinReferenceData>, val explicitImports: Set<FqName>)
 
@@ -201,7 +201,7 @@ public class ConvertJavaCopyPastePostProcessor : CopyPastePostProcessor<TextBloc
         return ConversionResult(convertedCode, parseContext ?: ParseContext.CODE_BLOCK, importsToAdd, convertedCode != originalCode)
     }
 
-    private fun buildReferenceData(text: String, parseContext: ParseContext, importsAndPackage: String, targetFile: JetFile): Collection<KotlinReferenceData> {
+    private fun buildReferenceData(text: String, parseContext: ParseContext, importsAndPackage: String, targetFile: KtFile): Collection<KotlinReferenceData> {
         var blockStart: Int? = null
         var blockEnd: Int? = null
         val fileText = StringBuilder {
@@ -221,7 +221,7 @@ public class ConvertJavaCopyPastePostProcessor : CopyPastePostProcessor<TextBloc
             append(contextSuffix)
         }.toString()
 
-        val dummyFile = JetPsiFactory(targetFile.getProject()).createAnalyzableFile("dummy.kt", fileText, targetFile)
+        val dummyFile = KtPsiFactory(targetFile.getProject()).createAnalyzableFile("dummy.kt", fileText, targetFile)
 
         return KotlinCopyPasteReferenceProcessor().collectReferenceData(dummyFile, intArrayOf(blockStart!!), intArrayOf(blockEnd!!))
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/coverage/KotlinCoverageExtension.kt b/idea/src/org/jetbrains/kotlin/idea/coverage/KotlinCoverageExtension.kt
index 251b9deeaaf..92407366ec3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/coverage/KotlinCoverageExtension.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/coverage/KotlinCoverageExtension.kt
@@ -23,7 +23,7 @@ import com.intellij.psi.PsiFile
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.coverage.CoverageSuitesBundle
 import java.io.File
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import com.intellij.openapi.roots.ProjectRootManager
 import com.intellij.psi.PsiClass
 import com.intellij.openapi.util.text.StringUtil
@@ -32,7 +32,7 @@ import com.intellij.coverage.PackageAnnotator
 import com.intellij.openapi.module.ModuleUtilCore
 import com.intellij.openapi.roots.CompilerModuleExtension
 import com.intellij.coverage.JavaCoverageAnnotator
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
 import com.intellij.openapi.vfs.VfsUtilCore
 import com.intellij.openapi.diagnostic.Logger
@@ -49,7 +49,7 @@ public class KotlinCoverageExtension(): JavaCoverageEngineExtension() {
     override fun isApplicableTo(conf: RunConfigurationBase?): Boolean = conf is JetRunConfiguration
 
     override fun suggestQualifiedName(sourceFile: PsiFile, classes: Array<out PsiClass>, names: MutableSet<String>): Boolean {
-        if (sourceFile is JetFile) {
+        if (sourceFile is KtFile) {
             val qNames = collectGeneratedClassQualifiedNames(findOutputRoot(sourceFile), sourceFile)
             if (qNames != null) {
                 names.addAll(qNames)
@@ -62,7 +62,7 @@ public class KotlinCoverageExtension(): JavaCoverageEngineExtension() {
     // Implements API added in IDEA 14.1
     override fun getSummaryCoverageInfo(coverageAnnotator: JavaCoverageAnnotator,
                                element: PsiNamedElement): PackageAnnotator.ClassCoverageInfo? {
-        if (element !is JetFile) {
+        if (element !is KtFile) {
             return null
         }
         LOG.info("Retrieving coverage for " + element.getName())
@@ -99,7 +99,7 @@ public class KotlinCoverageExtension(): JavaCoverageEngineExtension() {
                                     testoutput: VirtualFile?,
                                     suite: CoverageSuitesBundle,
                                     classFiles: MutableSet<File>): Boolean {
-        if (srcFile is JetFile) {
+        if (srcFile is KtFile) {
             val fileIndex = ProjectRootManager.getInstance(srcFile.getProject()).getFileIndex()
             if (fileIndex.isInLibraryClasses(srcFile.getVirtualFile()) ||
                 fileIndex.isInLibrarySource(srcFile.getVirtualFile())) {
@@ -119,7 +119,7 @@ public class KotlinCoverageExtension(): JavaCoverageEngineExtension() {
     companion object {
         private val LOG = Logger.getInstance(javaClass<KotlinCoverageExtension>())
 
-        fun collectGeneratedClassQualifiedNames(outputRoot: VirtualFile?, file: JetFile): List<String>? {
+        fun collectGeneratedClassQualifiedNames(outputRoot: VirtualFile?, file: KtFile): List<String>? {
             val existingClassFiles = getClassesGeneratedFromFile(outputRoot, file)
             if (existingClassFiles.isEmpty()) {
                 return null
@@ -153,7 +153,7 @@ public class KotlinCoverageExtension(): JavaCoverageEngineExtension() {
             return result
         }
 
-        private fun getClassesGeneratedFromFile(outputRoot: VirtualFile?, file: JetFile): List<VirtualFile> {
+        private fun getClassesGeneratedFromFile(outputRoot: VirtualFile?, file: KtFile): List<VirtualFile> {
             val relativePath = file.getPackageFqName().asString().replace('.', '/')
             val packageOutputDir = outputRoot?.findFileByRelativePath(relativePath)
             if (packageOutputDir == null) return listOf()
@@ -168,7 +168,7 @@ public class KotlinCoverageExtension(): JavaCoverageEngineExtension() {
             }
         }
 
-        private fun findOutputRoot(file: JetFile): VirtualFile? {
+        private fun findOutputRoot(file: KtFile): VirtualFile? {
             val module = ModuleUtilCore.findModuleForPsiElement(file)
             if (module == null) return null
             val fileIndex = ProjectRootManager.getInstance(file.getProject()).getFileIndex()
@@ -180,8 +180,8 @@ public class KotlinCoverageExtension(): JavaCoverageEngineExtension() {
                 compilerOutputExtension!!.getCompilerOutputPath()
         }
 
-        private fun collectClassFilePrefixes(file: JetFile): Collection<String> {
-            val result = file.getChildren().filter { it is JetClassOrObject }.map { (it as JetClassOrObject).getName()!! }
+        private fun collectClassFilePrefixes(file: KtFile): Collection<String> {
+            val result = file.getChildren().filter { it is KtClassOrObject }.map { (it as KtClassOrObject).getName()!! }
             val packagePartFqName = PackagePartClassUtils.getPackagePartFqName(file)
             return result.union(arrayListOf(packagePartFqName.shortName().asString()))
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/DiagnosticSuppressorForDebugger.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/DiagnosticSuppressorForDebugger.kt
index cc12da6f41a..29aa374affb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/DiagnosticSuppressorForDebugger.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/DiagnosticSuppressorForDebugger.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.debugger
 
 import org.jetbrains.kotlin.resolve.diagnostics.DiagnosticsWithSuppression
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.psi.codeFragmentUtil.suppressDiagnosticsInDebugMode
 
@@ -27,7 +27,7 @@ public class DiagnosticSuppressorForDebugger : DiagnosticsWithSuppression.Diagno
         val element = diagnostic.getPsiElement()
         val containingFile = element.getContainingFile()
 
-        if (containingFile is JetFile && containingFile.suppressDiagnosticsInDebugMode) {
+        if (containingFile is KtFile && containingFile.suppressDiagnosticsInDebugMode) {
             val diagnosticFactory = diagnostic.getFactory()
             return diagnosticFactory == Errors.INVISIBLE_MEMBER ||
                    diagnosticFactory == Errors.INVISIBLE_REFERENCE ||
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt
index 93069895ea1..7172d1ccbc3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt
@@ -105,7 +105,7 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
 
 
         if (lineNumber >= 0) {
-            val lambdaOrFunIfInside = getLambdaOrFunIfInside(location, psiFile as JetFile, lineNumber)
+            val lambdaOrFunIfInside = getLambdaOrFunIfInside(location, psiFile as KtFile, lineNumber)
             if (lambdaOrFunIfInside != null) {
                 return SourcePosition.createFromElement(lambdaOrFunIfInside.bodyExpression!!)
             }
@@ -115,7 +115,7 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
         throw NoDataException.INSTANCE
     }
 
-    private fun getLambdaOrFunIfInside(location: Location, file: JetFile, lineNumber: Int): JetFunction? {
+    private fun getLambdaOrFunIfInside(location: Location, file: KtFile, lineNumber: Int): KtFunction? {
         val currentLocationFqName = location.declaringType().name()
         if (currentLocationFqName == null) return null
 
@@ -124,8 +124,8 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
         if (start == null || end == null) return null
 
         val literalsOrFunctions = CodeInsightUtils.
-                findElementsOfClassInRange(file, start, end, JetFunctionLiteral::class.java, JetNamedFunction::class.java).
-                filter { JetPsiUtil.getParentCallIfPresent(it as JetExpression) != null }
+                findElementsOfClassInRange(file, start, end, KtFunctionLiteral::class.java, KtNamedFunction::class.java).
+                filter { KtPsiUtil.getParentCallIfPresent(it as KtExpression) != null }
 
         if (literalsOrFunctions.isEmpty()) return null;
 
@@ -137,7 +137,7 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
 
         val currentLocationClassName = JvmClassName.byFqNameWithoutInnerClasses(FqName(currentLocationFqName)).internalName
         for (literal in literalsOrFunctions) {
-            val functionLiteral = literal as JetFunction
+            val functionLiteral = literal as KtFunction
             if (isInlinedLambda(functionLiteral, typeMapper.bindingContext)) {
                 continue
             }
@@ -193,7 +193,7 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
 
     override fun getAllClasses(sourcePosition: SourcePosition): List<ReferenceType> {
         val psiFile = sourcePosition.file
-        if (psiFile is JetFile) {
+        if (psiFile is KtFile) {
             val result = ArrayList<ReferenceType>()
 
             if (!ProjectRootsUtil.isInProjectOrLibSource(psiFile)) return result
@@ -239,7 +239,7 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
                 null
             }
             else {
-                val file = element.containingFile as JetFile
+                val file = element.containingFile as KtFile
                 val isInLibrary = LibraryUtil.findLibraryEntry(file.virtualFile, file.project) != null
                 val typeMapper = if (!isInLibrary) prepareTypeMapper(file) else createTypeMapperForLibraryFile(element, file)
                 getInternalClassNameForElement(element, typeMapper, file, isInLibrary).className
@@ -247,7 +247,7 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
         }
     }
 
-    private fun prepareTypeMapper(file: JetFile): JetTypeMapper {
+    private fun prepareTypeMapper(file: KtFile): JetTypeMapper {
         val key = createKeyForTypeMapper(file)
 
         var value: CachedValue<JetTypeMapper>? = myTypeMappers.get(key)
@@ -265,7 +265,7 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
     }
 
     override fun locationsOfLine(type: ReferenceType, position: SourcePosition): List<Location> {
-        if (position.file !is JetFile) {
+        if (position.file !is KtFile) {
             throw NoDataException.INSTANCE
         }
         try {
@@ -284,7 +284,7 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
 
     @Deprecated("Since Idea 14.0.3 use createPrepareRequests fun")
     override fun createPrepareRequest(classPrepareRequestor: ClassPrepareRequestor, sourcePosition: SourcePosition): ClassPrepareRequest? {
-        if (sourcePosition.file !is JetFile) {
+        if (sourcePosition.file !is KtFile) {
             throw NoDataException.INSTANCE
         }
         val className = classNameForPosition(sourcePosition) ?: return null
@@ -292,7 +292,7 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
     }
 
     override fun createPrepareRequests(requestor: ClassPrepareRequestor, position: SourcePosition): List<ClassPrepareRequest> {
-        if (position.file !is JetFile) {
+        if (position.file !is KtFile) {
             throw NoDataException.INSTANCE
         }
 
@@ -302,7 +302,7 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
     }
 
     @TestOnly
-    public fun addTypeMapper(file: JetFile, typeMapper: JetTypeMapper) {
+    public fun addTypeMapper(file: KtFile, typeMapper: JetTypeMapper) {
         val value = CachedValuesManager.getManager(file.project).createCachedValue<JetTypeMapper>(
                 { CachedValueProvider.Result(typeMapper, PsiModificationTracker.MODIFICATION_COUNT) }, false)
         val key = createKeyForTypeMapper(file)
@@ -310,7 +310,7 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
     }
 
     companion object {
-        public fun createTypeMapper(file: JetFile): JetTypeMapper {
+        public fun createTypeMapper(file: KtFile): JetTypeMapper {
             val project = file.project
 
             val analysisResult = file.analyzeFullyAndGetResult()
@@ -326,11 +326,11 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
             return state.typeMapper
         }
 
-        public fun getInternalClassNameForElement(notPositionedElement: PsiElement?, typeMapper: JetTypeMapper, file: JetFile, isInLibrary: Boolean): PositionedElement {
+        public fun getInternalClassNameForElement(notPositionedElement: PsiElement?, typeMapper: JetTypeMapper, file: KtFile, isInLibrary: Boolean): PositionedElement {
             val element = getElementToCalculateClassName(notPositionedElement)
             when {
-                element is JetClassOrObject -> return PositionedElement(getJvmInternalNameForImpl(typeMapper, element), element)
-                element is JetFunctionLiteral -> {
+                element is KtClassOrObject -> return PositionedElement(getJvmInternalNameForImpl(typeMapper, element), element)
+                element is KtFunctionLiteral -> {
                     if (isInlinedLambda(element, typeMapper.bindingContext)) {
                         return getInternalClassNameForElement(element.parent, typeMapper, file, isInLibrary)
                     }
@@ -339,17 +339,17 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
                         return PositionedElement(asmType.internalName, element)
                     }
                 }
-                element is JetClassInitializer -> {
+                element is KtClassInitializer -> {
                     val parent = getElementToCalculateClassName(element.parent)
                     // Class-object initializer
-                    if (parent is JetObjectDeclaration && parent.isCompanion()) {
+                    if (parent is KtObjectDeclaration && parent.isCompanion()) {
                         return PositionedElement(getInternalClassNameForElement(parent.parent, typeMapper, file, isInLibrary).className, parent)
                     }
                     return getInternalClassNameForElement(element.parent, typeMapper, file, isInLibrary)
                 }
-                element is JetProperty && (!element.isTopLevel || !isInLibrary) -> {
+                element is KtProperty && (!element.isTopLevel || !isInLibrary) -> {
                     if (isInPropertyAccessor(notPositionedElement)) {
-                        val classOrObject = PsiTreeUtil.getParentOfType(element, JetClassOrObject::class.java)
+                        val classOrObject = PsiTreeUtil.getParentOfType(element, KtClassOrObject::class.java)
                         if (classOrObject != null) {
                             return PositionedElement(getJvmInternalNameForImpl(typeMapper, classOrObject), element)
                         }
@@ -362,13 +362,13 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
 
                     return PositionedElement(getJvmInternalNameForPropertyOwner(typeMapper, descriptor), element)
                 }
-                element is JetNamedFunction -> {
+                element is KtNamedFunction -> {
                     if (isInlinedLambda(element, typeMapper.bindingContext)) {
                         return getInternalClassNameForElement(element.parent, typeMapper, file, isInLibrary)
                     }
 
                     val parent = getElementToCalculateClassName(element.parent)
-                    if (parent is JetClassOrObject) {
+                    if (parent is KtClassOrObject) {
                         return PositionedElement(getJvmInternalNameForImpl(typeMapper, parent), element)
                     }
                     else if (parent != null) {
@@ -381,15 +381,15 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
             return PositionedElement(NoResolveFileClassesProvider.getFileClassInternalName(file), element)
         }
 
-        private val TYPES_TO_CALCULATE_CLASSNAME: Array<Class<out JetElement>> =
-                arrayOf(JetClassOrObject::class.java,
-                        JetFunctionLiteral::class.java,
-                        JetNamedFunction::class.java,
-                        JetProperty::class.java,
-                        JetClassInitializer::class.java)
+        private val TYPES_TO_CALCULATE_CLASSNAME: Array<Class<out KtElement>> =
+                arrayOf(KtClassOrObject::class.java,
+                        KtFunctionLiteral::class.java,
+                        KtNamedFunction::class.java,
+                        KtProperty::class.java,
+                        KtClassInitializer::class.java)
 
-        private fun getElementToCalculateClassName(notPositionedElement: PsiElement?): JetElement? {
-            if (notPositionedElement?.javaClass in TYPES_TO_CALCULATE_CLASSNAME ) return notPositionedElement as JetElement
+        private fun getElementToCalculateClassName(notPositionedElement: PsiElement?): KtElement? {
+            if (notPositionedElement?.javaClass in TYPES_TO_CALCULATE_CLASSNAME ) return notPositionedElement as KtElement
 
             return PsiTreeUtil.getParentOfType(notPositionedElement, *TYPES_TO_CALCULATE_CLASSNAME)
         }
@@ -401,23 +401,23 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
         }
 
         private fun isInPropertyAccessor(element: PsiElement?) =
-                element is JetPropertyAccessor ||
-                PsiTreeUtil.getParentOfType(element, JetProperty::class.java, JetPropertyAccessor::class.java) is JetPropertyAccessor
+                element is KtPropertyAccessor ||
+                PsiTreeUtil.getParentOfType(element, KtProperty::class.java, KtPropertyAccessor::class.java) is KtPropertyAccessor
 
         private fun getElementToCreateTypeMapperForLibraryFile(element: PsiElement?) =
-                if (element is JetElement) element else PsiTreeUtil.getParentOfType(element, JetElement::class.java)
+                if (element is KtElement) element else PsiTreeUtil.getParentOfType(element, KtElement::class.java)
 
-        private fun getJvmInternalNameForImpl(typeMapper: JetTypeMapper, jetClass: JetClassOrObject): String? {
-            val classDescriptor = typeMapper.bindingContext.get<PsiElement, ClassDescriptor>(BindingContext.CLASS, jetClass) ?: return null
+        private fun getJvmInternalNameForImpl(typeMapper: JetTypeMapper, ktClass: KtClassOrObject): String? {
+            val classDescriptor = typeMapper.bindingContext.get<PsiElement, ClassDescriptor>(BindingContext.CLASS, ktClass) ?: return null
 
-            if (jetClass is JetClass && jetClass.isInterface()) {
+            if (ktClass is KtClass && ktClass.isInterface()) {
                 return typeMapper.mapDefaultImpls(classDescriptor).internalName
             }
 
             return typeMapper.mapClass(classDescriptor).internalName
         }
 
-        private fun createTypeMapperForLibraryFile(notPositionedElement: PsiElement?, file: JetFile): JetTypeMapper {
+        private fun createTypeMapperForLibraryFile(notPositionedElement: PsiElement?, file: KtFile): JetTypeMapper {
             val element = getElementToCreateTypeMapperForLibraryFile(notPositionedElement)
             val analysisResult = element!!.analyzeAndGetResult()
 
@@ -426,15 +426,15 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
             return state.typeMapper
         }
 
-        public fun isInlinedLambda(functionLiteral: JetFunction, context: BindingContext): Boolean {
+        public fun isInlinedLambda(functionLiteral: KtFunction, context: BindingContext): Boolean {
             return InlineUtil.isInlinedArgument(functionLiteral, context, false)
         }
 
-        private fun createKeyForTypeMapper(file: JetFile) = NoResolveFileClassesProvider.getFileClassInternalName(file)
+        private fun createKeyForTypeMapper(file: KtFile) = NoResolveFileClassesProvider.getFileClassInternalName(file)
     }
 
     private fun findInlinedCalls(element: PsiElement?, jetFile: PsiFile?): List<String> {
-        if (element == null || jetFile !is JetFile) {
+        if (element == null || jetFile !is KtFile) {
             return emptyList()
         }
 
@@ -444,13 +444,13 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
             val typeMapper = if (!isInLibrary) prepareTypeMapper(jetFile) else createTypeMapperForLibraryFile(element, jetFile)
             val psiElement = getInternalClassNameForElement(element, typeMapper, jetFile, isInLibrary).element;
 
-            if (psiElement is JetNamedFunction &&
+            if (psiElement is KtNamedFunction &&
                 InlineUtil.isInline(typeMapper.bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, psiElement))
             ) {
                 ReferencesSearch.search(psiElement).forEach {
                     if (!it.isImportUsage()) {
                         val usage = it.element
-                        if (usage is JetElement) {
+                        if (usage is KtElement) {
                             //TODO recursive search
                             val name = classNameForPosition(usage)
                             if (name != null) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinEditorTextProvider.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinEditorTextProvider.kt
index 15d8e16a975..c4786e614d4 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinEditorTextProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinEditorTextProvider.kt
@@ -23,7 +23,7 @@ import com.intellij.openapi.util.TextRange
 import com.intellij.openapi.util.Pair
 import com.intellij.debugger.engine.evaluation.TextWithImportsImpl
 import com.intellij.debugger.engine.evaluation.CodeFragmentKind
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.psi.*
 
@@ -32,7 +32,7 @@ class KotlinEditorTextProvider : EditorTextProvider {
         val expression = findExpressionInner(elementAtCaret, true) ?: return null
 
         val expressionText = getElementInfo(expression) { it.getText() }
-        return TextWithImportsImpl(CodeFragmentKind.EXPRESSION, expressionText, "", JetFileType.INSTANCE)
+        return TextWithImportsImpl(CodeFragmentKind.EXPRESSION, expressionText, "", KotlinFileType.INSTANCE)
     }
 
     override fun findExpression(elementAtCaret: PsiElement, allowMethodCalls: Boolean): Pair<PsiElement, TextRange>? {
@@ -44,9 +44,9 @@ class KotlinEditorTextProvider : EditorTextProvider {
 
     companion object {
 
-        fun <T> getElementInfo(expr: JetExpression, f: (PsiElement) -> T): T {
+        fun <T> getElementInfo(expr: KtExpression, f: (PsiElement) -> T): T {
             var expressionText = f(expr)
-            if (expr is JetProperty) {
+            if (expr is KtProperty) {
                 val nameIdentifier = expr.getNameIdentifier()
                 if (nameIdentifier != null) {
                     expressionText = f(nameIdentifier)
@@ -55,13 +55,13 @@ class KotlinEditorTextProvider : EditorTextProvider {
             return expressionText
         }
 
-        fun findExpressionInner(element: PsiElement, allowMethodCalls: Boolean): JetExpression? {
+        fun findExpressionInner(element: PsiElement, allowMethodCalls: Boolean): KtExpression? {
             if (!isAcceptedAsCodeFragmentContext(element)) return null
 
-            val jetElement = PsiTreeUtil.getParentOfType(element, javaClass<JetElement>())
+            val jetElement = PsiTreeUtil.getParentOfType(element, javaClass<KtElement>())
             if (jetElement == null) return null
 
-            if (jetElement is JetProperty) {
+            if (jetElement is KtProperty) {
                 val nameIdentifier = jetElement.getNameIdentifier()
                 if (nameIdentifier == element) {
                     return jetElement
@@ -72,23 +72,23 @@ class KotlinEditorTextProvider : EditorTextProvider {
             if (parent == null) return null
 
             val newExpression = when (parent) {
-                is JetThisExpression,
-                is JetSuperExpression,
-                is JetReferenceExpression -> {
+                is KtThisExpression,
+                is KtSuperExpression,
+                is KtReferenceExpression -> {
                     val pparent = parent.getParent()
                     when (pparent) {
-                        is JetQualifiedExpression -> pparent
+                        is KtQualifiedExpression -> pparent
                         else -> parent
                     }
                 }
-                is JetQualifiedExpression -> {
+                is KtQualifiedExpression -> {
                     if (parent.getReceiverExpression() != jetElement) {
                         parent
                     } else {
                         null
                     }
                 }
-                is JetOperationExpression -> {
+                is KtOperationExpression -> {
                     if (parent.getOperationReference() == jetElement) {
                         parent
                     } else {
@@ -99,24 +99,24 @@ class KotlinEditorTextProvider : EditorTextProvider {
             }
 
             if (!allowMethodCalls && newExpression != null) {
-                fun PsiElement.isCall() = this is JetCallExpression || this is JetOperationExpression || this is JetArrayAccessExpression
+                fun PsiElement.isCall() = this is KtCallExpression || this is KtOperationExpression || this is KtArrayAccessExpression
 
                 if (newExpression.isCall() ||
-                        newExpression is JetQualifiedExpression && newExpression.getSelectorExpression()!!.isCall()) {
+                        newExpression is KtQualifiedExpression && newExpression.getSelectorExpression()!!.isCall()) {
                     return null
                 }
             }
 
             return when {
-                newExpression is JetExpression -> newExpression
-                jetElement is JetSimpleNameExpression -> jetElement
+                newExpression is KtExpression -> newExpression
+                jetElement is KtSimpleNameExpression -> jetElement
                 else -> null
             }
 
         }
 
         private val NOT_ACCEPTED_AS_CONTEXT_TYPES =
-                arrayOf(javaClass<JetUserType>(), javaClass<JetImportDirective>(), javaClass<JetPackageDirective>())
+                arrayOf(javaClass<KtUserType>(), javaClass<KtImportDirective>(), javaClass<KtPackageDirective>())
 
         fun isAcceptedAsCodeFragmentContext(element: PsiElement): Boolean {
             return element.javaClass !in NOT_ACCEPTED_AS_CONTEXT_TYPES &&
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinFrameExtraVariablesProvider.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinFrameExtraVariablesProvider.kt
index fe79d14622a..7074de4d380 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinFrameExtraVariablesProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinFrameExtraVariablesProvider.kt
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
 import java.util.LinkedHashSet
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
@@ -43,7 +43,7 @@ public class KotlinFrameExtraVariablesProvider : FrameExtraVariablesProvider {
     override fun isAvailable(sourcePosition: SourcePosition?, evalContext: EvaluationContext?): Boolean {
         if (sourcePosition == null) return false
         if (sourcePosition.getLine() < 0) return false
-        return sourcePosition.getFile().getFileType() == JetFileType.INSTANCE && DebuggerSettings.getInstance().AUTO_VARIABLES_MODE
+        return sourcePosition.getFile().getFileType() == KotlinFileType.INSTANCE && DebuggerSettings.getInstance().AUTO_VARIABLES_MODE
     }
 
     override fun collectVariables(sourcePosition: SourcePosition?, evalContext: EvaluationContext?, alreadyCollected: Set<String>?
@@ -101,16 +101,16 @@ private fun findAdditionalExpressions(position: SourcePosition): Set<TextWithImp
     return expressions
 }
 
-private fun getContainingElement(element: PsiElement): JetElement? {
-    val contElement = PsiTreeUtil.getParentOfType(element, javaClass<JetDeclaration>()) ?: PsiTreeUtil.getParentOfType(element, javaClass<JetElement>())
-    if (contElement is JetProperty && contElement.isLocal()) {
+private fun getContainingElement(element: PsiElement): KtElement? {
+    val contElement = PsiTreeUtil.getParentOfType(element, javaClass<KtDeclaration>()) ?: PsiTreeUtil.getParentOfType(element, javaClass<KtElement>())
+    if (contElement is KtProperty && contElement.isLocal()) {
         val parent = contElement.getParent()
         if (parent != null) {
             return getContainingElement(parent)
         }
     }
 
-    if (contElement is JetDeclarationWithBody) {
+    if (contElement is KtDeclarationWithBody) {
         return contElement.getBodyExpression()
     }
     return contElement
@@ -130,24 +130,24 @@ private fun shouldSkipLine(file: PsiFile, doc: Document, line: Int): Boolean {
 
     val elemAtOffset = file.findElementAt(start)
     val topmostElementAtOffset = CodeInsightUtils.getTopmostElementAtOffset(elemAtOffset!!, start)
-    return topmostElementAtOffset !is JetDeclaration
+    return topmostElementAtOffset !is KtDeclaration
 }
 
 private class VariablesCollector(
         private val myLineRange: TextRange,
         private val myExpressions: MutableSet<TextWithImports>
-) : JetTreeVisitorVoid() {
+) : KtTreeVisitorVoid() {
 
-    override fun visitJetElement(element: JetElement) {
+    override fun visitJetElement(element: KtElement) {
         if (element.isInRange()) {
             super.visitJetElement(element)
         }
     }
 
-    override fun visitQualifiedExpression(expression: JetQualifiedExpression) {
+    override fun visitQualifiedExpression(expression: KtQualifiedExpression) {
         if (expression.isInRange()) {
             val selector = expression.getSelectorExpression()
-            if (selector is JetReferenceExpression) {
+            if (selector is KtReferenceExpression) {
                 if (isRefToProperty(selector)) {
                     myExpressions.add(expression.createText())
                     return
@@ -157,7 +157,7 @@ private class VariablesCollector(
         super.visitQualifiedExpression(expression)
     }
 
-    private fun isRefToProperty(expression: JetReferenceExpression): Boolean {
+    private fun isRefToProperty(expression: KtReferenceExpression): Boolean {
         val context = expression.analyzeFully()
         val descriptor = context[BindingContext.REFERENCE_TARGET, expression]
         if (descriptor is PropertyDescriptor) {
@@ -168,7 +168,7 @@ private class VariablesCollector(
         return false
     }
 
-    override fun visitReferenceExpression(expression: JetReferenceExpression) {
+    override fun visitReferenceExpression(expression: KtReferenceExpression) {
         if (expression.isInRange()) {
             if (isRefToProperty(expression)) {
                 myExpressions.add(expression.createText())
@@ -177,22 +177,22 @@ private class VariablesCollector(
         super.visitReferenceExpression(expression)
     }
 
-    private fun JetElement.isInRange(): Boolean = myLineRange.intersects(this.getTextRange())
-    private fun JetElement.createText(): TextWithImports = TextWithImportsImpl(CodeFragmentKind.EXPRESSION, this.getText())
+    private fun KtElement.isInRange(): Boolean = myLineRange.intersects(this.getTextRange())
+    private fun KtElement.createText(): TextWithImports = TextWithImportsImpl(CodeFragmentKind.EXPRESSION, this.getText())
 
-    override fun visitClass(klass: JetClass) {
+    override fun visitClass(klass: KtClass) {
         // Do not show expressions used in local classes
     }
 
-    override fun visitNamedFunction(function: JetNamedFunction) {
+    override fun visitNamedFunction(function: KtNamedFunction) {
         // Do not show expressions used in local functions
     }
 
-    override fun visitObjectLiteralExpression(expression: JetObjectLiteralExpression) {
+    override fun visitObjectLiteralExpression(expression: KtObjectLiteralExpression) {
         // Do not show expressions used in anonymous objects
     }
 
-    override fun visitFunctionLiteralExpression(expression: JetFunctionLiteralExpression) {
+    override fun visitFunctionLiteralExpression(expression: KtFunctionLiteralExpression) {
         // Do not show expressions used in lambdas
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinSourcePositionHighlighter.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinSourcePositionHighlighter.kt
index 0cddefb0198..d461c451fa2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinSourcePositionHighlighter.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinSourcePositionHighlighter.kt
@@ -19,12 +19,12 @@ package org.jetbrains.kotlin.idea.debugger
 import com.intellij.debugger.SourcePosition
 import com.intellij.debugger.engine.SourcePositionHighlighter
 import com.intellij.openapi.util.TextRange
-import org.jetbrains.kotlin.psi.JetFunctionLiteral
+import org.jetbrains.kotlin.psi.KtFunctionLiteral
 
 public class KotlinSourcePositionHighlighter: SourcePositionHighlighter() {
     override fun getHighlightRange(sourcePosition: SourcePosition?): TextRange? {
         val lambda = sourcePosition?.elementAt?.parent
-        if (lambda is JetFunctionLiteral) {
+        if (lambda is KtFunctionLiteral) {
             return lambda.textRange
         }
         return null
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinSourcePositionProvider.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinSourcePositionProvider.kt
index cc9b93cd059..78800f59ebf 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinSourcePositionProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinSourcePositionProvider.kt
@@ -60,13 +60,13 @@ public class KotlinSourcePositionProvider: SourcePositionProvider() {
 
     private fun computeSourcePosition(descriptor: LocalVariableDescriptor, project: Project, context: DebuggerContextImpl, nearest: Boolean): SourcePosition? {
         val place = PositionUtil.getContextElement(context) ?: return null
-        if (place.getContainingFile() !is JetFile) return null
+        if (place.getContainingFile() !is KtFile) return null
 
         val contextElement = KotlinCodeFragmentFactory.getContextElement(place) ?: return null
 
-        val codeFragment = JetPsiFactory(project).createExpressionCodeFragment(descriptor.getName(), contextElement)
+        val codeFragment = KtPsiFactory(project).createExpressionCodeFragment(descriptor.getName(), contextElement)
         val expression = codeFragment.getContentElement()
-        if (expression is JetSimpleNameExpression) {
+        if (expression is KtSimpleNameExpression) {
             val bindingContext = expression.analyze(BodyResolveMode.PARTIAL)
             val declarationDescriptor = BindingContextUtils.extractVariableDescriptorIfAny(bindingContext, expression, false)
             val sourceElement = declarationDescriptor?.getSource()
@@ -89,7 +89,7 @@ public class KotlinSourcePositionProvider: SourcePositionProvider() {
         }
 
         val type = descriptor.getField().declaringType()
-        val myClass = findClassByType(project, type, context)?.getNavigationElement() as? JetClassOrObject ?: return null
+        val myClass = findClassByType(project, type, context)?.getNavigationElement() as? KtClassOrObject ?: return null
 
         val field = myClass.getDeclarations().firstOrNull { fieldName == it.getName() } ?: return null
 
@@ -111,7 +111,7 @@ public class KotlinSourcePositionProvider: SourcePositionProvider() {
         if (position != null) {
             val element = position.getElementAt()
             if (element != null) {
-                return element.getStrictParentOfType<JetClassOrObject>()
+                return element.getStrictParentOfType<KtClassOrObject>()
             }
         }
         return null
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpoint.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpoint.kt
index ba810ac7afc..47a3cb8b815 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpoint.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpoint.kt
@@ -48,10 +48,10 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetParameter
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtParameter
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.resolve.BindingContext
 import javax.swing.Icon
 
@@ -80,17 +80,17 @@ class KotlinFieldBreakpoint(
         }
     }
 
-    public fun getField(): JetCallableDeclaration? {
+    public fun getField(): KtCallableDeclaration? {
         val sourcePosition = getSourcePosition()
         return getProperty(sourcePosition)
     }
 
-    private fun getProperty(sourcePosition: SourcePosition?): JetCallableDeclaration? {
-        val property: JetProperty? = PositionUtil.getPsiElementAt(getProject(), javaClass(), sourcePosition)
+    private fun getProperty(sourcePosition: SourcePosition?): KtCallableDeclaration? {
+        val property: KtProperty? = PositionUtil.getPsiElementAt(getProject(), javaClass(), sourcePosition)
         if (property != null) {
             return property
         }
-        val parameter: JetParameter? = PositionUtil.getPsiElementAt(getProject(), javaClass(), sourcePosition)
+        val parameter: KtParameter? = PositionUtil.getPsiElementAt(getProject(), javaClass(), sourcePosition)
         if (parameter != null) {
             return parameter
         }
@@ -102,13 +102,13 @@ class KotlinFieldBreakpoint(
         if (property != null) {
             setFieldName(property.getName()!!)
 
-            if (property is JetProperty && property.isTopLevel()) {
+            if (property is KtProperty && property.isTopLevel()) {
                 getProperties().myClassName = JvmFileClassUtil.getFileClassInfoNoResolve(property.getContainingJetFile()).fileClassFqName.asString()
             }
             else {
-                val jetClass: JetClassOrObject? = PsiTreeUtil.getParentOfType(property, javaClass())
-                if (jetClass is JetClassOrObject) {
-                    val fqName = jetClass.getFqName()
+                val ktClass: KtClassOrObject? = PsiTreeUtil.getParentOfType(property, javaClass())
+                if (ktClass is KtClassOrObject) {
+                    val fqName = ktClass.getFqName()
                     if (fqName != null) {
                         getProperties().myClassName = fqName.asString()
                     }
@@ -188,7 +188,7 @@ class KotlinFieldBreakpoint(
         }
     }
 
-    private fun computeBreakpointType(property: JetCallableDeclaration): BreakpointType {
+    private fun computeBreakpointType(property: KtCallableDeclaration): BreakpointType {
         return runReadAction {
             val bindingContext = property.analyze()
             var descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, property)
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpointType.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpointType.kt
index 1b397e6bead..b57a3e07ea9 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpointType.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpointType.kt
@@ -41,7 +41,7 @@ import org.jetbrains.kotlin.asJava.KotlinLightClassForFacade
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.idea.JetBundle
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.debugger.breakpoints.dialog.AddFieldBreakpointDialog
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
@@ -113,13 +113,13 @@ public class KotlinFieldBreakpointType : JavaBreakpointType<KotlinPropertyBreakp
     }
 
     private fun createBreakpointIfPropertyExists(
-            declaration: JetDeclarationContainer,
-            file: JetFile,
+            declaration: KtDeclarationContainer,
+            file: KtFile,
             className: String,
             fieldName: String
     ): XLineBreakpoint<KotlinPropertyBreakpointProperties>? {
         val project = file.getProject()
-        val property = declaration.getDeclarations().firstOrNull { it is JetProperty && it.getName() == fieldName } ?: return null
+        val property = declaration.getDeclarations().firstOrNull { it is KtProperty && it.getName() == fieldName } ?: return null
 
         val document = PsiDocumentManager.getInstance(project).getDocument(file) ?: return null
         val line = document.getLineNumber(property.getTextOffset())
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinLineBreakpointType.java b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinLineBreakpointType.java
index 6d6e933b002..971e7107626 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinLineBreakpointType.java
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinLineBreakpointType.java
@@ -26,7 +26,7 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.psi.JetFunction;
+import org.jetbrains.kotlin.psi.KtFunction;
 
 public class KotlinLineBreakpointType extends JavaLineBreakpointType {
     public KotlinLineBreakpointType() {
@@ -54,7 +54,7 @@ public class KotlinLineBreakpointType extends JavaLineBreakpointType {
     @Nullable
     public static PsiElement getContainingMethod(@Nullable PsiElement elem) {
         //noinspection unchecked
-        return PsiTreeUtil.getParentOfType(elem, JetFunction.class);
+        return PsiTreeUtil.getParentOfType(elem, KtFunction.class);
     }
 
     public static boolean inTheMethod(@NotNull SourcePosition pos, @NotNull PsiElement method) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/breakpointTypeUtils.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/breakpointTypeUtils.kt
index dcc705a5ad3..2bfedc5e898 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/breakpointTypeUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/breakpointTypeUtils.kt
@@ -25,7 +25,7 @@ import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.xdebugger.XDebuggerUtil
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.resolve.BindingContext
 fun canPutAt(file: VirtualFile, line: Int, project: Project, breakpointTypeClass: Class<*>): Boolean {
     val psiFile = PsiManager.getInstance(project).findFile(file)
 
-    if (psiFile == null || psiFile.virtualFile.fileType != JetFileType.INSTANCE) {
+    if (psiFile == null || psiFile.virtualFile.fileType != KotlinFileType.INSTANCE) {
         return false
     }
 
@@ -56,8 +56,8 @@ fun canPutAt(file: VirtualFile, line: Int, project: Project, breakpointTypeClass
             parent = element.parent
         }
 
-        if (element is JetProperty || element is JetParameter) {
-            val bindingContext = (element as JetElement).analyze()
+        if (element is KtProperty || element is KtParameter) {
+            val bindingContext = (element as KtElement).analyze()
             var descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element)
             if (descriptor is ValueParameterDescriptor) {
                 descriptor = bindingContext.get(BindingContext.VALUE_PARAMETER_AS_PROPERTY, descriptor)
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/dialog/AddFieldBreakpointDialog.java b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/dialog/AddFieldBreakpointDialog.java
index 8f2df8a73de..4c71e2a35d0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/dialog/AddFieldBreakpointDialog.java
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/dialog/AddFieldBreakpointDialog.java
@@ -28,7 +28,7 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.ui.DocumentAdapter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.core.util.DescriptorMemberChooserObject;
-import org.jetbrains.kotlin.psi.JetProperty;
+import org.jetbrains.kotlin.psi.KtProperty;
 
 import javax.swing.*;
 import javax.swing.event.DocumentEvent;
@@ -92,7 +92,7 @@ public abstract class AddFieldBreakpointDialog extends DialogWrapper {
                 chooser.show();
                 List<DescriptorMemberChooserObject> selectedElements = chooser.getSelectedElements();
                 if (selectedElements != null && selectedElements.size() == 1) {
-                    JetProperty field = (JetProperty) selectedElements.get(0).getElement();
+                    KtProperty field = (KtProperty) selectedElements.get(0).getElement();
                     myFieldChooser.setText(field.getName());
                 }
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/dialog/fieldBreakpointDialogUtil.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/dialog/fieldBreakpointDialogUtil.kt
index 725a6d1734c..cbf1dfbd13c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/dialog/fieldBreakpointDialogUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/dialog/fieldBreakpointDialogUtil.kt
@@ -21,13 +21,13 @@ import org.jetbrains.kotlin.asJava.KotlinLightClass
 import org.jetbrains.kotlin.asJava.KotlinLightClassForFacade
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.core.util.DescriptorMemberChooserObject
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtProperty
 
 fun PsiClass.collectProperties(): Array<DescriptorMemberChooserObject> {
     if (this is KotlinLightClassForFacade) {
         val result = arrayListOf<DescriptorMemberChooserObject>()
         this.files.forEach {
-            it.getDeclarations().filterIsInstance<JetProperty>().forEach {
+            it.getDeclarations().filterIsInstance<KtProperty>().forEach {
                 result.add(DescriptorMemberChooserObject(it, it.resolveToDescriptor()))
             }
         }
@@ -36,7 +36,7 @@ fun PsiClass.collectProperties(): Array<DescriptorMemberChooserObject> {
     if (this is KotlinLightClass) {
         val origin = this.getOrigin()
         if (origin != null) {
-            return origin.getDeclarations().filterIsInstance<JetProperty>().map {
+            return origin.getDeclarations().filterIsInstance<KtProperty>().map {
                 DescriptorMemberChooserObject(it, it.resolveToDescriptor())
             }.toTypedArray()
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt
index f70f6f7eb08..58365870c9a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt
@@ -44,7 +44,7 @@ import org.jetbrains.eval4j.jdi.asValue
 import org.jetbrains.kotlin.asJava.KotlinLightClass
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
 import org.jetbrains.kotlin.idea.core.refactoring.j2kText
@@ -61,7 +61,7 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.typeUtil.makeNullable
 import org.jetbrains.kotlin.utils.addToStdlib.check
 import java.util.*
@@ -77,7 +77,7 @@ class KotlinCodeFragmentFactory: CodeFragmentFactory() {
             LOG.warn("CodeFragment with null context created:\noriginalContext = ${context?.getElementTextWithContext()}")
         }
         val codeFragment = if (item.kind == CodeFragmentKind.EXPRESSION) {
-            JetExpressionCodeFragment(
+            KtExpressionCodeFragment(
                     project,
                     "fragment.kt",
                     item.text,
@@ -86,7 +86,7 @@ class KotlinCodeFragmentFactory: CodeFragmentFactory() {
             )
         }
         else {
-            JetBlockCodeFragment(
+            KtBlockCodeFragment(
                     project,
                     "fragment.kt",
                     item.text,
@@ -95,8 +95,8 @@ class KotlinCodeFragmentFactory: CodeFragmentFactory() {
             )
         }
 
-        codeFragment.putCopyableUserData(JetCodeFragment.RUNTIME_TYPE_EVALUATOR, {
-            expression: JetExpression ->
+        codeFragment.putCopyableUserData(KtCodeFragment.RUNTIME_TYPE_EVALUATOR, {
+            expression: KtExpression ->
 
             val debuggerContext = DebuggerManagerEx.getInstanceEx(project).context
             val debuggerSession = debuggerContext.debuggerSession
@@ -106,9 +106,9 @@ class KotlinCodeFragmentFactory: CodeFragmentFactory() {
             else {
                 val semaphore = Semaphore()
                 semaphore.down()
-                val nameRef = AtomicReference<JetType>()
+                val nameRef = AtomicReference<KtType>()
                 val worker = object : KotlinRuntimeTypeEvaluator(null, expression, debuggerContext, ProgressManager.getInstance().progressIndicator) {
-                    override fun typeCalculationFinished(type: JetType?) {
+                    override fun typeCalculationFinished(type: KtType?) {
                         nameRef.set(type)
                         semaphore.up()
                     }
@@ -128,7 +128,7 @@ class KotlinCodeFragmentFactory: CodeFragmentFactory() {
         if (contextElement != null) {
             val lambdas = getInlinedLambdasInside(contextElement)
             if (lambdas.isNotEmpty()) {
-                codeFragment.putCopyableUserData(JetCodeFragment.ADDITIONAL_CONTEXT_FOR_LAMBDA, lamdba@ {
+                codeFragment.putCopyableUserData(KtCodeFragment.ADDITIONAL_CONTEXT_FOR_LAMBDA, lamdba@ {
                     val debuggerContext = DebuggerManagerEx.getInstanceEx(project).context
 
                     val semaphore = Semaphore()
@@ -204,10 +204,10 @@ class KotlinCodeFragmentFactory: CodeFragmentFactory() {
             // PsiCodeBlock -> DummyHolder -> originalElement
             return isContextAccepted(contextElement.context?.context)
         }
-        return contextElement?.language == JetFileType.INSTANCE.language
+        return contextElement?.language == KotlinFileType.INSTANCE.language
     }
 
-    override fun getFileType() = JetFileType.INSTANCE
+    override fun getFileType() = KotlinFileType.INSTANCE
 
     override fun getEvaluatorBuilder() = KotlinEvaluationBuilder
 
@@ -216,7 +216,7 @@ class KotlinCodeFragmentFactory: CodeFragmentFactory() {
         public val DEBUG_LABEL_SUFFIX: String = "_DebugLabel"
         @TestOnly val DEBUG_FRAME_FOR_TESTS: Key<StackFrameProxyImpl> = Key.create("DEBUG_FRAME_FOR_TESTS")
 
-        fun getContextElement(elementAt: PsiElement?): JetElement? {
+        fun getContextElement(elementAt: PsiElement?): KtElement? {
             if (elementAt == null) return null
 
             if (elementAt is PsiCodeBlock) {
@@ -228,11 +228,11 @@ class KotlinCodeFragmentFactory: CodeFragmentFactory() {
             }
 
             val containingFile = elementAt.containingFile
-            if (containingFile !is JetFile) return null
+            if (containingFile !is KtFile) return null
 
-            var result = PsiTreeUtil.findElementOfClassAtOffset(containingFile, elementAt.textOffset, javaClass<JetExpression>(), false)
+            var result = PsiTreeUtil.findElementOfClassAtOffset(containingFile, elementAt.textOffset, javaClass<KtExpression>(), false)
             if (result.check()) {
-                return CodeInsightUtils.getTopmostElementAtOffset(result!!, result.textOffset, JetExpression::class.java)
+                return CodeInsightUtils.getTopmostElementAtOffset(result!!, result.textOffset, KtExpression::class.java)
             }
 
             result = KotlinEditorTextProvider.findExpressionInner(elementAt, true)
@@ -243,16 +243,16 @@ class KotlinCodeFragmentFactory: CodeFragmentFactory() {
             return containingFile
         }
 
-        private fun JetElement?.check(): Boolean = this != null && this.check { KotlinEditorTextProvider.isAcceptedAsCodeFragmentContext(it) } != null
+        private fun KtElement?.check(): Boolean = this != null && this.check { KotlinEditorTextProvider.isAcceptedAsCodeFragmentContext(it) } != null
 
-        private fun getInlinedLambdasInside(contextElement: JetElement): List<JetFunction> {
+        private fun getInlinedLambdasInside(contextElement: KtElement): List<KtFunction> {
             val start = contextElement.startOffset
             val end = contextElement.endOffset
 
             val bindingContext = contextElement.analyze(BodyResolveMode.PARTIAL)
-            return CodeInsightUtils.findElementsOfClassInRange(contextElement.getContainingJetFile(), start, end, javaClass<JetFunctionLiteral>(), javaClass<JetNamedFunction>())
-                    .filterIsInstance<JetFunction>()
-                    .filter { JetPsiUtil.getParentCallIfPresent(it as JetExpression) != null && InlineUtil.isInlinedArgument(it, bindingContext, false) }
+            return CodeInsightUtils.findElementsOfClassInRange(contextElement.getContainingJetFile(), start, end, javaClass<KtFunctionLiteral>(), javaClass<KtNamedFunction>())
+                    .filterIsInstance<KtFunction>()
+                    .filter { KtPsiUtil.getParentCallIfPresent(it as KtExpression) != null && InlineUtil.isInlinedArgument(it, bindingContext, false) }
         }
 
         //internal for tests
@@ -312,7 +312,7 @@ class KotlinCodeFragmentFactory: CodeFragmentFactory() {
         }
     }
 
-    private fun wrapContextIfNeeded(project: Project, originalContext: JetElement?): JetElement? {
+    private fun wrapContextIfNeeded(project: Project, originalContext: KtElement?): KtElement? {
         val session = XDebuggerManager.getInstance(project).currentSession as? XDebugSessionImpl
                                             ?: return originalContext
 
@@ -331,11 +331,11 @@ class KotlinCodeFragmentFactory: CodeFragmentFactory() {
             labels: Map<String, Value>,
             originalContext: PsiElement?,
             project: Project
-    ): JetElement? {
-        val codeFragment = JetPsiFactory(project).createBlockCodeFragment(newFragmentText, originalContext)
+    ): KtElement? {
+        val codeFragment = KtPsiFactory(project).createBlockCodeFragment(newFragmentText, originalContext)
 
-        codeFragment.accept(object : JetTreeVisitorVoid() {
-            override fun visitProperty(property: JetProperty) {
+        codeFragment.accept(object : KtTreeVisitorVoid() {
+            override fun visitProperty(property: KtProperty) {
                 val reference = labels.get(property.name)
                 if (reference != null) {
                     property.putUserData(LABEL_VARIABLE_VALUE_KEY, reference)
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluateExpressionCache.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluateExpressionCache.kt
index c5061852d1a..cdc6de316ee 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluateExpressionCache.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluateExpressionCache.kt
@@ -20,13 +20,13 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.util.CachedValuesManager
 import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.PsiModificationTracker
-import org.jetbrains.kotlin.psi.JetCodeFragment
+import org.jetbrains.kotlin.psi.KtCodeFragment
 import com.intellij.debugger.SourcePosition
 import com.intellij.debugger.engine.evaluation.EvaluationContextImpl
 import java.util.ArrayList
 import com.intellij.openapi.components.ServiceManager
 import com.intellij.util.containers.MultiMap
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.apache.log4j.Logger
@@ -47,10 +47,10 @@ class KotlinEvaluateExpressionCache(val project: Project) {
         fun getInstance(project: Project) = ServiceManager.getService(project, javaClass<KotlinEvaluateExpressionCache>())!!
 
         fun getOrCreateCompiledData(
-                codeFragment: JetCodeFragment,
+                codeFragment: KtCodeFragment,
                 sourcePosition: SourcePosition,
                 evaluationContext: EvaluationContextImpl,
-                create: (JetCodeFragment, SourcePosition) -> CompiledDataDescriptor
+                create: (KtCodeFragment, SourcePosition) -> CompiledDataDescriptor
         ): CompiledDataDescriptor {
             val evaluateExpressionCache = getInstance(codeFragment.getProject())
 
@@ -96,12 +96,12 @@ class KotlinEvaluateExpressionCache(val project: Project) {
     class ParametersDescriptor : Iterable<Parameter> {
         private val list = ArrayList<Parameter>()
 
-        fun add(name: String, jetType: JetType, value: Value? = null) {
+        fun add(name: String, jetType: KtType, value: Value? = null) {
             list.add(Parameter(name, jetType, value))
         }
 
         override fun iterator() = list.iterator()
     }
 
-    data class Parameter(val callText: String, val type: JetType, val value: Value? = null)
+    data class Parameter(val callText: String, val type: KtType, val value: Value? = null)
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt
index ca8e24562d6..ccb7ccc2800 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt
@@ -87,12 +87,12 @@ internal val THIS_NAME = "this"
 
 object KotlinEvaluationBuilder: EvaluatorBuilder {
     override fun build(codeFragment: PsiElement, position: SourcePosition?): ExpressionEvaluator {
-        if (codeFragment !is JetCodeFragment || position == null) {
+        if (codeFragment !is KtCodeFragment || position == null) {
             return EvaluatorBuilderImpl.getInstance()!!.build(codeFragment, position)
         }
 
         val file = position.file
-        if (file !is JetFile) {
+        if (file !is KtFile) {
             throw EvaluateExceptionUtil.createEvaluateException("Couldn't evaluate kotlin expression in non-kotlin context")
         }
 
@@ -107,7 +107,7 @@ object KotlinEvaluationBuilder: EvaluatorBuilder {
                     "It may happen when you've changed source file after starting a debug process.")
         }
 
-        if (codeFragment.context !is JetElement) {
+        if (codeFragment.context !is KtElement) {
             val attachments = arrayOf(attachmentByPsiFile(position.file),
                                       attachmentByPsiFile(codeFragment),
                                       Attachment("breakpoint.info", "line: ${position.line}"))
@@ -122,7 +122,7 @@ object KotlinEvaluationBuilder: EvaluatorBuilder {
 
 val logger = Logger.getInstance(javaClass<KotlinEvaluator>())
 
-class KotlinEvaluator(val codeFragment: JetCodeFragment,
+class KotlinEvaluator(val codeFragment: KtCodeFragment,
                       val sourcePosition: SourcePosition
 ) : Evaluator {
     override fun evaluate(context: EvaluationContextImpl): Any? {
@@ -176,7 +176,7 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
     }
 
     companion object {
-        private fun extractAndCompile(codeFragment: JetCodeFragment, sourcePosition: SourcePosition, context: EvaluationContextImpl): CompiledDataDescriptor {
+        private fun extractAndCompile(codeFragment: KtCodeFragment, sourcePosition: SourcePosition, context: EvaluationContextImpl): CompiledDataDescriptor {
             codeFragment.checkForErrors(false)
 
             val extractionResult = getFunctionForExtractedFragment(codeFragment, sourcePosition.file, sourcePosition.line)
@@ -184,7 +184,7 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
                 throw IllegalStateException("Code fragment cannot be extracted to function")
             }
             val parametersDescriptor = extractionResult.getParametersForDebugger(codeFragment)
-            val extractedFunction = extractionResult.declaration as JetNamedFunction
+            val extractedFunction = extractionResult.declaration as KtNamedFunction
 
             val classFileFactory = createClassFileFactory(codeFragment, extractedFunction, context, parametersDescriptor)
 
@@ -294,14 +294,14 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
             return jdiValue.asJdiValue(vm, jdiValue.asmType)
         }
 
-        private fun ExtractionResult.getParametersForDebugger(fragment: JetCodeFragment): ParametersDescriptor {
+        private fun ExtractionResult.getParametersForDebugger(fragment: KtCodeFragment): ParametersDescriptor {
             return runReadAction {
                 val valuesForLabels = HashMap<String, Value>()
 
                 val contextElementFile = fragment.context?.containingFile
-                if (contextElementFile is JetCodeFragment) {
-                    contextElementFile.accept(object: JetTreeVisitorVoid() {
-                        override fun visitProperty(property: JetProperty) {
+                if (contextElementFile is KtCodeFragment) {
+                    contextElementFile.accept(object: KtTreeVisitorVoid() {
+                        override fun visitProperty(property: KtProperty) {
                             val value = property.getUserData(KotlinCodeFragmentFactory.LABEL_VARIABLE_VALUE_KEY)
                             if (value != null) {
                                 valuesForLabels.put(property.name?.quoteIfNeeded()!!, value.asValue())
@@ -341,8 +341,8 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
         }
 
         private fun createClassFileFactory(
-                codeFragment: JetCodeFragment,
-                extractedFunction: JetNamedFunction,
+                codeFragment: KtCodeFragment,
+                extractedFunction: KtNamedFunction,
                 context: EvaluationContextImpl,
                 parameters: ParametersDescriptor
         ): ClassFileFactory {
@@ -352,10 +352,10 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
                 val (bindingContext, moduleDescriptor, files) = jetFile.checkForErrors(true)
 
                 val generateClassFilter = object : GenerationState.GenerateClassFilter() {
-                    override fun shouldGeneratePackagePart(file: JetFile) = file == jetFile
-                    override fun shouldAnnotateClass(classOrObject: JetClassOrObject) = true
-                    override fun shouldGenerateClass(classOrObject: JetClassOrObject) = classOrObject.getContainingJetFile() == jetFile
-                    override fun shouldGenerateScript(script: JetScript) = false
+                    override fun shouldGeneratePackagePart(file: KtFile) = file == jetFile
+                    override fun shouldAnnotateClass(classOrObject: KtClassOrObject) = true
+                    override fun shouldGenerateClass(classOrObject: KtClassOrObject) = classOrObject.getContainingJetFile() == jetFile
+                    override fun shouldGenerateScript(script: KtScript) = false
                 }
 
                 val state = GenerationState(
@@ -398,7 +398,7 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
             }
         }
 
-        private fun BindingTrace.recordAnonymousType(typeReference: JetTypeReference, localVariableName: String, visitor: FrameVisitor) {
+        private fun BindingTrace.recordAnonymousType(typeReference: KtTypeReference, localVariableName: String, visitor: FrameVisitor) {
             val paramAnonymousType = typeReference.debugTypeInfo
             if (paramAnonymousType != null) {
                 val declarationDescriptor = paramAnonymousType.constructor.declarationDescriptor
@@ -422,7 +422,7 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
             throw EvaluateExceptionUtil.createEvaluateException(e)
         }
 
-        private fun JetFile.checkForErrors(analyzeInlineFunctions: Boolean): ExtendedAnalysisResult {
+        private fun KtFile.checkForErrors(analyzeInlineFunctions: Boolean): ExtendedAnalysisResult {
             return runReadAction {
                 try {
                     AnalyzingUtils.checkForSyntacticErrors(this)
@@ -452,7 +452,7 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
             }
         }
 
-        private data class ExtendedAnalysisResult(val bindingContext: BindingContext, val moduleDescriptor: ModuleDescriptor, val files: List<JetFile>)
+        private data class ExtendedAnalysisResult(val bindingContext: BindingContext, val moduleDescriptor: ModuleDescriptor, val files: List<KtFile>)
     }
 }
 
@@ -464,10 +464,10 @@ package packageForDebugger
 !FUNCTION!
 """
 
-private fun createFileForDebugger(codeFragment: JetCodeFragment,
-                                  extractedFunction: JetNamedFunction
-): JetFile {
-    val containingContextFile = (codeFragment.context as? JetElement)?.getContainingJetFile()
+private fun createFileForDebugger(codeFragment: KtCodeFragment,
+                                  extractedFunction: KtNamedFunction
+): KtFile {
+    val containingContextFile = (codeFragment.context as? KtElement)?.getContainingJetFile()
     val importsFromContextFile = containingContextFile?.importList?.let { it.text + "\n" } ?: ""
     val packageFromContextFile = containingContextFile?.packageName?.let {
         if (it.isNotBlank()) "import $it.*\n" else null
@@ -477,7 +477,7 @@ private fun createFileForDebugger(codeFragment: JetCodeFragment,
             "!IMPORT_LIST!",
             packageFromContextFile
                     + importsFromContextFile
-                    + codeFragment.importsToString().split(JetCodeFragment.IMPORT_SEPARATOR).joinToString("\n")
+                    + codeFragment.importsToString().split(KtCodeFragment.IMPORT_SEPARATOR).joinToString("\n")
     )
 
     val extractedFunctionText = extractedFunction.text
@@ -488,7 +488,7 @@ private fun createFileForDebugger(codeFragment: JetCodeFragment,
     jetFile.suppressDiagnosticsInDebugMode = true
 
     val list = jetFile.declarations
-    val function = list.get(0) as JetNamedFunction
+    val function = list.get(0) as KtNamedFunction
 
     function.receiverTypeReference?.debugTypeInfo = extractedFunction.receiverTypeReference?.debugTypeInfo
 
@@ -501,7 +501,7 @@ private fun createFileForDebugger(codeFragment: JetCodeFragment,
     return jetFile
 }
 
-private fun PsiElement.createFlexibleTypesFile(): JetFile {
+private fun PsiElement.createFlexibleTypesFile(): KtFile {
     return createJetFile(
             "FLEXIBLE_TYPES.kt",
             """
@@ -511,12 +511,12 @@ private fun PsiElement.createFlexibleTypesFile(): JetFile {
     )
 }
 
-private fun PsiElement.createJetFile(fileName: String, fileText: String): JetFile {
-    // Not using JetPsiFactory because we need a virtual file attached to the JetFile
+private fun PsiElement.createJetFile(fileName: String, fileText: String): KtFile {
+    // Not using KtPsiFactory because we need a virtual file attached to the JetFile
     val virtualFile = LightVirtualFile(fileName, KotlinLanguage.INSTANCE, fileText)
     virtualFile.charset = CharsetToolkit.UTF8_CHARSET
     val jetFile = (PsiFileFactory.getInstance(project) as PsiFileFactoryImpl)
-            .trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false) as JetFile
+            .trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false) as KtFile
     jetFile.analysisContext = this
     return jetFile
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinRuntimeTypeEvaluator.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinRuntimeTypeEvaluator.kt
index e720b1b5ec0..a11aaa688f7 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinRuntimeTypeEvaluator.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinRuntimeTypeEvaluator.kt
@@ -34,20 +34,20 @@ import com.intellij.psi.CommonClassNames
 import com.sun.jdi.ClassType
 import com.sun.jdi.Value
 import org.jetbrains.eval4j.jdi.asValue
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.org.objectweb.asm.Type as AsmType
 
 public abstract class KotlinRuntimeTypeEvaluator(
         editor: Editor?,
-        expression: JetExpression,
+        expression: KtExpression,
         context: DebuggerContextImpl,
         indicator: ProgressIndicator
-) : EditorEvaluationCommand<JetType>(editor, expression, context, indicator) {
+) : EditorEvaluationCommand<KtType>(editor, expression, context, indicator) {
 
     override fun threadAction() {
-        var type: JetType? = null
+        var type: KtType? = null
         try {
             type = evaluate()
         }
@@ -60,13 +60,13 @@ public abstract class KotlinRuntimeTypeEvaluator(
         }
     }
 
-    protected abstract fun typeCalculationFinished(type: JetType?)
+    protected abstract fun typeCalculationFinished(type: KtType?)
 
-    override fun evaluate(evaluationContext: EvaluationContextImpl): JetType? {
+    override fun evaluate(evaluationContext: EvaluationContextImpl): KtType? {
         val project = evaluationContext.getProject()
 
         val evaluator = DebuggerInvocationUtil.commitAndRunReadAction<ExpressionEvaluator>(project, EvaluatingComputable {
-                val codeFragment = JetPsiFactory(myElement.getProject()).createExpressionCodeFragment(
+                val codeFragment = KtPsiFactory(myElement.getProject()).createExpressionCodeFragment(
                         myElement.getText(), myElement.getContainingFile().getContext())
                 KotlinEvaluationBuilder.build(codeFragment, ContextUtil.getSourcePosition(evaluationContext))
         })
@@ -80,7 +80,7 @@ public abstract class KotlinRuntimeTypeEvaluator(
     }
 
     companion object {
-        private fun getCastableRuntimeType(project: Project, value: Value): JetType? {
+        private fun getCastableRuntimeType(project: Project, value: Value): KtType? {
             val myValue = value.asValue()
             var psiClass = myValue.asmType.getClassDescriptor(project)
             if (psiClass != null) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/extractFunctionForDebuggerUtil.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/extractFunctionForDebuggerUtil.kt
index a7d74a1c6f1..6e499fbb9ba 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/extractFunctionForDebuggerUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/extractFunctionForDebuggerUtil.kt
@@ -36,12 +36,12 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.codeFragmentUtil.suppressDiagnosticsInDebugMode
 
 fun getFunctionForExtractedFragment(
-        codeFragment: JetCodeFragment,
+        codeFragment: KtCodeFragment,
         breakpointFile: PsiFile,
         breakpointLine: Int
 ): ExtractionResult? {
 
-    fun getErrorMessageForExtractFunctionResult(analysisResult: AnalysisResult, tmpFile: JetFile): String {
+    fun getErrorMessageForExtractFunctionResult(analysisResult: AnalysisResult, tmpFile: KtFile): String {
         if (KotlinInternalMode.enabled) {
             logger.error("Couldn't extract function for debugger:\n" +
                                  "FILE NAME: ${breakpointFile.getName()}\n" +
@@ -69,7 +69,7 @@ fun getFunctionForExtractedFragment(
     }
 
     fun generateFunction(): ExtractionResult? {
-        val originalFile = breakpointFile as JetFile
+        val originalFile = breakpointFile as KtFile
 
         val tmpFile = originalFile.createTempCopy { it }
         tmpFile.suppressDiagnosticsInDebugMode = true
@@ -109,11 +109,11 @@ fun getFunctionForExtractedFragment(
     return runReadAction { generateFunction() }
 }
 
-private fun addImportsToFile(newImportList: JetImportList?, tmpFile: JetFile) {
+private fun addImportsToFile(newImportList: KtImportList?, tmpFile: KtFile) {
     if (newImportList != null) {
         val tmpFileImportList = tmpFile.getImportList()
         val packageDirective = tmpFile.getPackageDirective()
-        val psiFactory = JetPsiFactory(tmpFile)
+        val psiFactory = KtPsiFactory(tmpFile)
         if (tmpFileImportList == null) {
             tmpFile.addAfter(psiFactory.createNewLine(), packageDirective)
             tmpFile.addAfter(newImportList, tmpFile.getPackageDirective())
@@ -135,7 +135,7 @@ private fun addImportsToFile(newImportList: JetImportList?, tmpFile: JetFile) {
     }
 }
 
-private fun JetFile.getElementInCopy(e: PsiElement): PsiElement? {
+private fun KtFile.getElementInCopy(e: PsiElement): PsiElement? {
     val offset = e.getTextRange()?.getStartOffset()
     if (offset == null) {
         return null
@@ -147,7 +147,7 @@ private fun JetFile.getElementInCopy(e: PsiElement): PsiElement? {
     return elementAt
 }
 
-private fun getExpressionToAddDebugExpressionBefore(tmpFile: JetFile, contextElement: PsiElement?, line: Int): PsiElement? {
+private fun getExpressionToAddDebugExpressionBefore(tmpFile: KtFile, contextElement: PsiElement?, line: Int): PsiElement? {
     if (contextElement == null) {
         val lineStart = CodeInsightUtils.getStartLineOffset(tmpFile, line)
         if (lineStart == null) return null
@@ -159,11 +159,11 @@ private fun getExpressionToAddDebugExpressionBefore(tmpFile: JetFile, contextEle
     }
 
     val containingFile = contextElement.getContainingFile()
-    if (containingFile is JetCodeFragment) {
+    if (containingFile is KtCodeFragment) {
         return getExpressionToAddDebugExpressionBefore(tmpFile, containingFile.getContext(), line)
     }
 
-    fun shouldStop(el: PsiElement?, p: PsiElement?) = p is JetBlockExpression || el is JetDeclaration || el is JetFile
+    fun shouldStop(el: PsiElement?, p: PsiElement?) = p is KtBlockExpression || el is KtDeclaration || el is KtFile
 
     var elementAt = tmpFile.getElementInCopy(contextElement)
 
@@ -186,24 +186,24 @@ private fun getExpressionToAddDebugExpressionBefore(tmpFile: JetFile, contextEle
     return parent
 }
 
-private fun addDebugExpressionBeforeContextElement(codeFragment: JetCodeFragment, contextElement: PsiElement): List<JetExpression> {
-    val psiFactory = JetPsiFactory(codeFragment)
+private fun addDebugExpressionBeforeContextElement(codeFragment: KtCodeFragment, contextElement: PsiElement): List<KtExpression> {
+    val psiFactory = KtPsiFactory(codeFragment)
 
-    fun insertNewInitializer(classBody: JetClassBody): PsiElement? {
+    fun insertNewInitializer(classBody: KtClassBody): PsiElement? {
         val initializer = psiFactory.createAnonymousInitializer()
-        val newInitializer = (classBody.addAfter(initializer, classBody.getFirstChild()) as JetClassInitializer)
-        val block = newInitializer.getBody() as JetBlockExpression?
+        val newInitializer = (classBody.addAfter(initializer, classBody.getFirstChild()) as KtClassInitializer)
+        val block = newInitializer.getBody() as KtBlockExpression?
         return block?.getLastChild()
     }
 
     val elementBefore = when {
-        contextElement is JetFile -> {
+        contextElement is KtFile -> {
             val fakeFunction = psiFactory.createFunction("fun _debug_fun_() {}")
             contextElement.add(psiFactory.createNewLine())
-            val newFakeFun = contextElement.add(fakeFunction) as JetNamedFunction
+            val newFakeFun = contextElement.add(fakeFunction) as KtNamedFunction
             newFakeFun.getBodyExpression()!!.getLastChild()
         }
-        contextElement is JetProperty && !contextElement.isLocal() -> {
+        contextElement is KtProperty && !contextElement.isLocal() -> {
             val delegateExpressionOrInitializer = contextElement.getDelegateExpressionOrInitializer()
             if (delegateExpressionOrInitializer != null) {
                 wrapInRunFun(delegateExpressionOrInitializer)
@@ -214,40 +214,40 @@ private fun addDebugExpressionBeforeContextElement(codeFragment: JetCodeFragment
                     wrapInRunFun(getter.getBodyExpression()!!)
                 }
                 else {
-                    (getter.getBodyExpression() as JetBlockExpression).getStatements().first()
+                    (getter.getBodyExpression() as KtBlockExpression).getStatements().first()
                 }
             }
         }
-        contextElement is JetPrimaryConstructor -> {
+        contextElement is KtPrimaryConstructor -> {
             val classOrObject = contextElement.getContainingClassOrObject()
             insertNewInitializer(classOrObject.getOrCreateBody())
         }
-        contextElement is JetClassOrObject -> {
+        contextElement is KtClassOrObject -> {
             insertNewInitializer(contextElement.getBody()!!)
         }
-        contextElement is JetFunctionLiteral -> {
+        contextElement is KtFunctionLiteral -> {
             val block = contextElement.getBodyExpression()!!
             block.getStatements().firstOrNull() ?: block.getLastChild()
         }
-        contextElement is JetDeclarationWithBody && !contextElement.hasBody()-> {
+        contextElement is KtDeclarationWithBody && !contextElement.hasBody()-> {
             val block = psiFactory.createBlock("")
-            val newBlock = contextElement.add(block) as JetBlockExpression
+            val newBlock = contextElement.add(block) as KtBlockExpression
             newBlock.getRBrace()
         }
-        contextElement is JetDeclarationWithBody && !contextElement.hasBlockBody()-> {
+        contextElement is KtDeclarationWithBody && !contextElement.hasBlockBody()-> {
             wrapInRunFun(contextElement.getBodyExpression()!!)
         }
-        contextElement is JetDeclarationWithBody && contextElement.hasBlockBody()-> {
-            val block = contextElement.getBodyExpression() as JetBlockExpression
+        contextElement is KtDeclarationWithBody && contextElement.hasBlockBody()-> {
+            val block = contextElement.getBodyExpression() as KtBlockExpression
             val last = block.getStatements().lastOrNull()
-            if (last is JetReturnExpression)
+            if (last is KtReturnExpression)
                 last
             else
                 block.getRBrace()
         }
-        contextElement is JetWhenEntry -> {
+        contextElement is KtWhenEntry -> {
             val entryExpression = contextElement.getExpression()
-            if (entryExpression is JetBlockExpression) {
+            if (entryExpression is KtBlockExpression) {
                 entryExpression.getStatements().firstOrNull() ?: entryExpression.getLastChild()
             }
             else {
@@ -264,33 +264,33 @@ private fun addDebugExpressionBeforeContextElement(codeFragment: JetCodeFragment
 
     parent.addBefore(psiFactory.createNewLine(), elementBefore)
 
-    fun insertExpression(expr: JetElement?): List<JetExpression> {
+    fun insertExpression(expr: KtElement?): List<KtExpression> {
         when (expr) {
-            is JetBlockExpression -> return expr.getStatements().flatMap { insertExpression(it) }
-            is JetExpression -> {
+            is KtBlockExpression -> return expr.getStatements().flatMap { insertExpression(it) }
+            is KtExpression -> {
                 val newDebugExpression = parent.addBefore(expr, elementBefore)
                 if (newDebugExpression == null) {
                     logger.error("Couldn't insert debug expression ${expr.getText()} to context file before ${elementBefore.getText()}")
                     return emptyList()
                 }
                 parent.addBefore(psiFactory.createNewLine(), elementBefore)
-                return listOf(newDebugExpression as JetExpression)
+                return listOf(newDebugExpression as KtExpression)
             }
         }
         return emptyList()
     }
 
     val containingFile = codeFragment.getContext()?.getContainingFile()
-    if (containingFile is JetCodeFragment) {
-        insertExpression(containingFile.getContentElement() as? JetExpression)
+    if (containingFile is KtCodeFragment) {
+        insertExpression(containingFile.getContentElement() as? KtExpression)
     }
 
     val debugExpression = codeFragment.getContentElement() ?: return emptyList()
     return insertExpression(debugExpression)
 }
 
-private fun replaceByRunFunction(expression: JetExpression): JetCallExpression {
-    val callExpression = JetPsiFactory(expression).createExpression("run { \n${expression.getText()} \n}") as JetCallExpression
+private fun replaceByRunFunction(expression: KtExpression): KtCallExpression {
+    val callExpression = KtPsiFactory(expression).createExpression("run { \n${expression.getText()} \n}") as KtCallExpression
     val replaced = expression.replaced(callExpression)
     val typeArguments = InsertExplicitTypeArgumentsIntention.createTypeArguments(replaced, replaced.analyze())
     if (typeArguments?.getArguments()?.isNotEmpty() ?: false) {
@@ -300,7 +300,7 @@ private fun replaceByRunFunction(expression: JetExpression): JetCallExpression {
     return replaced
 }
 
-private fun wrapInRunFun(expression: JetExpression): PsiElement? {
+private fun wrapInRunFun(expression: KtExpression): PsiElement? {
     val replacedBody = replaceByRunFunction(expression)
 
     // Increment modification tracker to clear ResolveCache after changes in function body
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/DebuggerSteppingHelper.java b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/DebuggerSteppingHelper.java
index 67cd873b3d6..f79f2d931e7 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/DebuggerSteppingHelper.java
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/DebuggerSteppingHelper.java
@@ -25,10 +25,10 @@ import com.intellij.openapi.util.Computable;
 import com.intellij.psi.PsiElement;
 import com.intellij.xdebugger.impl.XSourcePositionImpl;
 import kotlin.IntRange;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetFunction;
-import org.jetbrains.kotlin.psi.JetFunctionLiteral;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtFunction;
+import org.jetbrains.kotlin.psi.KtFunctionLiteral;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
 
 import java.util.List;
 
@@ -37,9 +37,9 @@ public class DebuggerSteppingHelper {
     public static DebugProcessImpl.ResumeCommand createStepOverCommand(
             final SuspendContextImpl suspendContext,
             final boolean ignoreBreakpoints,
-            final JetFile file,
+            final KtFile file,
             final IntRange linesRange,
-            final List<JetFunction> inlineArguments,
+            final List<KtFunction> inlineArguments,
             final List<PsiElement> additionalElementsToSkip
     ) {
         final DebugProcessImpl debugProcess = suspendContext.getDebugProcess();
@@ -83,8 +83,8 @@ public class DebuggerSteppingHelper {
     public static DebugProcessImpl.ResumeCommand createStepOutCommand(
             final SuspendContextImpl suspendContext,
             final boolean ignoreBreakpoints,
-            final List<JetNamedFunction> inlineFunctions,
-            final JetFunctionLiteral inlineArgument
+            final List<KtNamedFunction> inlineFunctions,
+            final KtFunctionLiteral inlineArgument
     ) {
         final DebugProcessImpl debugProcess = suspendContext.getDebugProcess();
         return debugProcess.new ResumeCommand(suspendContext) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinBasicStepMethodFilter.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinBasicStepMethodFilter.kt
index 0e5eae33e97..5eaedff0185 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinBasicStepMethodFilter.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinBasicStepMethodFilter.kt
@@ -25,21 +25,21 @@ import com.sun.jdi.Method
 import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.load.java.JvmAbi
-import org.jetbrains.kotlin.psi.JetConstructor
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetPropertyAccessor
+import org.jetbrains.kotlin.psi.KtConstructor
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtPropertyAccessor
 
 public class KotlinBasicStepMethodFilter(
-        val resolvedFunction: JetElement,
+        val resolvedFunction: KtElement,
         val myCallingExpressionLines: Range<Int>
 ) : NamedMethodFilter {
     private val myTargetMethodName: String
 
     init {
         myTargetMethodName = when (resolvedFunction) {
-            is JetConstructor<*> -> "<init>"
-            is JetPropertyAccessor -> JvmAbi.getterName((resolvedFunction.getParent() as JetProperty).getName()!!)
+            is KtConstructor<*> -> "<init>"
+            is KtPropertyAccessor -> JvmAbi.getterName((resolvedFunction.getParent() as KtProperty).getName()!!)
             else -> resolvedFunction.getName()!!
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaMethodFilter.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaMethodFilter.kt
index 16e3de6a848..417423ae7b1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaMethodFilter.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaMethodFilter.kt
@@ -25,12 +25,12 @@ import com.intellij.psi.PsiElementFactory
 import com.intellij.util.Range
 import com.sun.jdi.Location
 import org.jetbrains.kotlin.idea.util.application.runReadAction
-import org.jetbrains.kotlin.psi.JetBlockExpression
-import org.jetbrains.kotlin.psi.JetFunctionLiteralExpression
+import org.jetbrains.kotlin.psi.KtBlockExpression
+import org.jetbrains.kotlin.psi.KtFunctionLiteralExpression
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
 public class KotlinLambdaMethodFilter(
-        lambda: JetFunctionLiteralExpression,
+        lambda: KtFunctionLiteralExpression,
         private val myCallingExpressionLines: Range<Int>
 ): BreakpointStepMethodFilter {
     private val myFirstStatementPosition: SourcePosition?
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaSmartStepIntoTarget.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaSmartStepIntoTarget.kt
index bcdfb00df1c..c8f22015c67 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaSmartStepIntoTarget.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaSmartStepIntoTarget.kt
@@ -22,21 +22,21 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiMethod
 import com.intellij.util.Range
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.idea.JetIcons
+import org.jetbrains.kotlin.idea.KtIcons
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetFunctionLiteralExpression
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFunctionLiteralExpression
 import org.jetbrains.kotlin.util.OperatorNameConventions
 import javax.swing.Icon
 
 public class KotlinLambdaSmartStepTarget(
         label: String,
-        highlightElement: JetFunctionLiteralExpression,
+        highlightElement: KtFunctionLiteralExpression,
         lines: Range<Int>
 ): SmartStepTarget(label, highlightElement, true, lines) {
-    override fun getIcon() = JetIcons.LAMBDA
+    override fun getIcon() = KtIcons.LAMBDA
 
-    fun getLambda() = getHighlightElement() as JetFunctionLiteralExpression
+    fun getLambda() = getHighlightElement() as KtFunctionLiteralExpression
 
     companion object {
         fun calcLabel(descriptor: DeclarationDescriptor, paramName: Name): String {
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinMethodSmartStepIntoTarget.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinMethodSmartStepIntoTarget.kt
index cc706e37181..686c24af85a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinMethodSmartStepIntoTarget.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinMethodSmartStepIntoTarget.kt
@@ -4,23 +4,23 @@ import com.intellij.debugger.actions.SmartStepTarget
 import com.intellij.psi.PsiElement
 import com.intellij.util.Range
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.idea.JetIcons
+import org.jetbrains.kotlin.idea.KtIcons
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.renderer.ParameterNameRenderingPolicy
 import javax.swing.Icon
 
 public class KotlinMethodSmartStepTarget(
-        val resolvedElement: JetElement,
+        val resolvedElement: KtElement,
         label: String,
         highlightElement: PsiElement,
         lines: Range<Int>
 ): SmartStepTarget(label, highlightElement, false, lines) {
     override fun getIcon(): Icon? {
         return when {
-            resolvedElement is JetNamedFunction && resolvedElement.getReceiverTypeReference() != null -> JetIcons.EXTENSION_FUNCTION
-            else -> JetIcons.FUNCTION
+            resolvedElement is KtNamedFunction && resolvedElement.getReceiverTypeReference() != null -> KtIcons.EXTENSION_FUNCTION
+            else -> KtIcons.FUNCTION
         }
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSmartStepIntoHandler.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSmartStepIntoHandler.kt
index d22b8334b3f..ed4a9cb566e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSmartStepIntoHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSmartStepIntoHandler.kt
@@ -40,7 +40,7 @@ import org.jetbrains.kotlin.resolve.inline.InlineUtil
 
 public class KotlinSmartStepIntoHandler : JvmSmartStepIntoHandler() {
 
-    override fun isAvailable(position: SourcePosition?) = position?.getFile() is JetFile
+    override fun isAvailable(position: SourcePosition?) = position?.getFile() is KtFile
 
     override fun findSmartStepTargets(position: SourcePosition): List<SmartStepTarget> {
         if (position.getLine() < 0) return emptyList()
@@ -52,7 +52,7 @@ public class KotlinSmartStepIntoHandler : JvmSmartStepIntoHandler() {
         val elementAtOffset = file.findElementAt(lineStart) ?: return emptyList()
 
         val element = CodeInsightUtils.getTopmostElementAtOffset(elementAtOffset, lineStart)
-        if (element !is JetElement) return emptyList()
+        if (element !is KtElement) return emptyList()
 
         val elementTextRange = element.getTextRange() ?: return emptyList()
 
@@ -63,9 +63,9 @@ public class KotlinSmartStepIntoHandler : JvmSmartStepIntoHandler() {
         val result = OrderedSet<SmartStepTarget>()
 
         // TODO support class initializers, local functions, delegated properties with specified type, setter for properties
-        element.accept(object: JetTreeVisitorVoid() {
+        element.accept(object: KtTreeVisitorVoid() {
 
-            override fun visitFunctionLiteralExpression(expression: JetFunctionLiteralExpression) {
+            override fun visitFunctionLiteralExpression(expression: KtFunctionLiteralExpression) {
                 val context = expression.analyze()
                 val resolvedCall = expression.getParentCall(context).getResolvedCall(context)
                 if (resolvedCall != null && !InlineUtil.isInline(resolvedCall.getResultingDescriptor())) {
@@ -80,46 +80,46 @@ public class KotlinSmartStepIntoHandler : JvmSmartStepIntoHandler() {
                 }
             }
 
-            override fun visitObjectLiteralExpression(expression: JetObjectLiteralExpression) {
+            override fun visitObjectLiteralExpression(expression: KtObjectLiteralExpression) {
                 // skip calls in object declarations
             }
 
-            override fun visitIfExpression(expression: JetIfExpression) {
+            override fun visitIfExpression(expression: KtIfExpression) {
                 expression.getCondition()?.accept(this)
             }
 
-            override fun visitWhileExpression(expression: JetWhileExpression) {
+            override fun visitWhileExpression(expression: KtWhileExpression) {
                 expression.getCondition()?.accept(this)
             }
 
-            override fun visitDoWhileExpression(expression: JetDoWhileExpression) {
+            override fun visitDoWhileExpression(expression: KtDoWhileExpression) {
                 expression.getCondition()?.accept(this)
             }
 
-            override fun visitForExpression(expression: JetForExpression) {
+            override fun visitForExpression(expression: KtForExpression) {
                 expression.getLoopRange()?.accept(this)
             }
 
-            override fun visitWhenExpression(expression: JetWhenExpression) {
+            override fun visitWhenExpression(expression: KtWhenExpression) {
                 expression.getSubjectExpression()?.accept(this)
             }
 
-            override fun visitArrayAccessExpression(expression: JetArrayAccessExpression) {
+            override fun visitArrayAccessExpression(expression: KtArrayAccessExpression) {
                 recordFunction(expression)
                 super.visitArrayAccessExpression(expression)
             }
 
-            override fun visitUnaryExpression(expression: JetUnaryExpression) {
+            override fun visitUnaryExpression(expression: KtUnaryExpression) {
                 recordFunction(expression.getOperationReference())
                 super.visitUnaryExpression(expression)
             }
 
-            override fun visitBinaryExpression(expression: JetBinaryExpression) {
+            override fun visitBinaryExpression(expression: KtBinaryExpression) {
                 recordFunction(expression.getOperationReference())
                 super.visitBinaryExpression(expression)
             }
 
-            override fun visitCallExpression(expression: JetCallExpression) {
+            override fun visitCallExpression(expression: KtCallExpression) {
                 val calleeExpression = expression.getCalleeExpression()
                 if (calleeExpression != null) {
                     recordFunction(calleeExpression)
@@ -127,7 +127,7 @@ public class KotlinSmartStepIntoHandler : JvmSmartStepIntoHandler() {
                 super.visitCallExpression(expression)
             }
 
-            override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+            override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
                 val resolvedCall = expression.getResolvedCall(bindingContext)
                 if (resolvedCall != null) {
                     val propertyDescriptor = resolvedCall.getResultingDescriptor()
@@ -137,7 +137,7 @@ public class KotlinSmartStepIntoHandler : JvmSmartStepIntoHandler() {
                             val delegatedResolvedCall = bindingContext[BindingContext.DELEGATED_PROPERTY_RESOLVED_CALL, getterDescriptor]
                             if (delegatedResolvedCall == null) {
                                 val getter = DescriptorToSourceUtilsIde.getAnyDeclaration(file.getProject(), getterDescriptor)
-                                if (getter is JetPropertyAccessor && (getter.getBodyExpression() != null || getter.getEqualsToken() != null)) {
+                                if (getter is KtPropertyAccessor && (getter.getBodyExpression() != null || getter.getEqualsToken() != null)) {
                                     val label = KotlinMethodSmartStepTarget.calcLabel(getterDescriptor)
                                     result.add(KotlinMethodSmartStepTarget(getter, label, expression, lines))
                                 }
@@ -146,9 +146,9 @@ public class KotlinSmartStepIntoHandler : JvmSmartStepIntoHandler() {
                                 val delegatedPropertyGetterDescriptor = delegatedResolvedCall.getResultingDescriptor()
                                 if (delegatedPropertyGetterDescriptor is CallableMemberDescriptor) {
                                     val function = DescriptorToSourceUtilsIde.getAnyDeclaration(file.getProject(), delegatedPropertyGetterDescriptor)
-                                    if (function is JetNamedFunction || function is JetSecondaryConstructor) {
+                                    if (function is KtNamedFunction || function is KtSecondaryConstructor) {
                                         val label = "${propertyDescriptor.getName()}." + KotlinMethodSmartStepTarget.calcLabel(delegatedPropertyGetterDescriptor)
-                                        result.add(KotlinMethodSmartStepTarget(function as JetFunction, label, expression, lines))
+                                        result.add(KotlinMethodSmartStepTarget(function as KtFunction, label, expression, lines))
                                     }
                                 }
                             }
@@ -158,15 +158,15 @@ public class KotlinSmartStepIntoHandler : JvmSmartStepIntoHandler() {
                 super.visitSimpleNameExpression(expression)
             }
 
-            private fun recordFunction(expression: JetExpression) {
+            private fun recordFunction(expression: KtExpression) {
                 val resolvedCall = expression.getResolvedCall(bindingContext) ?: return
 
                 val descriptor = resolvedCall.getResultingDescriptor()
                 if (descriptor is CallableMemberDescriptor && !isIntrinsic(descriptor)) {
                     val function = DescriptorToSourceUtilsIde.getAnyDeclaration(file.getProject(), descriptor)
-                    if (function is JetNamedFunction || function is JetSecondaryConstructor) {
+                    if (function is KtNamedFunction || function is KtSecondaryConstructor) {
                         val label = KotlinMethodSmartStepTarget.calcLabel(descriptor)
-                        result.add(KotlinMethodSmartStepTarget(function as JetFunction, label, expression, lines))
+                        result.add(KotlinMethodSmartStepTarget(function as KtFunction, label, expression, lines))
                     }
                     else if (function is PsiMethod) {
                         result.add(MethodSmartStepTarget(function, null, expression, false, lines))
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSteppingCommandProvider.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSteppingCommandProvider.kt
index 0ae1e8140c7..64c20e5089a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSteppingCommandProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSteppingCommandProvider.kt
@@ -65,10 +65,10 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() {
     }
 
     fun getStepOverCommand(suspendContext: SuspendContextImpl, ignoreBreakpoints: Boolean, sourcePosition: SourcePosition): DebugProcessImpl.ResumeCommand? {
-        val file = sourcePosition.file as? JetFile ?: return null
+        val file = sourcePosition.file as? KtFile ?: return null
         if (sourcePosition.line < 0) return null
 
-        val containingFunction = sourcePosition.elementAt.getParentOfType<JetNamedFunction>(false) ?: return null
+        val containingFunction = sourcePosition.elementAt.getParentOfType<KtNamedFunction>(false) ?: return null
 
         val startLineNumber = containingFunction.getLineNumber(true)
         val endLineNumber = containingFunction.getLineNumber(false)
@@ -92,25 +92,25 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() {
 
     private fun PsiElement.getAdditionalElementsToSkip(): List<PsiElement> {
         val result = arrayListOf<PsiElement>()
-        val ifParent = getParentOfType<JetIfExpression>(false)
+        val ifParent = getParentOfType<KtIfExpression>(false)
         if (ifParent != null) {
             if (ifParent.then.contains(this)) {
                 ifParent.elseKeyword?.let { result.add(it) }
                 ifParent.`else`?.let { result.add(it) }
             }
         }
-        val tryParent = getParentOfType<JetTryExpression>(false)
+        val tryParent = getParentOfType<KtTryExpression>(false)
         if (tryParent != null) {
-            val catchClause = getParentOfType<JetCatchClause>(false)
+            val catchClause = getParentOfType<KtCatchClause>(false)
             if (catchClause != null) {
                 result.addAll(tryParent.catchClauses.filter { it != catchClause })
             }
         }
 
-        val whenEntry = getParentOfType<JetWhenEntry>(false)
+        val whenEntry = getParentOfType<KtWhenEntry>(false)
         if (whenEntry != null) {
             if (whenEntry.expression.contains(this)) {
-                val whenParent = whenEntry.getParentOfType<JetWhenExpression>(false)
+                val whenParent = whenEntry.getParentOfType<KtWhenExpression>(false)
                 if (whenParent != null) {
                     result.addAll(whenParent.entries.filter { it != whenEntry })
                 }
@@ -121,7 +121,7 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() {
     }
 
     private fun PsiElement.shouldNotUseStepOver(elementAt: PsiElement): Boolean {
-        val ifParent = getParentOfType<JetIfExpression>(false)
+        val ifParent = getParentOfType<KtIfExpression>(false)
         if (ifParent != null) {
             // if (inlineFunCall()) {...}
             if (ifParent.condition.contains(this)) {
@@ -132,7 +132,7 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() {
             <caret>if (...) inlineFunCall()
                        else inlineFunCall()
              */
-            val ifParentElementAt = elementAt.getParentOfType<JetIfExpression>(false)
+            val ifParentElementAt = elementAt.getParentOfType<KtIfExpression>(false)
             if (ifParentElementAt == null) {
                 if (ifParent.then.contains(this)) {
                     return true
@@ -143,7 +143,7 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() {
             }
         }
 
-        val tryParent = getParentOfType<JetTryExpression>(false)
+        val tryParent = getParentOfType<KtTryExpression>(false)
         if (tryParent != null) {
             /* try { inlineFunCall() }
                catch()...
@@ -153,7 +153,7 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() {
             }
         }
 
-        val whenEntry = getParentOfType<JetWhenEntry>(false)
+        val whenEntry = getParentOfType<KtWhenEntry>(false)
         if (whenEntry != null) {
             // <caret>inlineFunCall -> ...
             if (whenEntry.conditions.any { it.contains(this) } ) {
@@ -162,7 +162,7 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() {
 
             // <caret>1 == 2 -> inlineFunCall()
             if (whenEntry.expression.contains(this)) {
-                val parentEntryElementAt = elementAt.getParentOfType<JetWhenEntry>(false) ?: return true
+                val parentEntryElementAt = elementAt.getParentOfType<KtWhenEntry>(false) ?: return true
                 return parentEntryElementAt == whenEntry &&
                         whenEntry.conditions.any { it.contains(elementAt) }
             }
@@ -188,7 +188,7 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() {
     }
 
     private fun getStepOutCommand(suspendContext: SuspendContextImpl, sourcePosition: SourcePosition): DebugProcessImpl.ResumeCommand? {
-        val file = sourcePosition.file as? JetFile ?: return null
+        val file = sourcePosition.file as? KtFile ?: return null
         if (sourcePosition.line < 0) return null
 
         val lineStartOffset = file.getLineStartOffset(sourcePosition.line) ?: return null
@@ -201,9 +201,9 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() {
         return DebuggerSteppingHelper.createStepOutCommand(suspendContext, true, inlineFunctions, inlinedArgument)
     }
 
-    private fun getInlineFunctionsIfAny(file: JetFile, offset: Int): List<JetNamedFunction> {
+    private fun getInlineFunctionsIfAny(file: KtFile, offset: Int): List<KtNamedFunction> {
         val elementAt = file.findElementAt(offset) ?: return emptyList()
-        val containingFunction = elementAt.getParentOfType<JetNamedFunction>(false) ?: return emptyList()
+        val containingFunction = elementAt.getParentOfType<KtNamedFunction>(false) ?: return emptyList()
 
         val descriptor = containingFunction.resolveToDescriptor()
         if (!InlineUtil.isInline(descriptor)) return emptyList()
@@ -213,22 +213,22 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() {
                 containingFunction.analyzeFully(),
                 containingFunction,
                 false
-        ).filterIsInstance<JetNamedFunction>()
+        ).filterIsInstance<KtNamedFunction>()
 
         return inlineFunctionsCalls
     }
 
-    private fun getInlineArgumentsIfAny(inlineFunctionCalls: List<JetCallExpression>): List<JetFunction> {
+    private fun getInlineArgumentsIfAny(inlineFunctionCalls: List<KtCallExpression>): List<KtFunction> {
         return inlineFunctionCalls.flatMap {
             it.valueArguments
                     .map { it.getArgumentExpression()  }
-                    .filterIsInstance<JetFunctionLiteralExpression>()
+                    .filterIsInstance<KtFunctionLiteralExpression>()
                     .map { it.functionLiteral }
         }
     }
 
-    private fun getInlineFunctionCallsIfAny(sourcePosition: SourcePosition): List<JetCallExpression> {
-        val file = sourcePosition.file as? JetFile ?: return emptyList()
+    private fun getInlineFunctionCallsIfAny(sourcePosition: SourcePosition): List<KtCallExpression> {
+        val file = sourcePosition.file as? KtFile ?: return emptyList()
         val lineNumber = sourcePosition.line
         var elementAt = sourcePosition.elementAt
 
@@ -236,7 +236,7 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() {
         var endOffset = file.getLineEndOffset(lineNumber) ?: elementAt.endOffset
 
         var topMostElement: PsiElement? = null
-        while (topMostElement !is JetElement && startOffset < endOffset) {
+        while (topMostElement !is KtElement && startOffset < endOffset) {
             elementAt = file.findElementAt(startOffset)
             if (elementAt != null) {
                 topMostElement = CodeInsightUtils.getTopmostElementAtOffset(elementAt, startOffset)
@@ -244,21 +244,21 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() {
             startOffset++
         }
 
-        if (topMostElement !is JetElement) return emptyList()
+        if (topMostElement !is KtElement) return emptyList()
 
         val start = topMostElement.startOffset
         val end = topMostElement.endOffset
 
-        fun isInlineCall(expr: JetExpression): Boolean {
+        fun isInlineCall(expr: KtExpression): Boolean {
             val context = expr.analyze(BodyResolveMode.PARTIAL)
             val resolvedCall = expr.getResolvedCall(context) ?: return false
             return InlineUtil.isInline(resolvedCall.resultingDescriptor)
         }
 
         val allInlineFunctionCalls = CodeInsightUtils.
-                findElementsOfClassInRange(file, start, end, JetExpression::class.java)
-                .map { JetPsiUtil.getParentCallIfPresent(it as JetExpression) }
-                .filterIsInstance<JetCallExpression>()
+                findElementsOfClassInRange(file, start, end, KtExpression::class.java)
+                .map { KtPsiUtil.getParentCallIfPresent(it as KtExpression) }
+                .filterIsInstance<KtCallExpression>()
                 .filter { isInlineCall(it) }
                 .toSet()
 
@@ -276,9 +276,9 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() {
 
 fun getStepOutPosition(
         location: Location,
-        file: JetFile,
+        file: KtFile,
         range: Range<Int>,
-        inlinedArguments: List<JetElement>,
+        inlinedArguments: List<KtElement>,
         elementsToSkip: List<PsiElement>
 ): XSourcePositionImpl? {
     val computedReferenceType = location.declaringType() ?: return null
@@ -306,8 +306,8 @@ fun getStepOutPosition(
 fun getStepOverPosition(
         location: Location,
         suspendContext: SuspendContextImpl,
-        inlineFunctions: List<JetNamedFunction>,
-        inlinedArgument: JetFunctionLiteral?
+        inlineFunctions: List<KtNamedFunction>,
+        inlinedArgument: KtFunctionLiteral?
 ): XSourcePositionImpl? {
     val computedReferenceType = location.declaringType() ?: return null
 
@@ -327,7 +327,7 @@ fun getStepOverPosition(
 
 private fun SuspendContextImpl.getXPositionForStepOutFromInlineFunction(
         locations: List<Location>,
-        inlineFunctionsToSkip: List<JetNamedFunction>
+        inlineFunctionsToSkip: List<KtNamedFunction>
 ): XSourcePositionImpl? {
     return getNextPositionWithFilter(locations) {
         file, offset ->
@@ -342,7 +342,7 @@ private fun SuspendContextImpl.getXPositionForStepOutFromInlineFunction(
 
 private fun SuspendContextImpl.getXPositionForStepOutFromInlinedArgument(
         locations: List<Location>,
-        inlinedArgumentToSkip: JetFunctionLiteral
+        inlinedArgumentToSkip: KtFunctionLiteral
 ): XSourcePositionImpl? {
     return getNextPositionWithFilter(locations) {
         file, offset ->
@@ -352,11 +352,11 @@ private fun SuspendContextImpl.getXPositionForStepOutFromInlinedArgument(
 
 private fun SuspendContextImpl.getNextPositionWithFilter(
         locations: List<Location>,
-        skip: (JetFile, Int) -> Boolean
+        skip: (KtFile, Int) -> Boolean
 ): XSourcePositionImpl? {
     for (location in locations) {
         val file = try {
-            this.debugProcess.positionManager.getSourcePosition(location)?.file as? JetFile
+            this.debugProcess.positionManager.getSourcePosition(location)?.file as? KtFile
         }
         catch(e: NoDataException) {
             null
@@ -373,9 +373,9 @@ private fun SuspendContextImpl.getNextPositionWithFilter(
     return null
 }
 
-private fun getInlineArgumentIfAny(file: JetFile, offset: Int): JetFunctionLiteral? {
+private fun getInlineArgumentIfAny(file: KtFile, offset: Int): KtFunctionLiteral? {
     val elementAt = file.findElementAt(offset) ?: return null
-    val functionLiteralExpression = elementAt.getParentOfType<JetFunctionLiteralExpression>(false) ?: return null
+    val functionLiteralExpression = elementAt.getParentOfType<KtFunctionLiteralExpression>(false) ?: return null
 
     val context = functionLiteralExpression.analyze(BodyResolveMode.PARTIAL)
     if (!InlineUtil.isInlinedArgument(functionLiteralExpression.functionLiteral, context, false)) return null
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/JetLtGtTypingUtils.java b/idea/src/org/jetbrains/kotlin/idea/editor/JetLtGtTypingUtils.java
index 49140ccb0eb..8d725434357 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/JetLtGtTypingUtils.java
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/JetLtGtTypingUtils.java
@@ -22,24 +22,24 @@ import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.ex.EditorEx;
 import com.intellij.openapi.editor.highlighter.HighlighterIterator;
 import com.intellij.psi.tree.TokenSet;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
 final class JetLtGtTypingUtils {
-    private static final TokenSet INVALID_INSIDE_REFERENCE = TokenSet.create(JetTokens.SEMICOLON, JetTokens.LBRACE, JetTokens.RBRACE);
+    private static final TokenSet INVALID_INSIDE_REFERENCE = TokenSet.create(KtTokens.SEMICOLON, KtTokens.LBRACE, KtTokens.RBRACE);
 
     private JetLtGtTypingUtils() {
     }
 
     static void handleJetAutoCloseLT(Editor editor) {
-        JavaTypedHandler.handleAfterJavaLT(editor, JetTokens.LT, JetTokens.GT, INVALID_INSIDE_REFERENCE);
+        JavaTypedHandler.handleAfterJavaLT(editor, KtTokens.LT, KtTokens.GT, INVALID_INSIDE_REFERENCE);
     }
 
     static boolean handleJetGTInsert(Editor editor) {
-        return JavaTypedHandler.handleJavaGT(editor, JetTokens.LT, JetTokens.GT, INVALID_INSIDE_REFERENCE);
+        return JavaTypedHandler.handleJavaGT(editor, KtTokens.LT, KtTokens.GT, INVALID_INSIDE_REFERENCE);
     }
 
     static void handleJetLTDeletion(Editor editor, int offset) {
-        JavaBackspaceHandler.handleLTDeletion(editor, offset, JetTokens.LT, JetTokens.GT, INVALID_INSIDE_REFERENCE);
+        JavaBackspaceHandler.handleLTDeletion(editor, offset, KtTokens.LT, KtTokens.GT, INVALID_INSIDE_REFERENCE);
     }
 
     static boolean shouldAutoCloseAngleBracket(int offset, Editor editor) {
@@ -56,7 +56,7 @@ final class JetLtGtTypingUtils {
             iterator.retreat();
         }
 
-        return JavaTypedHandler.isClassLikeIdentifier(offset, editor, iterator, JetTokens.IDENTIFIER);
+        return JavaTypedHandler.isClassLikeIdentifier(offset, editor, iterator, KtTokens.IDENTIFIER);
     }
 
     private static boolean isAfterFunKeyword(int offset, Editor editor) {
@@ -69,10 +69,10 @@ final class JetLtGtTypingUtils {
             iterator.retreat();
         }
 
-        if (iterator.getTokenType() == JetTokens.WHITE_SPACE && iterator.getStart() > 0) {
+        if (iterator.getTokenType() == KtTokens.WHITE_SPACE && iterator.getStart() > 0) {
             iterator.retreat();
         }
 
-        return iterator.getTokenType() == JetTokens.FUN_KEYWORD;
+        return iterator.getTokenType() == KtTokens.FUN_KEYWORD;
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/KotlinBackspaceHandler.java b/idea/src/org/jetbrains/kotlin/idea/editor/KotlinBackspaceHandler.java
index ad3290c379d..ad39318c140 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/KotlinBackspaceHandler.java
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/KotlinBackspaceHandler.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.editor;
 import com.intellij.codeInsight.editorActions.BackspaceHandlerDelegate;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.psi.PsiFile;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 
 public class KotlinBackspaceHandler extends BackspaceHandlerDelegate {
     private boolean deleteGt;
@@ -27,7 +27,7 @@ public class KotlinBackspaceHandler extends BackspaceHandlerDelegate {
     @Override
     public void beforeCharDeleted(char c, PsiFile file, Editor editor) {
         int offset = editor.getCaretModel().getOffset() - 1;
-        deleteGt = c =='<' && file instanceof JetFile && JetLtGtTypingUtils.shouldAutoCloseAngleBracket(offset, editor);
+        deleteGt = c =='<' && file instanceof KtFile && JetLtGtTypingUtils.shouldAutoCloseAngleBracket(offset, editor);
     }
 
     @Override
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/KotlinEnterHandler.kt b/idea/src/org/jetbrains/kotlin/idea/editor/KotlinEnterHandler.kt
index 8fd420a938c..5a0caaa4f09 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/KotlinEnterHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/KotlinEnterHandler.kt
@@ -31,14 +31,14 @@ import com.intellij.psi.codeStyle.CodeStyleManager
 import com.intellij.psi.tree.TokenSet
 import com.intellij.util.IncorrectOperationException
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.*
 
 public class KotlinEnterHandler: EnterHandlerDelegateAdapter() {
     companion object {
         private val LOG = Logger.getInstance(javaClass<KotlinEnterHandler>())
-        private val FORCE_INDENT_IN_LAMBDA_AFTER = TokenSet.create(JetTokens.ARROW, JetTokens.LBRACE)
+        private val FORCE_INDENT_IN_LAMBDA_AFTER = TokenSet.create(KtTokens.ARROW, KtTokens.LBRACE)
     }
 
     override fun preprocessEnter(
@@ -49,7 +49,7 @@ public class KotlinEnterHandler: EnterHandlerDelegateAdapter() {
             dataContext: DataContext,
             originalHandler: EditorActionHandler?
     ): EnterHandlerDelegate.Result? {
-        if (file !is JetFile) return EnterHandlerDelegate.Result.Continue
+        if (file !is KtFile) return EnterHandlerDelegate.Result.Continue
 
         if (preprocessEnterInStringLiteral(file, editor, caretOffsetRef, caretAdvance)) {
             return EnterHandlerDelegate.Result.DefaultForceIndent
@@ -71,9 +71,9 @@ public class KotlinEnterHandler: EnterHandlerDelegateAdapter() {
         val elementAfter = CodeInsightUtils.getElementAtOffsetIgnoreWhitespaceBefore(file, caretOffset);
 
         val isAfterLBraceOrArrow = elementBefore != null && elementBefore.getNode()!!.getElementType() in FORCE_INDENT_IN_LAMBDA_AFTER
-        val isBeforeRBrace = elementAfter == null || elementAfter.getNode()!!.getElementType() == JetTokens.RBRACE
+        val isBeforeRBrace = elementAfter == null || elementAfter.getNode()!!.getElementType() == KtTokens.RBRACE
 
-        if (isAfterLBraceOrArrow && isBeforeRBrace && (elementBefore!!.getParent() is JetFunctionLiteral)) {
+        if (isAfterLBraceOrArrow && isBeforeRBrace && (elementBefore!!.getParent() is KtFunctionLiteral)) {
             originalHandler?.execute(editor, dataContext)
             PsiDocumentManager.getInstance(file.getProject()).commitDocument(document)
 
@@ -99,15 +99,15 @@ public class KotlinEnterHandler: EnterHandlerDelegateAdapter() {
                                                caretAdvanceRef: Ref<Int>): Boolean {
         var caretOffset = caretOffsetRef.get()
         val psiAtOffset = psiFile.findElementAt(caretOffset) ?: return false
-        val stringTemplate = psiAtOffset.getStrictParentOfType<JetStringTemplateExpression>() ?: return false
+        val stringTemplate = psiAtOffset.getStrictParentOfType<KtStringTemplateExpression>() ?: return false
         if (!stringTemplate.isSingleQuoted()) return false
         val tokenType = psiAtOffset.getNode().getElementType()
         when (tokenType) {
-            JetTokens.CLOSING_QUOTE, JetTokens.REGULAR_STRING_PART, JetTokens.ESCAPE_SEQUENCE,
-            JetTokens.SHORT_TEMPLATE_ENTRY_START, JetTokens.LONG_TEMPLATE_ENTRY_START -> {
+            KtTokens.CLOSING_QUOTE, KtTokens.REGULAR_STRING_PART, KtTokens.ESCAPE_SEQUENCE,
+            KtTokens.SHORT_TEMPLATE_ENTRY_START, KtTokens.LONG_TEMPLATE_ENTRY_START -> {
                 val doc = editor.getDocument()
                 var caretAdvance = 1
-                if (stringTemplate.getParent() is JetDotQualifiedExpression) {
+                if (stringTemplate.getParent() is KtDotQualifiedExpression) {
                     doc.insertString(stringTemplate.endOffset, ")")
                     doc.insertString(stringTemplate.startOffset, "(")
                     caretOffset++
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/KotlinQuoteHandler.kt b/idea/src/org/jetbrains/kotlin/idea/editor/KotlinQuoteHandler.kt
index 17e1c0d4503..35db1ea8445 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/KotlinQuoteHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/KotlinQuoteHandler.kt
@@ -20,18 +20,18 @@ import com.intellij.codeInsight.editorActions.QuoteHandler
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.highlighter.HighlighterIterator
 import com.intellij.psi.tree.IElementType
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 
 public class KotlinQuoteHandler : QuoteHandler {
     override fun isClosingQuote(iterator: HighlighterIterator, offset: Int): Boolean {
         val tokenType = iterator.getTokenType()
 
-        if (tokenType == JetTokens.CHARACTER_LITERAL) {
+        if (tokenType == KtTokens.CHARACTER_LITERAL) {
             val start = iterator.getStart()
             val end = iterator.getEnd()
             return end - start >= 1 && offset == end - 1
         }
-        else if (tokenType == JetTokens.CLOSING_QUOTE) {
+        else if (tokenType == KtTokens.CLOSING_QUOTE) {
             return true
         }
         return false
@@ -40,7 +40,7 @@ public class KotlinQuoteHandler : QuoteHandler {
     override fun isOpeningQuote(iterator: HighlighterIterator, offset: Int): Boolean {
         val tokenType = iterator.getTokenType()
 
-        if (tokenType == JetTokens.OPEN_QUOTE) {
+        if (tokenType == KtTokens.OPEN_QUOTE) {
             val start = iterator.getStart()
             return offset == start
         }
@@ -53,11 +53,11 @@ public class KotlinQuoteHandler : QuoteHandler {
 
     override fun isInsideLiteral(iterator: HighlighterIterator): Boolean {
         val tokenType = iterator.getTokenType()
-        return tokenType == JetTokens.REGULAR_STRING_PART ||
-               tokenType == JetTokens.OPEN_QUOTE ||
-               tokenType == JetTokens.CLOSING_QUOTE ||
-               tokenType == JetTokens.SHORT_TEMPLATE_ENTRY_START ||
-               tokenType == JetTokens.LONG_TEMPLATE_ENTRY_END ||
-               tokenType == JetTokens.LONG_TEMPLATE_ENTRY_START
+        return tokenType == KtTokens.REGULAR_STRING_PART ||
+               tokenType == KtTokens.OPEN_QUOTE ||
+               tokenType == KtTokens.CLOSING_QUOTE ||
+               tokenType == KtTokens.SHORT_TEMPLATE_ENTRY_START ||
+               tokenType == KtTokens.LONG_TEMPLATE_ENTRY_END ||
+               tokenType == KtTokens.LONG_TEMPLATE_ENTRY_START
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/KotlinSmartEnterHandler.kt b/idea/src/org/jetbrains/kotlin/idea/editor/KotlinSmartEnterHandler.kt
index e282366fe02..a3ba08bc936 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/KotlinSmartEnterHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/KotlinSmartEnterHandler.kt
@@ -24,18 +24,18 @@ import com.intellij.util.text.CharArrayUtil
 import com.intellij.psi.codeStyle.CodeStyleSettingsManager
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiWhiteSpace
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetBlockExpression
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetDeclarationWithBody
-import org.jetbrains.kotlin.psi.JetIfExpression
-import org.jetbrains.kotlin.psi.JetForExpression
-import org.jetbrains.kotlin.psi.JetParameter
-import org.jetbrains.kotlin.psi.JetFunctionLiteral
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtBlockExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtDeclarationWithBody
+import org.jetbrains.kotlin.psi.KtIfExpression
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtParameter
+import org.jetbrains.kotlin.psi.KtFunctionLiteral
 import com.intellij.psi.tree.TokenSet
-import org.jetbrains.kotlin.JetNodeTypes
-import org.jetbrains.kotlin.psi.JetLoopExpression
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.KtNodeTypes
+import org.jetbrains.kotlin.psi.KtLoopExpression
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 
 public class KotlinSmartEnterHandler: SmartEnterProcessorWithFixers() {
@@ -68,12 +68,12 @@ public class KotlinSmartEnterHandler: SmartEnterProcessorWithFixers() {
         while (atCaret != null) {
             when {
                 atCaret.isJetStatement() == true -> return atCaret
-                atCaret.getParent() is JetFunctionLiteral -> return atCaret
-                atCaret is JetDeclaration -> {
+                atCaret.getParent() is KtFunctionLiteral -> return atCaret
+                atCaret is KtDeclaration -> {
                     val declaration = atCaret
                     when {
-                        declaration is JetParameter && !declaration.isInLambdaExpression() -> {/* proceed to function declaration */}
-                        declaration.getParent() is JetForExpression -> {/* skip variable declaration in 'for' expression */}
+                        declaration is KtParameter && !declaration.isInLambdaExpression() -> {/* proceed to function declaration */}
+                        declaration.getParent() is KtForExpression -> {/* skip variable declaration in 'for' expression */}
                         else -> return atCaret
                     }
                 }
@@ -106,7 +106,7 @@ public class KotlinSmartEnterHandler: SmartEnterProcessorWithFixers() {
             val settings = CodeStyleSettingsManager.getSettings(file.getProject())
             val old = settings.KEEP_SIMPLE_BLOCKS_IN_ONE_LINE
             settings.KEEP_SIMPLE_BLOCKS_IN_ONE_LINE = false
-            val elt = file.findElementAt(caretOffset - 1)!!.getStrictParentOfType<JetBlockExpression>()
+            val elt = file.findElementAt(caretOffset - 1)!!.getStrictParentOfType<KtBlockExpression>()
             if (elt != null) {
                 reformat(elt)
             }
@@ -122,27 +122,27 @@ public class KotlinSmartEnterHandler: SmartEnterProcessorWithFixers() {
     }
 
     private fun PsiElement.isJetStatement() = when {
-        getParent() is JetBlockExpression && getNode()?.getElementType() !in BRACES -> true
-        getParent()?.getNode()?.getElementType() in BRANCH_CONTAINERS && this !is JetBlockExpression -> true
+        getParent() is KtBlockExpression && getNode()?.getElementType() !in BRACES -> true
+        getParent()?.getNode()?.getElementType() in BRANCH_CONTAINERS && this !is KtBlockExpression -> true
         else -> false
     }
 
     class KotlinPlainEnterProcessor : SmartEnterProcessorWithFixers.FixEnterProcessor() {
-        private fun getControlStatementBlock(caret: Int, element: PsiElement): JetExpression? {
+        private fun getControlStatementBlock(caret: Int, element: PsiElement): KtExpression? {
             when (element) {
-                is JetDeclarationWithBody -> return element.getBodyExpression()
-                is JetIfExpression -> {
+                is KtDeclarationWithBody -> return element.getBodyExpression()
+                is KtIfExpression -> {
                     if (element.getThen().isWithCaret(caret)) return element.getThen()
                     if (element.getElse().isWithCaret(caret)) return element.getElse()
                 }
-                is JetLoopExpression -> return element.getBody()
+                is KtLoopExpression -> return element.getBody()
             }
 
             return null
         }
 
         override fun doEnter(atCaret: PsiElement, file: PsiFile?, editor: Editor, modified: Boolean): Boolean {
-            val block = getControlStatementBlock(editor.getCaretModel().getOffset(), atCaret) as? JetBlockExpression
+            val block = getControlStatementBlock(editor.getCaretModel().getOffset(), atCaret) as? KtBlockExpression
             if (block != null) {
                 val firstElement = block.getFirstChild()?.getNextSibling()
 
@@ -161,6 +161,6 @@ public class KotlinSmartEnterHandler: SmartEnterProcessorWithFixers() {
     }
 }
 
-private val BRANCH_CONTAINERS = TokenSet.create(JetNodeTypes.THEN, JetNodeTypes.ELSE, JetNodeTypes.BODY)
-private val BRACES = TokenSet.create(JetTokens.RBRACE, JetTokens.LBRACE)
-private fun JetParameter.isInLambdaExpression() = this.getParent()?.getParent() is JetFunctionLiteral
+private val BRANCH_CONTAINERS = TokenSet.create(KtNodeTypes.THEN, KtNodeTypes.ELSE, KtNodeTypes.BODY)
+private val BRACES = TokenSet.create(KtTokens.RBRACE, KtTokens.LBRACE)
+private fun KtParameter.isInLambdaExpression() = this.getParent()?.getParent() is KtFunctionLiteral
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/KotlinTypedHandler.java b/idea/src/org/jetbrains/kotlin/idea/editor/KotlinTypedHandler.java
index 04d189955ea..5fa95f116ed 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/KotlinTypedHandler.java
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/KotlinTypedHandler.java
@@ -44,21 +44,21 @@ import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.TokenSet;
 import com.intellij.util.text.CharArrayUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.JetNodeTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
+import org.jetbrains.kotlin.psi.KtFile;
 
 public class KotlinTypedHandler extends TypedHandlerDelegate {
     private final static TokenSet CONTROL_FLOW_EXPRESSIONS = TokenSet.create(
-            JetNodeTypes.IF,
-            JetNodeTypes.FOR,
-            JetNodeTypes.WHILE);
+            KtNodeTypes.IF,
+            KtNodeTypes.FOR,
+            KtNodeTypes.WHILE);
 
     private boolean jetLTTyped;
 
     @Override
     public Result beforeCharTyped(char c, Project project, Editor editor, PsiFile file, FileType fileType) {
-        if (!(file instanceof JetFile)) {
+        if (!(file instanceof KtFile)) {
             return Result.CONTINUE;
         }
 
@@ -89,7 +89,7 @@ public class KotlinTypedHandler extends TypedHandlerDelegate {
                     iterator.retreat();
                 }
 
-                if (iterator.atEnd() || iterator.getTokenType() != JetTokens.RPAR) {
+                if (iterator.atEnd() || iterator.getTokenType() != KtTokens.RPAR) {
                     return Result.CONTINUE;
                 }
 
@@ -139,7 +139,7 @@ public class KotlinTypedHandler extends TypedHandlerDelegate {
                 if (lastElement == null) return false;
 
                 IElementType elementType = lastElement.getNode().getElementType();
-                return elementType == JetTokens.DOT || elementType == JetTokens.SAFE_ACCESS;
+                return elementType == KtTokens.DOT || elementType == KtTokens.SAFE_ACCESS;
             }
         });
     }
@@ -159,7 +159,7 @@ public class KotlinTypedHandler extends TypedHandlerDelegate {
                 PsiElement lastElement = file.findElementAt(offset - 1);
                 if (lastElement == null) return false;
 
-                return lastElement.getNode().getElementType() == JetTokens.AT;
+                return lastElement.getNode().getElementType() == KtTokens.AT;
             }
         });
     }
@@ -173,7 +173,7 @@ public class KotlinTypedHandler extends TypedHandlerDelegate {
                 PsiElement lastElement = file.findElementAt(offset - 1);
                 if (lastElement == null) return false;
 
-                return lastElement.getNode().getElementType() == JetTokens.COLONCOLON;
+                return lastElement.getNode().getElementType() == KtTokens.COLONCOLON;
             }
         });
     }
@@ -185,7 +185,7 @@ public class KotlinTypedHandler extends TypedHandlerDelegate {
 
     @Override
     public Result charTyped(char c, Project project, @NotNull Editor editor, @NotNull PsiFile file) {
-        if (!(file instanceof JetFile)) {
+        if (!(file instanceof KtFile)) {
             return Result.CONTINUE;
         }
 
@@ -201,7 +201,7 @@ public class KotlinTypedHandler extends TypedHandlerDelegate {
             int offset = editor.getCaretModel().getOffset();
             PsiElement previousElement = file.findElementAt(offset - 1);
             if (previousElement instanceof LeafPsiElement
-                    && ((LeafPsiElement) previousElement).getElementType() == JetTokens.LONG_TEMPLATE_ENTRY_START) {
+                    && ((LeafPsiElement) previousElement).getElementType() == KtTokens.LONG_TEMPLATE_ENTRY_START) {
                 editor.getDocument().insertString(offset, "}");
                 return Result.STOP;
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinDoWhileFixer.kt b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinDoWhileFixer.kt
index 318fbe077eb..20ebeea0302 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinDoWhileFixer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinDoWhileFixer.kt
@@ -20,12 +20,12 @@ import com.intellij.lang.SmartEnterProcessorWithFixers
 import org.jetbrains.kotlin.idea.editor.KotlinSmartEnterHandler
 import com.intellij.openapi.editor.Editor
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetDoWhileExpression
-import org.jetbrains.kotlin.psi.JetBlockExpression
+import org.jetbrains.kotlin.psi.KtDoWhileExpression
+import org.jetbrains.kotlin.psi.KtBlockExpression
 
 public class KotlinDoWhileFixer : SmartEnterProcessorWithFixers.Fixer<KotlinSmartEnterHandler>() {
     override fun apply(editor: Editor, processor: KotlinSmartEnterHandler, psiElement: PsiElement) {
-        if (psiElement !is JetDoWhileExpression) return
+        if (psiElement !is KtDoWhileExpression) return
 
         val doc = editor.getDocument()
         val start = psiElement.range.start
@@ -41,7 +41,7 @@ public class KotlinDoWhileFixer : SmartEnterProcessorWithFixers.Fixer<KotlinSmar
             }
             return
         }
-        else if (whileKeyword != null && body !is JetBlockExpression && body.startLine(doc) > psiElement.startLine(doc)) {
+        else if (whileKeyword != null && body !is KtBlockExpression && body.startLine(doc) > psiElement.startLine(doc)) {
             doc.insertString(whileKeyword.range.start, "}")
             doc.insertString(start + "do".length(), "{")
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinForConditionFixer.kt b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinForConditionFixer.kt
index 944994043f3..b3f8422947e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinForConditionFixer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinForConditionFixer.kt
@@ -17,14 +17,14 @@
 package org.jetbrains.kotlin.idea.editor.fixers
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetForExpression
+import org.jetbrains.kotlin.psi.KtForExpression
 
-public class KotlinForConditionFixer: MissingConditionFixer<JetForExpression>() {
+public class KotlinForConditionFixer: MissingConditionFixer<KtForExpression>() {
     override val keyword = "for"
-    override fun getElement(element: PsiElement?) = element as? JetForExpression
-    override fun getCondition(element: JetForExpression) =
+    override fun getElement(element: PsiElement?) = element as? KtForExpression
+    override fun getCondition(element: KtForExpression) =
             element.getLoopRange() ?: element.getLoopParameter() ?: element.getMultiParameter()
-    override fun getLeftParenthesis(element: JetForExpression) = element.getLeftParenthesis()
-    override fun getRightParenthesis(element: JetForExpression) = element.getRightParenthesis()
-    override fun getBody(element: JetForExpression) = element.getBody()
+    override fun getLeftParenthesis(element: KtForExpression) = element.getLeftParenthesis()
+    override fun getRightParenthesis(element: KtForExpression) = element.getRightParenthesis()
+    override fun getBody(element: KtForExpression) = element.getBody()
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinFunctionDeclarationBodyFixer.kt b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinFunctionDeclarationBodyFixer.kt
index 6442f7db0ea..71901f1ae50 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinFunctionDeclarationBodyFixer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinFunctionDeclarationBodyFixer.kt
@@ -20,22 +20,22 @@ import com.intellij.lang.SmartEnterProcessorWithFixers
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.kotlin.idea.editor.KotlinSmartEnterHandler
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetPsiUtil
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtPsiUtil
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 
 
 public class KotlinFunctionDeclarationBodyFixer : SmartEnterProcessorWithFixers.Fixer<KotlinSmartEnterHandler>() {
     override fun apply(editor: Editor, processor: KotlinSmartEnterHandler, psiElement: PsiElement) {
-        if (psiElement !is JetNamedFunction) return
+        if (psiElement !is KtNamedFunction) return
         if (psiElement.getBodyExpression() != null|| psiElement.getEqualsToken() != null) return
 
-        val parentDeclaration = psiElement.getStrictParentOfType<JetDeclaration>()
-        if (parentDeclaration is JetClassOrObject) {
-            if (JetPsiUtil.isTrait(parentDeclaration) || psiElement.hasModifier(JetTokens.ABSTRACT_KEYWORD)) {
+        val parentDeclaration = psiElement.getStrictParentOfType<KtDeclaration>()
+        if (parentDeclaration is KtClassOrObject) {
+            if (KtPsiUtil.isTrait(parentDeclaration) || psiElement.hasModifier(KtTokens.ABSTRACT_KEYWORD)) {
                 return
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinFunctionParametersFixer.kt b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinFunctionParametersFixer.kt
index d8b592b7de0..4cb5cae0a08 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinFunctionParametersFixer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinFunctionParametersFixer.kt
@@ -20,12 +20,12 @@ import com.intellij.lang.SmartEnterProcessorWithFixers
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.idea.editor.KotlinSmartEnterHandler
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtNamedFunction
 
 
 public class KotlinFunctionParametersFixer : SmartEnterProcessorWithFixers.Fixer<KotlinSmartEnterHandler>() {
     override fun apply(editor: Editor, processor: KotlinSmartEnterHandler, psiElement: PsiElement) {
-        if (psiElement !is JetNamedFunction) return;
+        if (psiElement !is KtNamedFunction) return;
 
         val parameterList = psiElement.getValueParameterList()
         if (parameterList == null) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinIfConditionFixer.kt b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinIfConditionFixer.kt
index e7aeb9eb297..47e0847ccbd 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinIfConditionFixer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinIfConditionFixer.kt
@@ -17,13 +17,13 @@
 package org.jetbrains.kotlin.idea.editor.fixers
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetIfExpression
+import org.jetbrains.kotlin.psi.KtIfExpression
 
-public class KotlinIfConditionFixer : MissingConditionFixer<JetIfExpression>() {
+public class KotlinIfConditionFixer : MissingConditionFixer<KtIfExpression>() {
     override val keyword = "if"
-    override fun getElement(element: PsiElement?) = element as? JetIfExpression
-    override fun getCondition(element: JetIfExpression) = element.getCondition()
-    override fun getLeftParenthesis(element: JetIfExpression) = element.getLeftParenthesis()
-    override fun getRightParenthesis(element: JetIfExpression) = element.getRightParenthesis()
-    override fun getBody(element: JetIfExpression) = element.getThen()
+    override fun getElement(element: PsiElement?) = element as? KtIfExpression
+    override fun getCondition(element: KtIfExpression) = element.getCondition()
+    override fun getLeftParenthesis(element: KtIfExpression) = element.getLeftParenthesis()
+    override fun getRightParenthesis(element: KtIfExpression) = element.getRightParenthesis()
+    override fun getBody(element: KtIfExpression) = element.getThen()
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinMissingForOrWhileBodyFixer.kt b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinMissingForOrWhileBodyFixer.kt
index 53f34e38a46..ed847e8a4c5 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinMissingForOrWhileBodyFixer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinMissingForOrWhileBodyFixer.kt
@@ -20,20 +20,20 @@ import com.intellij.lang.SmartEnterProcessorWithFixers
 import org.jetbrains.kotlin.idea.editor.KotlinSmartEnterHandler
 import com.intellij.openapi.editor.Editor
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetWhileExpression
-import org.jetbrains.kotlin.psi.JetBlockExpression
-import org.jetbrains.kotlin.psi.JetLoopExpression
-import org.jetbrains.kotlin.psi.JetForExpression
+import org.jetbrains.kotlin.psi.KtWhileExpression
+import org.jetbrains.kotlin.psi.KtBlockExpression
+import org.jetbrains.kotlin.psi.KtLoopExpression
+import org.jetbrains.kotlin.psi.KtForExpression
 
 public class KotlinMissingForOrWhileBodyFixer : SmartEnterProcessorWithFixers.Fixer<KotlinSmartEnterHandler>() {
     override fun apply(editor: Editor, processor: KotlinSmartEnterHandler, element: PsiElement) {
-        if (!(element is JetForExpression || element is JetWhileExpression)) return
-        val loopExpression = element as JetLoopExpression
+        if (!(element is KtForExpression || element is KtWhileExpression)) return
+        val loopExpression = element as KtLoopExpression
 
         val doc = editor.getDocument()
 
         val body = loopExpression.getBody()
-        if (body is JetBlockExpression) return
+        if (body is KtBlockExpression) return
 
         if (!loopExpression.isValidLoopCondition()) return
 
@@ -45,6 +45,6 @@ public class KotlinMissingForOrWhileBodyFixer : SmartEnterProcessorWithFixers.Fi
         doc.insertString(rParen.range.end, "{}")
     }
 
-    fun JetLoopExpression.isValidLoopCondition() = getLeftParenthesis() != null && getRightParenthesis() != null
+    fun KtLoopExpression.isValidLoopCondition() = getLeftParenthesis() != null && getRightParenthesis() != null
 }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinMissingIfBranchFixer.kt b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinMissingIfBranchFixer.kt
index 95b914c7dfc..c48e87d7730 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinMissingIfBranchFixer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinMissingIfBranchFixer.kt
@@ -20,26 +20,26 @@ import com.intellij.lang.SmartEnterProcessorWithFixers
 import org.jetbrains.kotlin.idea.editor.KotlinSmartEnterHandler
 import com.intellij.openapi.editor.Editor
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetIfExpression
-import org.jetbrains.kotlin.psi.JetBlockExpression
+import org.jetbrains.kotlin.psi.KtIfExpression
+import org.jetbrains.kotlin.psi.KtBlockExpression
 
 public class KotlinMissingIfBranchFixer : SmartEnterProcessorWithFixers.Fixer<KotlinSmartEnterHandler>() {
     override fun apply(editor: Editor, processor: KotlinSmartEnterHandler, element: PsiElement) {
-        if (element !is JetIfExpression) return
+        if (element !is KtIfExpression) return
 
         val document = editor.getDocument()
         val elseBranch = element.getElse()
         val elseKeyword = element.getElseKeyword()
 
         if (elseKeyword != null) {
-            if (elseBranch == null || elseBranch !is JetBlockExpression && elseBranch.startLine(editor.getDocument()) > elseKeyword.startLine(editor.getDocument())) {
+            if (elseBranch == null || elseBranch !is KtBlockExpression && elseBranch.startLine(editor.getDocument()) > elseKeyword.startLine(editor.getDocument())) {
                 document.insertString(elseKeyword.range.end, "{}")
                 return
             }
         }
 
         val thenBranch = element.getThen()
-        if (thenBranch is JetBlockExpression) return
+        if (thenBranch is KtBlockExpression) return
 
         val rParen = element.getRightParenthesis()
         if (rParen == null) return
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinMissingWhenBodyFixer.kt b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinMissingWhenBodyFixer.kt
index f7498a9bc86..c3a56699aad 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinMissingWhenBodyFixer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinMissingWhenBodyFixer.kt
@@ -20,11 +20,11 @@ import com.intellij.lang.SmartEnterProcessorWithFixers
 import org.jetbrains.kotlin.idea.editor.KotlinSmartEnterHandler
 import com.intellij.openapi.editor.Editor
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetWhenExpression
+import org.jetbrains.kotlin.psi.KtWhenExpression
 
 public class KotlinMissingWhenBodyFixer : SmartEnterProcessorWithFixers.Fixer<KotlinSmartEnterHandler>() {
     override fun apply(editor: Editor, processor: KotlinSmartEnterHandler, element: PsiElement) {
-        if (element !is JetWhenExpression) return
+        if (element !is KtWhenExpression) return
 
         val doc = editor.getDocument()
 
@@ -39,7 +39,7 @@ public class KotlinMissingWhenBodyFixer : SmartEnterProcessorWithFixers.Fixer<Ko
         }
     }
 
-    fun JetWhenExpression.insertOpenBraceAfter(): PsiElement? = when {
+    fun KtWhenExpression.insertOpenBraceAfter(): PsiElement? = when {
         getRightParenthesis() != null -> getRightParenthesis()
         getSubjectExpression() != null -> null
         getLeftParenthesis() != null -> null
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinWhenSubjectCaretFixer.kt b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinWhenSubjectCaretFixer.kt
index dd8e59ad6f2..a220c89e17b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinWhenSubjectCaretFixer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinWhenSubjectCaretFixer.kt
@@ -20,11 +20,11 @@ import com.intellij.psi.PsiElement
 import com.intellij.lang.SmartEnterProcessorWithFixers
 import org.jetbrains.kotlin.idea.editor.KotlinSmartEnterHandler
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.psi.JetWhenExpression
+import org.jetbrains.kotlin.psi.KtWhenExpression
 
 public class KotlinWhenSubjectCaretFixer : SmartEnterProcessorWithFixers.Fixer<KotlinSmartEnterHandler>() {
     override fun apply(editor: Editor, processor: KotlinSmartEnterHandler, element: PsiElement) {
-        if (element !is JetWhenExpression) return
+        if (element !is KtWhenExpression) return
 
         val lParen = element.getLeftParenthesis()
         val rParen = element.getRightParenthesis()
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinWhileConditionFixer.kt b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinWhileConditionFixer.kt
index 2b295a9b421..652f951658c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinWhileConditionFixer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinWhileConditionFixer.kt
@@ -17,13 +17,13 @@
 package org.jetbrains.kotlin.idea.editor.fixers
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetWhileExpression
+import org.jetbrains.kotlin.psi.KtWhileExpression
 
-public class KotlinWhileConditionFixer: MissingConditionFixer<JetWhileExpression>() {
+public class KotlinWhileConditionFixer: MissingConditionFixer<KtWhileExpression>() {
     override val keyword = "while"
-    override fun getElement(element: PsiElement?) = element as? JetWhileExpression
-    override fun getCondition(element: JetWhileExpression) = element.getCondition()
-    override fun getLeftParenthesis(element: JetWhileExpression) = element.getLeftParenthesis()
-    override fun getRightParenthesis(element: JetWhileExpression) = element.getRightParenthesis()
-    override fun getBody(element: JetWhileExpression) = element.getBody()
+    override fun getElement(element: PsiElement?) = element as? KtWhileExpression
+    override fun getCondition(element: KtWhileExpression) = element.getCondition()
+    override fun getLeftParenthesis(element: KtWhileExpression) = element.getLeftParenthesis()
+    override fun getRightParenthesis(element: KtWhileExpression) = element.getRightParenthesis()
+    override fun getBody(element: KtWhileExpression) = element.getBody()
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinCodeBlockSelectioner.kt b/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinCodeBlockSelectioner.kt
index ffcfbdb295c..6fd5d0f6ac3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinCodeBlockSelectioner.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinCodeBlockSelectioner.kt
@@ -21,9 +21,9 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiWhiteSpace
-import org.jetbrains.kotlin.psi.JetBlockExpression
-import org.jetbrains.kotlin.psi.JetWhenExpression
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.psi.KtBlockExpression
+import org.jetbrains.kotlin.psi.KtWhenExpression
+import org.jetbrains.kotlin.lexer.KtTokens
 
 import java.util.ArrayList
 import com.intellij.codeInsight.editorActions.ExtendWordSelectionHandlerBase
@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.psi.psiUtil.startOffset
  */
 public class KotlinCodeBlockSelectioner : ExtendWordSelectionHandlerBase() {
     override fun canSelect(e: PsiElement)
-            = e is JetBlockExpression || e is JetWhenExpression
+            = e is KtBlockExpression || e is KtWhenExpression
 
     override fun select(e: PsiElement, editorText: CharSequence, cursorOffset: Int, editor: Editor): List<TextRange>? {
         val result = ArrayList<TextRange>()
@@ -54,7 +54,7 @@ public class KotlinCodeBlockSelectioner : ExtendWordSelectionHandlerBase() {
 
     private fun findBlockContentStart(block: PsiElement): Int {
         val element = block.allChildren
-                              .dropWhile { it.getNode().getElementType() != JetTokens.LBRACE } // search for '{'
+                              .dropWhile { it.getNode().getElementType() != KtTokens.LBRACE } // search for '{'
                               .drop(1) // skip it
                               .dropWhile { it is PsiWhiteSpace } // and skip all whitespaces
                               .firstOrNull() ?: block
@@ -66,7 +66,7 @@ public class KotlinCodeBlockSelectioner : ExtendWordSelectionHandlerBase() {
                            .toList()
                            .asReversed()
                            .asSequence()
-                           .dropWhile { it.getNode().getElementType() != JetTokens.RBRACE } // search for '}'
+                           .dropWhile { it.getNode().getElementType() != KtTokens.RBRACE } // search for '}'
                            .drop(1) // skip it
                            .dropWhile { it is PsiWhiteSpace } // and skip all whitespaces
                            .firstOrNull() ?: block
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinDeclarationSelectioner.kt b/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinDeclarationSelectioner.kt
index c846593d211..44cb8ada0a0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinDeclarationSelectioner.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinDeclarationSelectioner.kt
@@ -20,21 +20,21 @@ import com.intellij.psi.PsiElement
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import com.intellij.codeInsight.editorActions.ExtendWordSelectionHandlerBase
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import java.util.ArrayList
 import org.jetbrains.kotlin.psi.psiUtil.siblings
 import com.intellij.psi.PsiComment
 import com.intellij.psi.PsiWhiteSpace
-import org.jetbrains.kotlin.psi.JetMultiDeclaration
+import org.jetbrains.kotlin.psi.KtMultiDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
 public class KotlinDeclarationSelectioner : ExtendWordSelectionHandlerBase() {
     override fun canSelect(e: PsiElement)
-            = e is JetDeclaration
+            = e is KtDeclaration
 
     override fun select(e: PsiElement, editorText: CharSequence, cursorOffset: Int, editor: Editor): List<TextRange>? {
-        if (e is JetMultiDeclaration) {
+        if (e is KtMultiDeclaration) {
             return selectMultiDeclaration(editorText, e)
         }
 
@@ -58,7 +58,7 @@ public class KotlinDeclarationSelectioner : ExtendWordSelectionHandlerBase() {
         return result
     }
 
-    private fun selectMultiDeclaration(editorText: CharSequence, e: JetMultiDeclaration): ArrayList<TextRange> {
+    private fun selectMultiDeclaration(editorText: CharSequence, e: KtMultiDeclaration): ArrayList<TextRange> {
         val result = ArrayList<TextRange>()
         val lpar = e.lPar
         val rpar = e.rPar
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinListSelectioner.kt b/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinListSelectioner.kt
index 06b41f15c26..c6f98cb997b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinListSelectioner.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinListSelectioner.kt
@@ -20,27 +20,27 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 import com.intellij.psi.tree.TokenSet
-import org.jetbrains.kotlin.psi.JetParameterList
-import org.jetbrains.kotlin.psi.JetTypeArgumentList
-import org.jetbrains.kotlin.psi.JetTypeParameterList
-import org.jetbrains.kotlin.psi.JetValueArgumentList
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.psi.KtParameterList
+import org.jetbrains.kotlin.psi.KtTypeArgumentList
+import org.jetbrains.kotlin.psi.KtTypeParameterList
+import org.jetbrains.kotlin.psi.KtValueArgumentList
+import org.jetbrains.kotlin.lexer.KtTokens
 import com.intellij.codeInsight.editorActions.ExtendWordSelectionHandlerBase
 
 public class KotlinListSelectioner : ExtendWordSelectionHandlerBase() {
     companion object {
         fun canSelect(e: PsiElement)
-            = e is JetParameterList || e is JetValueArgumentList || e is JetTypeParameterList || e is JetTypeArgumentList
+            = e is KtParameterList || e is KtValueArgumentList || e is KtTypeParameterList || e is KtTypeArgumentList
     }
 
     override fun canSelect(e: PsiElement) = KotlinListSelectioner.canSelect(e)
 
     override fun select(e: PsiElement, editorText: CharSequence, cursorOffset: Int, editor: Editor): List<TextRange>? {
         val node = e.getNode()!!
-        val startNode = node.findChildByType(TokenSet.create(JetTokens.LPAR, JetTokens.LT)) ?: return null
-        val endNode = node.findChildByType(TokenSet.create(JetTokens.RPAR, JetTokens.GT)) ?: return null
+        val startNode = node.findChildByType(TokenSet.create(KtTokens.LPAR, KtTokens.LT)) ?: return null
+        val endNode = node.findChildByType(TokenSet.create(KtTokens.RPAR, KtTokens.GT)) ?: return null
         val innerRange = TextRange(startNode.getStartOffset() + 1, endNode.getStartOffset())
-        if (e is JetTypeArgumentList || e is JetTypeParameterList) {
+        if (e is KtTypeArgumentList || e is KtTypeParameterList) {
             return listOf(innerRange,
                           TextRange(startNode.getStartOffset(), endNode.getStartOffset() + endNode.getTextLength()))
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinStatementGroupSelectioner.kt b/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinStatementGroupSelectioner.kt
index 8b259802abd..9b9784cac24 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinStatementGroupSelectioner.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinStatementGroupSelectioner.kt
@@ -21,7 +21,7 @@ import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiWhiteSpace
 import com.intellij.psi.impl.source.tree.LeafPsiElement
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 
 import com.intellij.codeInsight.editorActions.ExtendWordSelectionHandlerBase
 import org.jetbrains.kotlin.psi.psiUtil.siblings
@@ -33,9 +33,9 @@ import org.jetbrains.kotlin.psi.*
  */
 public class KotlinStatementGroupSelectioner : ExtendWordSelectionHandlerBase() {
     override fun canSelect(e: PsiElement): Boolean {
-        if (e !is JetExpression && e !is JetWhenEntry && e !is PsiComment) return false
+        if (e !is KtExpression && e !is KtWhenEntry && e !is PsiComment) return false
         val parent = e.getParent()
-        return parent is JetBlockExpression || parent is JetWhenExpression || parent is JetFunctionLiteral
+        return parent is KtBlockExpression || parent is KtWhenExpression || parent is KtFunctionLiteral
     }
 
     override fun select(e: PsiElement, editorText: CharSequence, cursorOffset: Int, editor: Editor): List<TextRange>? {
@@ -43,7 +43,7 @@ public class KotlinStatementGroupSelectioner : ExtendWordSelectionHandlerBase()
 
         val startElement = e.siblings(forward = false, withItself = false)
                 .firstOrNull { // find preceding '{' or blank line
-                    it is LeafPsiElement && it.getElementType() == JetTokens.LBRACE ||
+                    it is LeafPsiElement && it.getElementType() == KtTokens.LBRACE ||
                         it is PsiWhiteSpace && it.getText()!!.count { it == '\n' } > 1
                 }
                 ?.siblings(forward = true, withItself = false)
@@ -52,7 +52,7 @@ public class KotlinStatementGroupSelectioner : ExtendWordSelectionHandlerBase()
 
         val endElement = e.siblings(forward = true, withItself = false)
                 .firstOrNull { // find next '}' or blank line
-                    it is LeafPsiElement && it.getElementType() == JetTokens.RBRACE ||
+                    it is LeafPsiElement && it.getElementType() == KtTokens.RBRACE ||
                         it is PsiWhiteSpace && it.getText()!!.count { it == '\n' } > 1
                 }
                 ?.siblings(forward = false, withItself = false)
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinStringLiteralSelectioner.kt b/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinStringLiteralSelectioner.kt
index ad8130bdef7..a19d10655c9 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinStringLiteralSelectioner.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinStringLiteralSelectioner.kt
@@ -20,15 +20,15 @@ import com.intellij.codeInsight.editorActions.ExtendWordSelectionHandlerBase
 import com.intellij.psi.PsiElement
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
-import org.jetbrains.kotlin.psi.JetStringTemplateExpression
+import org.jetbrains.kotlin.psi.KtStringTemplateExpression
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
 public class KotlinStringLiteralSelectioner : ExtendWordSelectionHandlerBase() {
-    override fun canSelect(e: PsiElement) = e is JetStringTemplateExpression
+    override fun canSelect(e: PsiElement) = e is KtStringTemplateExpression
 
     override fun select(e: PsiElement, editorText: CharSequence, cursorOffset: Int, editor: Editor): List<TextRange>? {
-        val entries = (e as JetStringTemplateExpression).getEntries()
+        val entries = (e as KtStringTemplateExpression).getEntries()
         if (entries.isEmpty()) return null
         val start = entries.first().startOffset
         val end = entries.last().endOffset
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinWordSelectionFilter.kt b/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinWordSelectionFilter.kt
index 1f5e4970e4c..3ca679f1985 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinWordSelectionFilter.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/wordSelection/KotlinWordSelectionFilter.kt
@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.idea.editor.wordSelection
 
 import com.intellij.openapi.util.Condition
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.JetNodeTypes.*
-import org.jetbrains.kotlin.psi.JetContainerNode
+import org.jetbrains.kotlin.KtNodeTypes.*
+import org.jetbrains.kotlin.psi.KtContainerNode
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.kdoc.parser.KDocElementTypes
 
@@ -28,8 +28,8 @@ public class KotlinWordSelectionFilter : Condition<PsiElement>{
         if (e.getLanguage() != KotlinLanguage.INSTANCE) return true
 
         if (KotlinListSelectioner.canSelect(e)) return false
-        if (e is JetContainerNode) return false
-        if (e.getParent().getFirstChild().getNextSibling() == null && e.getParent() !is JetContainerNode) return false // skip nodes with the same range as their parent
+        if (e is KtContainerNode) return false
+        if (e.getParent().getFirstChild().getNextSibling() == null && e.getParent() !is KtContainerNode) return false // skip nodes with the same range as their parent
 
         return when (e.getNode().getElementType()) {
             BLOCK, KDocElementTypes.KDOC_SECTION -> false
diff --git a/idea/src/org/jetbrains/kotlin/idea/filters/JetExceptionFilter.java b/idea/src/org/jetbrains/kotlin/idea/filters/JetExceptionFilter.java
index 55fa08e86e2..a882aaaa80c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/filters/JetExceptionFilter.java
+++ b/idea/src/org/jetbrains/kotlin/idea/filters/JetExceptionFilter.java
@@ -28,7 +28,7 @@ import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.util.DebuggerUtils;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
 
 import java.util.regex.Matcher;
@@ -63,7 +63,7 @@ public class JetExceptionFilter implements Filter {
         String internalName = fullyQualifiedName.replace('.', '/');
         JvmClassName jvmClassName = JvmClassName.byInternalName(internalName);
 
-        JetFile file = DebuggerUtils.findSourceFileForClass(project, searchScope, jvmClassName, fileName);
+        KtFile file = DebuggerUtils.findSourceFileForClass(project, searchScope, jvmClassName, fileName);
 
         if (file == null) return null;
         VirtualFile virtualFile = file.getVirtualFile();
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/BuiltInsUseScopeEnlarger.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/BuiltInsUseScopeEnlarger.kt
index f40f918caff..40c9ba5c0f3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/BuiltInsUseScopeEnlarger.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/BuiltInsUseScopeEnlarger.kt
@@ -22,11 +22,11 @@ import com.intellij.psi.search.ProjectScope
 import com.intellij.psi.search.SearchScope
 import com.intellij.psi.search.UseScopeEnlarger
 import org.jetbrains.kotlin.idea.references.BuiltInsReferenceResolver
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 
 public class BuiltInsUseScopeEnlarger : UseScopeEnlarger() {
     override fun getAdditionalUseScope(element: PsiElement): SearchScope? {
-        if (element is JetElement && BuiltInsReferenceResolver.isFromBuiltIns(element)) {
+        if (element is KtElement && BuiltInsReferenceResolver.isFromBuiltIns(element)) {
             return ProjectScope.getAllScope(element.getProject())
         }
         return null
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/JetElementDescriptionProvider.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/JetElementDescriptionProvider.kt
index ba654f7e340..cb720cca211 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/JetElementDescriptionProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/JetElementDescriptionProvider.kt
@@ -36,26 +36,26 @@ public class JetElementDescriptionProvider : ElementDescriptionProvider {
         val targetElement = element.unwrapped
 
         fun elementKind() = when (targetElement) {
-            is JetClass -> if (targetElement.isInterface()) "interface" else "class"
-            is JetObjectDeclaration -> "object"
-            is JetNamedFunction -> "function"
-            is JetSecondaryConstructor -> "constructor"
-            is JetProperty -> if (targetElement.isLocal()) "variable" else "property"
-            is JetTypeParameter -> "type parameter"
-            is JetParameter -> "parameter"
-            is JetMultiDeclarationEntry -> "variable"
+            is KtClass -> if (targetElement.isInterface()) "interface" else "class"
+            is KtObjectDeclaration -> "object"
+            is KtNamedFunction -> "function"
+            is KtSecondaryConstructor -> "constructor"
+            is KtProperty -> if (targetElement.isLocal()) "variable" else "property"
+            is KtTypeParameter -> "type parameter"
+            is KtParameter -> "parameter"
+            is KtMultiDeclarationEntry -> "variable"
             else -> null
         }
 
         fun targetDescriptor(): DeclarationDescriptor? {
-            val descriptor = (targetElement as JetDeclaration).descriptor ?: return null
+            val descriptor = (targetElement as KtDeclaration).descriptor ?: return null
             if (descriptor is ConstructorDescriptor) {
                 return descriptor.getContainingDeclaration()
             }
             return descriptor
         }
 
-        if (targetElement !is PsiNamedElement || targetElement !is JetElement) return null
+        if (targetElement !is PsiNamedElement || targetElement !is KtElement) return null
 
         val name = (targetElement as PsiNamedElement).getName()
 
@@ -66,7 +66,7 @@ public class JetElementDescriptionProvider : ElementDescriptionProvider {
                 val kind = elementKind() ?: return null
                 val descriptor = targetDescriptor() ?: return null
                 val desc =
-                        if (location.includeParent() && targetElement !is JetTypeParameter && targetElement !is JetParameter) {
+                        if (location.includeParent() && targetElement !is KtTypeParameter && targetElement !is KtParameter) {
                             DescriptorUtils.getFqName(descriptor).asString()
                         }
                         else {
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/JetImportFilteringRule.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/JetImportFilteringRule.kt
index f272322eb83..2ba2c3624f4 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/JetImportFilteringRule.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/JetImportFilteringRule.kt
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.idea.findUsages
 import com.intellij.usages.Usage
 import com.intellij.usages.rules.ImportFilteringRule
 import com.intellij.usages.rules.PsiElementUsage
-import org.jetbrains.kotlin.psi.JetImportDirective
+import org.jetbrains.kotlin.psi.KtImportDirective
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 
 public class JetImportFilteringRule : ImportFilteringRule() {
     public override fun isVisible(usage: Usage): Boolean {
         if (usage is PsiElementUsage) {
-            return usage.getElement()?.getNonStrictParentOfType<JetImportDirective>() == null
+            return usage.getElement()?.getNonStrictParentOfType<KtImportDirective>() == null
         }
 
         return true
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinDeclarationGroupRuleProvider.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinDeclarationGroupRuleProvider.kt
index bc9eb472f30..ea53754ae7f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinDeclarationGroupRuleProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinDeclarationGroupRuleProvider.kt
@@ -21,9 +21,9 @@ import com.intellij.usages.UsageGroup
 import com.intellij.usages.Usage
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.usages.rules.UsageGroupingRule
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import com.intellij.usages.PsiNamedElementUsageGroupBase
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import com.intellij.usages.impl.FileStructureGroupRuleProvider
 import com.intellij.openapi.project.Project
 
@@ -34,9 +34,9 @@ public class KotlinDeclarationGroupRuleProvider : FileStructureGroupRuleProvider
             if (element == null) return null
 
             val containingFile = element.getContainingFile()
-            if (containingFile !is JetFile) return null
+            if (containingFile !is KtFile) return null
 
-            return PsiTreeUtil.getTopmostParentOfType(element, javaClass<JetNamedDeclaration>())?.let { container ->
+            return PsiTreeUtil.getTopmostParentOfType(element, javaClass<KtNamedDeclaration>())?.let { container ->
                 PsiNamedElementUsageGroupBase(container)
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinFindUsagesHandlerFactory.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinFindUsagesHandlerFactory.kt
index 55f3a3ed185..97f8f1b48ff 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinFindUsagesHandlerFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinFindUsagesHandlerFactory.kt
@@ -48,12 +48,12 @@ public class KotlinFindUsagesHandlerFactory(project: Project) : FindUsagesHandle
     val defaultOptions = FindUsagesOptions(project)
 
     public override fun canFindUsages(element: PsiElement): Boolean =
-            element is JetClassOrObject ||
-            element is JetNamedFunction ||
-            element is JetProperty ||
-            element is JetParameter ||
-            element is JetTypeParameter ||
-            element is JetConstructor<*>
+            element is KtClassOrObject ||
+            element is KtNamedFunction ||
+            element is KtProperty ||
+            element is KtParameter ||
+            element is KtTypeParameter ||
+            element is KtConstructor<*>
 
     public fun createFindUsagesHandlerNoQuestions(element: PsiElement): FindUsagesHandler {
         return createFindUsagesHandler(element, forHighlightUsages = false, canAsk = false)
@@ -73,10 +73,10 @@ public class KotlinFindUsagesHandlerFactory(project: Project) : FindUsagesHandle
 
     private fun createFindUsagesHandlerNoDecoration(element: PsiElement, canAsk: Boolean): FindUsagesHandler {
         when (element) {
-            is JetClassOrObject ->
+            is KtClassOrObject ->
                 return KotlinFindClassUsagesHandler(element, this)
 
-            is JetParameter -> {
+            is KtParameter -> {
                 if (canAsk) {
                     val function = element.ownerFunction
                     if (function != null && function.isOverridable()) {
@@ -101,8 +101,8 @@ public class KotlinFindUsagesHandlerFactory(project: Project) : FindUsagesHandle
                 return KotlinFindMemberUsagesHandler.getInstance(element, factory = this)
             }
 
-            is JetNamedFunction, is JetProperty, is JetConstructor<*> -> {
-                val declaration = element as JetNamedDeclaration
+            is KtNamedFunction, is KtProperty, is KtConstructor<*> -> {
+                val declaration = element as KtNamedDeclaration
 
                 if (!canAsk) {
                     return KotlinFindMemberUsagesHandler.getInstance(declaration, factory = this)
@@ -112,7 +112,7 @@ public class KotlinFindUsagesHandlerFactory(project: Project) : FindUsagesHandle
                 return handlerForMultiple(declaration, declarationsToSearch)
             }
 
-            is JetTypeParameter ->
+            is KtTypeParameter ->
                 return KotlinTypeParameterFindUsagesHandler(element, this)
 
             else ->
@@ -120,13 +120,13 @@ public class KotlinFindUsagesHandlerFactory(project: Project) : FindUsagesHandle
         }
     }
 
-    private fun handlerForMultiple(originalDeclaration: JetNamedDeclaration, declarations: Collection<PsiElement>): FindUsagesHandler {
+    private fun handlerForMultiple(originalDeclaration: KtNamedDeclaration, declarations: Collection<PsiElement>): FindUsagesHandler {
         return when (declarations.size()) {
             0 -> FindUsagesHandler.NULL_HANDLER
 
             1 -> {
                 val target = declarations.single().unwrapped ?: return FindUsagesHandler.NULL_HANDLER
-                if (target is JetNamedDeclaration) {
+                if (target is KtNamedDeclaration) {
                     KotlinFindMemberUsagesHandler.getInstance(target, factory = this)
                 }
                 else {
@@ -138,7 +138,7 @@ public class KotlinFindUsagesHandlerFactory(project: Project) : FindUsagesHandle
         }
     }
 
-    private fun askWhetherShouldSearchForParameterInOverridingMethods(parameter: JetParameter): Boolean {
+    private fun askWhetherShouldSearchForParameterInOverridingMethods(parameter: KtParameter): Boolean {
         return Messages.showOkCancelDialog(parameter.project,
                                            FindBundle.message("find.parameter.usages.in.overriding.methods.prompt", parameter.name),
                                            FindBundle.message("find.parameter.usages.in.overriding.methods.title"),
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinFindClassUsagesDialog.java b/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinFindClassUsagesDialog.java
index 0dd5cee2640..ab2e260104a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinFindClassUsagesDialog.java
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinFindClassUsagesDialog.java
@@ -35,8 +35,8 @@ import org.jetbrains.kotlin.asJava.LightClassUtilsKt;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.findUsages.KotlinClassFindUsagesOptions;
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil;
-import org.jetbrains.kotlin.psi.JetClass;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
+import org.jetbrains.kotlin.psi.KtClass;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
 import org.jetbrains.kotlin.psi.psiUtil.JetPsiUtilKt;
 
 import javax.swing.*;
@@ -47,7 +47,7 @@ public class KotlinFindClassUsagesDialog extends FindClassUsagesDialog {
     private StateRestoringCheckBox derivedTraits;
 
     public KotlinFindClassUsagesDialog(
-            JetClassOrObject classOrObject,
+            KtClassOrObject classOrObject,
             Project project,
             FindUsagesOptions findUsagesOptions,
             boolean toShowInNewTab,
@@ -58,10 +58,10 @@ public class KotlinFindClassUsagesDialog extends FindClassUsagesDialog {
         super(getRepresentingPsiClass(classOrObject), project, findUsagesOptions, toShowInNewTab, mustOpenInNewTab, isSingleFile, handler);
     }
 
-    private static final Key<JetClassOrObject> ORIGINAL_CLASS = Key.create("ORIGINAL_CLASS");
+    private static final Key<KtClassOrObject> ORIGINAL_CLASS = Key.create("ORIGINAL_CLASS");
 
     @NotNull
-    private static PsiClass getRepresentingPsiClass(@NotNull JetClassOrObject classOrObject) {
+    private static PsiClass getRepresentingPsiClass(@NotNull KtClassOrObject classOrObject) {
         PsiClass lightClass = LightClassUtil.INSTANCE$.getPsiClass(classOrObject);
         if (lightClass != null) return lightClass;
 
@@ -74,8 +74,8 @@ public class KotlinFindClassUsagesDialog extends FindClassUsagesDialog {
         }
 
         PsiClass javaClass;
-        if (classOrObject instanceof JetClass) {
-            JetClass klass = (JetClass) classOrObject;
+        if (classOrObject instanceof KtClass) {
+            KtClass klass = (KtClass) classOrObject;
             javaClass = !klass.isInterface()
                         ? factory.createClass(name)
                         : klass.isAnnotation()
@@ -90,7 +90,7 @@ public class KotlinFindClassUsagesDialog extends FindClassUsagesDialog {
         //noinspection ConstantConditions
         javaClass.getModifierList().setModifierProperty(
                 PsiModifier.FINAL,
-                !(classOrObject instanceof JetClass && JetPsiUtilKt.isInheritable((JetClass) classOrObject))
+                !(classOrObject instanceof KtClass && JetPsiUtilKt.isInheritable((KtClass) classOrObject))
         );
 
         javaClass.putUserData(ORIGINAL_CLASS, classOrObject);
@@ -148,8 +148,8 @@ public class KotlinFindClassUsagesDialog extends FindClassUsagesDialog {
     public void configureLabelComponent(@NotNull SimpleColoredComponent coloredComponent) {
         PsiElement klass = LightClassUtilsKt.getUnwrapped(getPsiElement());
         //noinspection ConstantConditions
-        JetClassOrObject originalClass = klass instanceof JetClassOrObject
-                                         ? (JetClassOrObject) klass
+        KtClassOrObject originalClass = klass instanceof KtClassOrObject
+                                         ? (KtClassOrObject) klass
                                          : klass.getUserData(ORIGINAL_CLASS);
 
         if (originalClass != null) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinFindPropertyUsagesDialog.java b/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinFindPropertyUsagesDialog.java
index e180048c0a1..aaa3b041ef6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinFindPropertyUsagesDialog.java
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinFindPropertyUsagesDialog.java
@@ -28,8 +28,8 @@ import com.intellij.ui.StateRestoringCheckBox;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.findUsages.KotlinPropertyFindUsagesOptions;
-import org.jetbrains.kotlin.lexer.JetTokens;
-import org.jetbrains.kotlin.psi.JetNamedDeclaration;
+import org.jetbrains.kotlin.lexer.KtTokens;
+import org.jetbrains.kotlin.psi.KtNamedDeclaration;
 
 import javax.swing.*;
 
@@ -95,17 +95,17 @@ public class KotlinFindPropertyUsagesDialog extends JavaFindUsagesDialog<KotlinP
 
     @Override
     public void configureLabelComponent(@NotNull SimpleColoredComponent coloredComponent) {
-        Utils.configureLabelComponent(coloredComponent, (JetNamedDeclaration) getPsiElement());
+        Utils.configureLabelComponent(coloredComponent, (KtNamedDeclaration) getPsiElement());
     }
 
     @Override
     protected void addUsagesOptions(JPanel optionsPanel) {
         super.addUsagesOptions(optionsPanel);
 
-        JetNamedDeclaration property = (JetNamedDeclaration) getPsiElement();
+        KtNamedDeclaration property = (KtNamedDeclaration) getPsiElement();
 
-        boolean isAbstract = property.hasModifier(JetTokens.ABSTRACT_KEYWORD);
-        boolean isOpen = property.hasModifier(JetTokens.OPEN_KEYWORD);
+        boolean isAbstract = property.hasModifier(KtTokens.ABSTRACT_KEYWORD);
+        boolean isOpen = property.hasModifier(KtTokens.OPEN_KEYWORD);
         if (isOpen || isAbstract) {
             cbOverrides = addCheckboxToPanel(
                     isAbstract
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinTypeParameterFindUsagesDialog.java b/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinTypeParameterFindUsagesDialog.java
index 8ee489a29b1..f9c4d0167dd 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinTypeParameterFindUsagesDialog.java
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinTypeParameterFindUsagesDialog.java
@@ -22,9 +22,9 @@ import com.intellij.find.findUsages.FindUsagesOptions;
 import com.intellij.openapi.project.Project;
 import com.intellij.ui.SimpleColoredComponent;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetNamedDeclaration;
+import org.jetbrains.kotlin.psi.KtNamedDeclaration;
 
-public class KotlinTypeParameterFindUsagesDialog<T extends JetNamedDeclaration> extends CommonFindUsagesDialog {
+public class KotlinTypeParameterFindUsagesDialog<T extends KtNamedDeclaration> extends CommonFindUsagesDialog {
     public KotlinTypeParameterFindUsagesDialog(
             T element,
             Project project,
@@ -39,6 +39,6 @@ public class KotlinTypeParameterFindUsagesDialog<T extends JetNamedDeclaration>
 
     @Override
     public void configureLabelComponent(@NotNull SimpleColoredComponent coloredComponent) {
-        Utils.configureLabelComponent(coloredComponent, (JetNamedDeclaration) myPsiElement);
+        Utils.configureLabelComponent(coloredComponent, (KtNamedDeclaration) myPsiElement);
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/Utils.java b/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/Utils.java
index 606b7968f6d..60c3709e506 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/Utils.java
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/Utils.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.findUsages.dialogs;
 import com.intellij.ui.SimpleColoredComponent;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.search.usagesSearch.UtilsKt;
-import org.jetbrains.kotlin.psi.JetNamedDeclaration;
+import org.jetbrains.kotlin.psi.KtNamedDeclaration;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 
 import javax.swing.*;
@@ -31,7 +31,7 @@ class Utils {
 
     public static void configureLabelComponent(
             @NotNull SimpleColoredComponent coloredComponent,
-            @NotNull JetNamedDeclaration declaration) {
+            @NotNull KtNamedDeclaration declaration) {
         coloredComponent.append(DescriptorRenderer.COMPACT.render(UtilsKt.getDescriptor(declaration)));
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/DelegatingFindMemberUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/DelegatingFindMemberUsagesHandler.kt
index 1c59d564e85..131515cad23 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/DelegatingFindMemberUsagesHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/DelegatingFindMemberUsagesHandler.kt
@@ -28,10 +28,10 @@ import com.intellij.usageView.UsageInfo
 import com.intellij.util.Processor
 import org.jetbrains.kotlin.idea.findUsages.*
 import org.jetbrains.kotlin.idea.util.application.runReadAction
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 
 class DelegatingFindMemberUsagesHandler(
-        val declaration: JetNamedDeclaration,
+        val declaration: KtNamedDeclaration,
         val elementsToSearch: Collection<PsiElement>,
         val factory: KotlinFindUsagesHandlerFactory
 ) : FindUsagesHandler(declaration) {
@@ -44,7 +44,7 @@ class DelegatingFindMemberUsagesHandler(
 
     private fun getHandlerAndOptions(element: PsiElement, options: FindUsagesOptions?): HandlerAndOptions? {
         return when (element) {
-            is JetNamedDeclaration ->
+            is KtNamedDeclaration ->
                 HandlerAndOptions(KotlinFindMemberUsagesHandler.getInstance(element, elementsToSearch, factory), options)
 
             is PsiMethod ->
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt
index b21d5e99b82..5bf9967c192 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt
@@ -56,9 +56,9 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ClassReceiver
 import java.util.*
 
 public class KotlinFindClassUsagesHandler(
-        jetClass: JetClassOrObject,
+        ktClass: KtClassOrObject,
         factory: KotlinFindUsagesHandlerFactory
-) : KotlinFindUsagesHandler<JetClassOrObject>(jetClass, factory) {
+) : KotlinFindUsagesHandler<KtClassOrObject>(ktClass, factory) {
     public override fun getFindUsagesDialog(
             isSingleFile: Boolean, toShowInNewTab: Boolean, mustOpenInNewTab: Boolean
     ): AbstractFindUsagesDialog {
@@ -92,7 +92,7 @@ public class KotlinFindClassUsagesHandler(
             )
         }
 
-        val classOrObject = element as JetClassOrObject
+        val classOrObject = element as KtClassOrObject
         val referenceProcessor = KotlinFindUsagesHandler.createReferenceProcessor(processor)
 
         if (kotlinOptions.isUsages || kotlinOptions.searchConstructorUsages) {
@@ -103,7 +103,7 @@ public class KotlinFindClassUsagesHandler(
             if (!processMemberReferences(classOrObject, kotlinOptions, referenceProcessor)) return false
         }
 
-        if (kotlinOptions.isUsages && classOrObject is JetObjectDeclaration && classOrObject.isCompanion()) {
+        if (kotlinOptions.isUsages && classOrObject is KtObjectDeclaration && classOrObject.isCompanion()) {
             if (!processCompanionObjectInternalReferences(classOrObject, referenceProcessor)) {
                 return false
             }
@@ -128,7 +128,7 @@ public class KotlinFindClassUsagesHandler(
         return true
     }
 
-    private fun processClassReferences(classOrObject: JetClassOrObject,
+    private fun processClassReferences(classOrObject: KtClassOrObject,
                                        options: KotlinClassFindUsagesOptions,
                                        processor: Processor<PsiReference>): Boolean {
         val searchParameters = KotlinReferencesSearchParameters(classOrObject,
@@ -149,14 +149,14 @@ public class KotlinFindClassUsagesHandler(
         return usagesQuery.forEach(processor)
     }
 
-    private fun processCompanionObjectInternalReferences(companionObject: JetObjectDeclaration,
+    private fun processCompanionObjectInternalReferences(companionObject: KtObjectDeclaration,
                                                          processor: Processor<PsiReference>): Boolean {
         var stop: Boolean = false
         runReadAction {
-            val klass = companionObject.getStrictParentOfType<JetClass>() ?: return@runReadAction
+            val klass = companionObject.getStrictParentOfType<KtClass>() ?: return@runReadAction
             val companionObjectDescriptor = companionObject.descriptor
-            klass.acceptChildren(object : JetVisitorVoid() {
-                override fun visitJetElement(element: JetElement) {
+            klass.acceptChildren(object : KtVisitorVoid() {
+                override fun visitJetElement(element: KtElement) {
                     if (element == companionObject) return // skip companion object itself
                     if (stop) return
                     element.acceptChildren(this)
@@ -177,12 +177,12 @@ public class KotlinFindClassUsagesHandler(
         return !stop
     }
 
-    private fun processMemberReferences(classOrObject: JetClassOrObject,
+    private fun processMemberReferences(classOrObject: KtClassOrObject,
                                         options: KotlinClassFindUsagesOptions,
                                         processor: Processor<PsiReference>): Boolean {
         for (decl in classOrObject.effectiveDeclarations()) {
-            if ((decl is JetNamedFunction && options.isMethodsUsages) ||
-                ((decl is JetProperty || decl is JetParameter) && options.isFieldsUsages)) {
+            if ((decl is KtNamedFunction && options.isMethodsUsages) ||
+                ((decl is KtProperty || decl is KtParameter) && options.isFieldsUsages)) {
                 if (!ReferencesSearch.search(decl, options.searchScope).forEach(processor)) return false
             }
         }
@@ -192,7 +192,7 @@ public class KotlinFindClassUsagesHandler(
     protected override fun getStringsToSearch(element: PsiElement): Collection<String> {
         val psiClass = when (element) {
                            is PsiClass -> element
-                           is JetClassOrObject -> LightClassUtil.getPsiClass(getElement())
+                           is KtClassOrObject -> LightClassUtil.getPsiClass(getElement())
                            else -> null
                        } ?: return Collections.emptyList()
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.kt
index 4c112d32839..0278d18b968 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.kt
@@ -42,16 +42,16 @@ import org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinReferencesSearchOpt
 import org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinReferencesSearchParameters
 import org.jetbrains.kotlin.idea.search.usagesSearch.isImportUsage
 import org.jetbrains.kotlin.idea.util.application.runReadAction
-import org.jetbrains.kotlin.psi.JetFunction
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 
-public abstract class KotlinFindMemberUsagesHandler<T : JetNamedDeclaration>
+public abstract class KotlinFindMemberUsagesHandler<T : KtNamedDeclaration>
     protected constructor(declaration: T, elementsToSearch: Collection<PsiElement>, factory: KotlinFindUsagesHandlerFactory)
     : KotlinFindUsagesHandler<T>(declaration, elementsToSearch, factory) {
 
-    private class Function(declaration: JetFunction,
+    private class Function(declaration: KtFunction,
                            elementsToSearch: Collection<PsiElement>,
-                           factory: KotlinFindUsagesHandlerFactory) : KotlinFindMemberUsagesHandler<JetFunction>(declaration, elementsToSearch, factory) {
+                           factory: KotlinFindUsagesHandlerFactory) : KotlinFindMemberUsagesHandler<KtFunction>(declaration, elementsToSearch, factory) {
 
         override fun getFindUsagesOptions(dataContext: DataContext?): FindUsagesOptions = factory.findFunctionOptions
 
@@ -79,7 +79,7 @@ public abstract class KotlinFindMemberUsagesHandler<T : JetNamedDeclaration>
         }
     }
 
-    private class Property(declaration: JetNamedDeclaration, elementsToSearch: Collection<PsiElement>, factory: KotlinFindUsagesHandlerFactory) : KotlinFindMemberUsagesHandler<JetNamedDeclaration>(declaration, elementsToSearch, factory) {
+    private class Property(declaration: KtNamedDeclaration, elementsToSearch: Collection<PsiElement>, factory: KotlinFindUsagesHandlerFactory) : KotlinFindMemberUsagesHandler<KtNamedDeclaration>(declaration, elementsToSearch, factory) {
 
         override fun getFindUsagesOptions(dataContext: DataContext?): FindUsagesOptions = factory.findPropertyOptions
 
@@ -133,7 +133,7 @@ public abstract class KotlinFindMemberUsagesHandler<T : JetNamedDeclaration>
 
             val psiMethods = when (element) {
                 is PsiMethod -> listOf(element)
-                is JetFunction -> runReadAction { LightClassUtil.getLightClassMethods(element) }
+                is KtFunction -> runReadAction { LightClassUtil.getLightClassMethods(element) }
                 else -> listOf<PsiMethod>()
             }
             for (psiMethod in psiMethods) {
@@ -161,10 +161,10 @@ public abstract class KotlinFindMemberUsagesHandler<T : JetNamedDeclaration>
 
     companion object {
 
-        public fun getInstance(declaration: JetNamedDeclaration,
+        public fun getInstance(declaration: KtNamedDeclaration,
                                elementsToSearch: Collection<PsiElement> = emptyList(),
-                               factory: KotlinFindUsagesHandlerFactory): KotlinFindMemberUsagesHandler<out JetNamedDeclaration> {
-            return if (declaration is JetFunction)
+                               factory: KotlinFindUsagesHandlerFactory): KotlinFindMemberUsagesHandler<out KtNamedDeclaration> {
+            return if (declaration is KtFunction)
                 Function(declaration, elementsToSearch, factory)
             else
                 Property(declaration, elementsToSearch, factory)
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinTypeParameterFindUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinTypeParameterFindUsagesHandler.kt
index a20de506ab4..680176fb597 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinTypeParameterFindUsagesHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinTypeParameterFindUsagesHandler.kt
@@ -25,16 +25,16 @@ import com.intellij.usageView.UsageInfo
 import com.intellij.util.Processor
 import org.jetbrains.kotlin.idea.findUsages.KotlinFindUsagesHandlerFactory
 import org.jetbrains.kotlin.idea.findUsages.dialogs.KotlinTypeParameterFindUsagesDialog
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 
 public class KotlinTypeParameterFindUsagesHandler(
-        element: JetNamedDeclaration,
+        element: KtNamedDeclaration,
         factory: KotlinFindUsagesHandlerFactory
-) : KotlinFindUsagesHandler<JetNamedDeclaration>(element, factory) {
+) : KotlinFindUsagesHandler<KtNamedDeclaration>(element, factory) {
     public override fun getFindUsagesDialog(
             isSingleFile: Boolean, toShowInNewTab: Boolean, mustOpenInNewTab: Boolean
     ): AbstractFindUsagesDialog {
-        return KotlinTypeParameterFindUsagesDialog<JetNamedDeclaration>(
+        return KotlinTypeParameterFindUsagesDialog<KtNamedDeclaration>(
                 getElement(), getProject(), getFindUsagesOptions(), toShowInNewTab, mustOpenInNewTab, isSingleFile, this
         )
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/formatter/JetBlock.java b/idea/src/org/jetbrains/kotlin/idea/formatter/JetBlock.java
index 3f5e14df613..49eb6e08cf7 100644
--- a/idea/src/org/jetbrains/kotlin/idea/formatter/JetBlock.java
+++ b/idea/src/org/jetbrains/kotlin/idea/formatter/JetBlock.java
@@ -33,17 +33,17 @@ import org.jetbrains.kotlin.idea.KotlinLanguage;
 import org.jetbrains.kotlin.idea.core.formatter.JetCodeStyleSettings;
 import org.jetbrains.kotlin.kdoc.lexer.KDocTokens;
 import org.jetbrains.kotlin.kdoc.parser.KDocElementTypes;
-import org.jetbrains.kotlin.lexer.JetTokens;
-import org.jetbrains.kotlin.psi.JetDeclaration;
+import org.jetbrains.kotlin.lexer.KtTokens;
+import org.jetbrains.kotlin.psi.KtDeclaration;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
-import static org.jetbrains.kotlin.JetNodeTypes.*;
+import static org.jetbrains.kotlin.KtNodeTypes.*;
 import static org.jetbrains.kotlin.idea.formatter.NodeIndentStrategy.strategy;
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
+import static org.jetbrains.kotlin.lexer.KtTokens.*;
 
 /**
  * @see Block for good JavaDoc documentation
@@ -172,7 +172,7 @@ public class JetBlock extends AbstractBlock {
 
     private static ASTNode getPrevWithoutWhitespaceAndComments(ASTNode node) {
         node = node.getTreePrev();
-        while (node != null && (node.getElementType() == TokenType.WHITE_SPACE || JetTokens.COMMENTS.contains(node.getElementType()))) {
+        while (node != null && (node.getElementType() == TokenType.WHITE_SPACE || KtTokens.COMMENTS.contains(node.getElementType()))) {
             node = node.getTreePrev();
         }
 
@@ -444,9 +444,9 @@ public class JetBlock extends AbstractBlock {
         }
 
         // do not indent child after heading comments inside declaration
-        if (childParent != null && childParent.getPsi() instanceof JetDeclaration) {
+        if (childParent != null && childParent.getPsi() instanceof KtDeclaration) {
             ASTNode prev = getPrevWithoutWhitespace(child);
-            if (prev != null && JetTokens.COMMENTS.contains(prev.getElementType()) && getPrevWithoutWhitespaceAndComments(prev) == null) {
+            if (prev != null && KtTokens.COMMENTS.contains(prev.getElementType()) && getPrevWithoutWhitespaceAndComments(prev) == null) {
                 return Indent.getNoneIndent();
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/formatter/KotlinSpacingBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/formatter/KotlinSpacingBuilder.kt
index c641e72ae88..2000302381a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/formatter/KotlinSpacingBuilder.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/formatter/KotlinSpacingBuilder.kt
@@ -24,9 +24,9 @@ import com.intellij.openapi.util.TextRange
 import com.intellij.psi.codeStyle.CodeStyleSettings
 import com.intellij.psi.formatter.common.AbstractBlock
 import com.intellij.psi.tree.IElementType
-import org.jetbrains.kotlin.JetNodeTypes
+import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.idea.KotlinLanguage
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import java.util.ArrayList
 
 class KotlinSpacingBuilder(val codeStyleSettings: CodeStyleSettings) {
@@ -118,8 +118,8 @@ class KotlinSpacingBuilder(val codeStyleSettings: CodeStyleSettings) {
 
             if (spacing != null) {
                 // TODO: it's a severe hack but I don't know how to implement it in other way
-                if (child1.getNode().getElementType() == JetTokens.EOL_COMMENT && spacing.toString().contains("minLineFeeds=0")) {
-                    val isBeforeBlock = child2.getNode().getElementType() == JetNodeTypes.BLOCK || child2.getNode().getFirstChildNode()?.getElementType() == JetNodeTypes.BLOCK
+                if (child1.getNode().getElementType() == KtTokens.EOL_COMMENT && spacing.toString().contains("minLineFeeds=0")) {
+                    val isBeforeBlock = child2.getNode().getElementType() == KtNodeTypes.BLOCK || child2.getNode().getFirstChildNode()?.getElementType() == KtNodeTypes.BLOCK
                     val keepBlankLines = if (isBeforeBlock) 0 else codeStyleSettings.KEEP_BLANK_LINES_IN_CODE
                     return Spacing.createSpacing(0, 0, 1, true, keepBlankLines)
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt b/idea/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt
index 97fb908f765..8af3a331fd0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt
@@ -25,12 +25,12 @@ import com.intellij.psi.codeStyle.CodeStyleSettings
 import com.intellij.psi.formatter.FormatterUtil
 import com.intellij.psi.tree.IElementType
 import com.intellij.psi.tree.TokenSet
-import org.jetbrains.kotlin.JetNodeTypes.*
+import org.jetbrains.kotlin.KtNodeTypes.*
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.core.formatter.JetCodeStyleSettings
 import org.jetbrains.kotlin.idea.formatter.KotlinSpacingBuilder.CustomSpacingBuilder
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.lexer.JetTokens.*
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.lexer.KtTokens.*
 
 val MODIFIERS_LIST_ENTRIES = TokenSet.orSet(TokenSet.create(ANNOTATION_ENTRY, ANNOTATION), MODIFIER_KEYWORDS)
 
@@ -64,7 +64,7 @@ fun createSpacingBuilder(settings: CodeStyleSettings): KotlinSpacingBuilder {
 
             val parameterWithDocCommentRule = {
                 parent: ASTBlock, left: ASTBlock, right: ASTBlock ->
-                if (right.getNode().getFirstChildNode().getElementType() == JetTokens.DOC_COMMENT) {
+                if (right.getNode().getFirstChildNode().getElementType() == KtTokens.DOC_COMMENT) {
                     Spacing.createSpacing(0, 0, 1, true, settings.KEEP_BLANK_LINES_IN_DECLARATIONS)
                 }
                 else {
diff --git a/idea/src/org/jetbrains/kotlin/idea/framework/JSFrameworkType.java b/idea/src/org/jetbrains/kotlin/idea/framework/JSFrameworkType.java
index 6d0c423ced5..5a6430e9f71 100644
--- a/idea/src/org/jetbrains/kotlin/idea/framework/JSFrameworkType.java
+++ b/idea/src/org/jetbrains/kotlin/idea/framework/JSFrameworkType.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.framework;
 import com.intellij.framework.FrameworkTypeEx;
 import com.intellij.framework.addSupport.FrameworkSupportInModuleProvider;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.idea.JetIcons;
+import org.jetbrains.kotlin.idea.KtIcons;
 
 import javax.swing.*;
 
@@ -47,6 +47,6 @@ public class JSFrameworkType extends FrameworkTypeEx {
     @NotNull
     @Override
     public Icon getIcon() {
-        return JetIcons.SMALL_LOGO_13;
+        return KtIcons.SMALL_LOGO_13;
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/framework/JSLibraryStdPresentationProvider.java b/idea/src/org/jetbrains/kotlin/idea/framework/JSLibraryStdPresentationProvider.java
index 7b927b762f5..c9dd74580b3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/framework/JSLibraryStdPresentationProvider.java
+++ b/idea/src/org/jetbrains/kotlin/idea/framework/JSLibraryStdPresentationProvider.java
@@ -23,7 +23,7 @@ import com.intellij.openapi.roots.libraries.LibraryPresentationProvider;
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.JetIcons;
+import org.jetbrains.kotlin.idea.KtIcons;
 import org.jetbrains.kotlin.utils.LibraryUtils;
 import org.jetbrains.kotlin.utils.PathUtil;
 
@@ -43,7 +43,7 @@ public class JSLibraryStdPresentationProvider extends LibraryPresentationProvide
     @Nullable
     @Override
     public Icon getIcon() {
-        return JetIcons.SMALL_LOGO_13;
+        return KtIcons.SMALL_LOGO_13;
     }
 
     @Nullable
diff --git a/idea/src/org/jetbrains/kotlin/idea/framework/JavaFrameworkType.java b/idea/src/org/jetbrains/kotlin/idea/framework/JavaFrameworkType.java
index efed3000c6b..005e95da5de 100644
--- a/idea/src/org/jetbrains/kotlin/idea/framework/JavaFrameworkType.java
+++ b/idea/src/org/jetbrains/kotlin/idea/framework/JavaFrameworkType.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.framework;
 import com.intellij.framework.FrameworkTypeEx;
 import com.intellij.framework.addSupport.FrameworkSupportInModuleProvider;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.idea.JetIcons;
+import org.jetbrains.kotlin.idea.KtIcons;
 
 import javax.swing.*;
 
@@ -47,6 +47,6 @@ public class JavaFrameworkType extends FrameworkTypeEx {
     @NotNull
     @Override
     public Icon getIcon() {
-        return JetIcons.SMALL_LOGO_13;
+        return KtIcons.SMALL_LOGO_13;
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/framework/JavaRuntimePresentationProvider.java b/idea/src/org/jetbrains/kotlin/idea/framework/JavaRuntimePresentationProvider.java
index ae013ee54b7..df650451a2a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/framework/JavaRuntimePresentationProvider.java
+++ b/idea/src/org/jetbrains/kotlin/idea/framework/JavaRuntimePresentationProvider.java
@@ -23,7 +23,7 @@ import com.intellij.openapi.roots.libraries.LibraryPresentationProvider;
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.JetIcons;
+import org.jetbrains.kotlin.idea.KtIcons;
 import org.jetbrains.kotlin.utils.LibraryUtils;
 import org.jetbrains.kotlin.utils.PathUtil;
 
@@ -43,7 +43,7 @@ public class JavaRuntimePresentationProvider extends LibraryPresentationProvider
     @Nullable
     @Override
     public Icon getIcon() {
-        return JetIcons.SMALL_LOGO_13;
+        return KtIcons.SMALL_LOGO_13;
     }
 
     @Nullable
diff --git a/idea/src/org/jetbrains/kotlin/idea/framework/KotlinModuleBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/framework/KotlinModuleBuilder.kt
index 50efe56e44c..01762714fa1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/framework/KotlinModuleBuilder.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/framework/KotlinModuleBuilder.kt
@@ -21,7 +21,7 @@ import com.intellij.ide.util.projectWizard.ModuleWizardStep
 import com.intellij.ide.util.projectWizard.SettingsStep
 import com.intellij.ide.util.projectWizard.WizardContext
 import com.intellij.openapi.roots.ui.configuration.ModulesProvider
-import org.jetbrains.kotlin.idea.JetIcons
+import org.jetbrains.kotlin.idea.KtIcons
 import org.jetbrains.kotlin.resolve.TargetPlatform
 
 public class KotlinModuleBuilder(
@@ -30,8 +30,8 @@ public class KotlinModuleBuilder(
     override fun getName() = builderName
     override fun getPresentableName() = builderName
     override fun getDescription() = builderDescription
-    override fun getBigIcon() = JetIcons.KOTLIN_LOGO_24
-    override fun getNodeIcon() = JetIcons.SMALL_LOGO
+    override fun getBigIcon() = KtIcons.KOTLIN_LOGO_24
+    override fun getNodeIcon() = KtIcons.SMALL_LOGO
     override fun getGroupName() = KotlinTemplatesFactory.KOTLIN_GROUP_NAME
     override fun createWizardSteps(wizardContext: WizardContext, modulesProvider: ModulesProvider) = ModuleWizardStep.EMPTY_ARRAY
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/framework/KotlinTemplatesFactory.kt b/idea/src/org/jetbrains/kotlin/idea/framework/KotlinTemplatesFactory.kt
index de1cff288e0..af4bb82fa7e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/framework/KotlinTemplatesFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/framework/KotlinTemplatesFactory.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.framework
 import com.intellij.ide.util.projectWizard.WizardContext
 import com.intellij.platform.ProjectTemplatesFactory
 import com.intellij.platform.templates.BuilderBasedTemplate
-import org.jetbrains.kotlin.idea.JetIcons
+import org.jetbrains.kotlin.idea.KtIcons
 import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 
@@ -29,7 +29,7 @@ public class KotlinTemplatesFactory : ProjectTemplatesFactory() {
     }
 
     override fun getGroups() = arrayOf(KOTLIN_GROUP_NAME)
-    override fun getGroupIcon(group: String) = JetIcons.SMALL_LOGO
+    override fun getGroupIcon(group: String) = KtIcons.SMALL_LOGO
 
     override fun createTemplates(group: String?, context: WizardContext?) =
             arrayOf(
diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/HierarchyUtils.java b/idea/src/org/jetbrains/kotlin/idea/hierarchy/HierarchyUtils.java
index 3205a18d27c..a4aeebf634e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/HierarchyUtils.java
+++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/HierarchyUtils.java
@@ -35,12 +35,12 @@ public class HierarchyUtils {
         public Boolean invoke(@Nullable PsiElement input) {
             return input instanceof PsiMethod ||
                    input instanceof PsiClass ||
-                   input instanceof JetFile ||
-                   input instanceof JetNamedFunction ||
-                   input instanceof JetSecondaryConstructor ||
-                   input instanceof JetObjectDeclaration ||
-                   (input instanceof JetClass && !((JetClass) input).isInterface()) ||
-                   input instanceof JetProperty;
+                   input instanceof KtFile ||
+                   input instanceof KtNamedFunction ||
+                   input instanceof KtSecondaryConstructor ||
+                   input instanceof KtObjectDeclaration ||
+                   (input instanceof KtClass && !((KtClass) input).isInterface()) ||
+                   input instanceof KtProperty;
         }
     };
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/KotlinTypeHierarchyProvider.java b/idea/src/org/jetbrains/kotlin/idea/hierarchy/KotlinTypeHierarchyProvider.java
index 45fa2d3fc62..675a05af545 100644
--- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/KotlinTypeHierarchyProvider.java
+++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/KotlinTypeHierarchyProvider.java
@@ -35,11 +35,11 @@ import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
 import org.jetbrains.kotlin.idea.decompiler.navigation.JetSourceNavigationHelper;
 import org.jetbrains.kotlin.idea.stubindex.JetClassShortNameIndex;
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collection;
 
@@ -62,24 +62,24 @@ public class KotlinTypeHierarchyProvider extends JavaTypeHierarchyProvider {
                 return target;
             }
 
-            if (target instanceof JetClassOrObject) {
-                return JetSourceNavigationHelper.getOriginalPsiClassOrCreateLightClass((JetClassOrObject) target);
+            if (target instanceof KtClassOrObject) {
+                return JetSourceNavigationHelper.getOriginalPsiClassOrCreateLightClass((KtClassOrObject) target);
             }
             // Factory methods
-            else if (target instanceof JetNamedFunction) {
-                JetNamedFunction function = (JetNamedFunction) target;
+            else if (target instanceof KtNamedFunction) {
+                KtNamedFunction function = (KtNamedFunction) target;
                 String functionName = function.getName();
                 FunctionDescriptor functionDescriptor = ResolutionUtils.analyze(function)
                         .get(BindingContext.FUNCTION, target);
                 if (functionDescriptor != null) {
-                    JetType type = functionDescriptor.getReturnType();
+                    KtType type = functionDescriptor.getReturnType();
                     if (type != null) {
                         String returnTypeText = DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(type);
                         if (returnTypeText.equals(functionName)) {
-                            Collection<JetClassOrObject> classOrObjects =
+                            Collection<KtClassOrObject> classOrObjects =
                                     JetClassShortNameIndex.getInstance().get(functionName, project, GlobalSearchScope.allScope(project));
                             if (classOrObjects.size() == 1) {
-                                JetClassOrObject classOrObject = classOrObjects.iterator().next();
+                                KtClassOrObject classOrObject = classOrObjects.iterator().next();
                                 return JetSourceNavigationHelper.getOriginalPsiClassOrCreateLightClass(classOrObject);
                             }
                         }
@@ -91,15 +91,15 @@ public class KotlinTypeHierarchyProvider extends JavaTypeHierarchyProvider {
             PsiElement element = file.findElementAt(offset);
             if (element == null) return null;
 
-            JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(element, JetClassOrObject.class);
+            KtClassOrObject classOrObject = PsiTreeUtil.getParentOfType(element, KtClassOrObject.class);
             if (classOrObject != null) {
                 return JetSourceNavigationHelper.getOriginalPsiClassOrCreateLightClass(classOrObject);
             }
         }
         else {
             PsiElement element = LangDataKeys.PSI_ELEMENT.getData(dataContext);
-            if (element instanceof JetClassOrObject) {
-                return JetSourceNavigationHelper.getOriginalPsiClassOrCreateLightClass((JetClassOrObject) element);
+            if (element instanceof KtClassOrObject) {
+                return JetSourceNavigationHelper.getOriginalPsiClassOrCreateLightClass((KtClassOrObject) element);
             }
         }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/CalleeReferenceVisitorBase.java b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/CalleeReferenceVisitorBase.java
index 735fe766734..79fb926cfee 100644
--- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/CalleeReferenceVisitorBase.java
+++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/CalleeReferenceVisitorBase.java
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 
-public abstract class CalleeReferenceVisitorBase extends JetTreeVisitorVoid {
+public abstract class CalleeReferenceVisitorBase extends KtTreeVisitorVoid {
     private final BindingContext bindingContext;
     private final boolean deepTraversal;
 
@@ -36,17 +36,17 @@ public abstract class CalleeReferenceVisitorBase extends JetTreeVisitorVoid {
         this.deepTraversal = deepTraversal;
     }
 
-    protected abstract void processDeclaration(JetSimpleNameExpression reference, PsiElement declaration);
+    protected abstract void processDeclaration(KtSimpleNameExpression reference, PsiElement declaration);
 
     @Override
-    public void visitJetElement(@NotNull JetElement element) {
-        if (deepTraversal || !(element instanceof JetClassOrObject || element instanceof JetNamedFunction)) {
+    public void visitJetElement(@NotNull KtElement element) {
+        if (deepTraversal || !(element instanceof KtClassOrObject || element instanceof KtNamedFunction)) {
             super.visitJetElement(element);
         }
     }
 
     @Override
-    public void visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression) {
+    public void visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression) {
         DeclarationDescriptor descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, expression);
         if (descriptor == null) return;
 
@@ -59,18 +59,18 @@ public abstract class CalleeReferenceVisitorBase extends JetTreeVisitorVoid {
     }
 
     // Accept callees of JetCallElement which refer to Kotlin function, Kotlin class or Java method
-    private static boolean isCallable(DeclarationDescriptor descriptor, PsiElement declaration, JetSimpleNameExpression reference) {
-        JetCallElement callElement = PsiTreeUtil.getParentOfType(reference, JetCallElement.class);
+    private static boolean isCallable(DeclarationDescriptor descriptor, PsiElement declaration, KtSimpleNameExpression reference) {
+        KtCallElement callElement = PsiTreeUtil.getParentOfType(reference, KtCallElement.class);
         if (callElement == null || !PsiTreeUtil.isAncestor(callElement.getCalleeExpression(), reference, false)) return false;
 
         return descriptor instanceof FunctionDescriptor
-                 && (declaration instanceof JetClassOrObject
-                     || declaration instanceof JetNamedFunction
+                 && (declaration instanceof KtClassOrObject
+                     || declaration instanceof KtNamedFunction
                      || declaration instanceof PsiMethod);
     }
 
     // Accept only properties (not local variables or references to Java fields)
     private static boolean isProperty(DeclarationDescriptor descriptor, PsiElement declaration) {
-        return descriptor instanceof PropertyDescriptor && declaration instanceof JetProperty;
+        return descriptor instanceof PropertyDescriptor && declaration instanceof KtProperty;
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyNodeDescriptor.java b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyNodeDescriptor.java
index cbe1d0c3a61..dcdf342a140 100644
--- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyNodeDescriptor.java
+++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyNodeDescriptor.java
@@ -123,8 +123,8 @@ public class KotlinCallHierarchyNodeDescriptor extends HierarchyNodeDescriptor i
         }
 
         String packageName = null;
-        if (targetElement instanceof JetElement) {
-            packageName = JetPsiUtil.getPackageName((JetElement) targetElement);
+        if (targetElement instanceof KtElement) {
+            packageName = KtPsiUtil.getPackageName((KtElement) targetElement);
         }
         else {
             PsiClass enclosingClass = PsiTreeUtil.getParentOfType(targetElement, PsiClass.class, false);
@@ -160,27 +160,27 @@ public class KotlinCallHierarchyNodeDescriptor extends HierarchyNodeDescriptor i
         String elementText;
         String containerText = null;
 
-        if (element instanceof JetFile) {
-            elementText = ((JetFile) element).getName();
+        if (element instanceof KtFile) {
+            elementText = ((KtFile) element).getName();
         }
-        else if (element instanceof JetNamedDeclaration) {
-            BindingContext bindingContext = ResolutionUtils.analyze((JetElement) element, BodyResolveMode.FULL);
+        else if (element instanceof KtNamedDeclaration) {
+            BindingContext bindingContext = ResolutionUtils.analyze((KtElement) element, BodyResolveMode.FULL);
 
             DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element);
             if (descriptor == null) return null;
 
-            if (element instanceof JetClassOrObject) {
-                if (element instanceof JetObjectDeclaration && ((JetObjectDeclaration) element).isCompanion()) {
+            if (element instanceof KtClassOrObject) {
+                if (element instanceof KtObjectDeclaration && ((KtObjectDeclaration) element).isCompanion()) {
                     descriptor = descriptor.getContainingDeclaration();
                     if (!(descriptor instanceof ClassDescriptor)) return null;
 
                     elementText = renderClassOrObject((ClassDescriptor) descriptor);
                 }
-                else if (element instanceof JetEnumEntry) {
-                    elementText = ((JetEnumEntry) element).getName();
+                else if (element instanceof KtEnumEntry) {
+                    elementText = ((KtEnumEntry) element).getName();
                 }
                 else {
-                    if (((JetClassOrObject) element).getName() != null) {
+                    if (((KtClassOrObject) element).getName() != null) {
                         elementText = renderClassOrObject((ClassDescriptor) descriptor);
                     }
                     else {
@@ -188,11 +188,11 @@ public class KotlinCallHierarchyNodeDescriptor extends HierarchyNodeDescriptor i
                     }
                 }
             }
-            else if (element instanceof JetNamedFunction || element instanceof JetSecondaryConstructor) {
+            else if (element instanceof KtNamedFunction || element instanceof KtSecondaryConstructor) {
                 elementText = renderNamedFunction((FunctionDescriptor) descriptor);
             }
-            else if (element instanceof JetProperty) {
-                elementText = ((JetProperty) element).getName();
+            else if (element instanceof KtProperty) {
+                elementText = ((KtProperty) element).getName();
             }
             else return null;
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyProvider.java b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyProvider.java
index a29816d3545..06e79fcf6f1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyProvider.java
+++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyProvider.java
@@ -30,7 +30,7 @@ import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.hierarchy.HierarchyUtils;
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 
 public class KotlinCallHierarchyProvider implements HierarchyProvider {
     @Override
@@ -42,7 +42,7 @@ public class KotlinCallHierarchyProvider implements HierarchyProvider {
         if (element == null) return null;
 
         element = HierarchyUtils.getCallHierarchyElement(element);
-        if (element instanceof JetFile) return null;
+        if (element instanceof KtFile) return null;
 
         return element;
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallTreeStructure.java b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallTreeStructure.java
index f803de41b6b..0a65b14e5b9 100644
--- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallTreeStructure.java
+++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallTreeStructure.java
@@ -43,9 +43,9 @@ public abstract class KotlinCallTreeStructure extends HierarchyTreeStructure {
         this.scopeType = scopeType;
     }
 
-    protected static JetElement getEnclosingElementForLocalDeclaration(PsiElement element) {
-        return element instanceof JetNamedDeclaration
-                                   ? JetPsiUtil.getEnclosingElementForLocalDeclaration((JetNamedDeclaration) element)
+    protected static KtElement getEnclosingElementForLocalDeclaration(PsiElement element) {
+        return element instanceof KtNamedDeclaration
+                                   ? KtPsiUtil.getEnclosingElementForLocalDeclaration((KtNamedDeclaration) element)
                                    : null;
     }
 
@@ -53,7 +53,7 @@ public abstract class KotlinCallTreeStructure extends HierarchyTreeStructure {
             Project project, PsiElement element, HierarchyNodeDescriptor parent, boolean navigateToReference
     ) {
         boolean root = (parent == null);
-        return element instanceof JetElement
+        return element instanceof KtElement
                ? new KotlinCallHierarchyNodeDescriptor(project, parent, element, root, navigateToReference)
                : new CallHierarchyNodeDescriptor(project, parent, element, root, navigateToReference);
     }
@@ -68,8 +68,8 @@ public abstract class KotlinCallTreeStructure extends HierarchyTreeStructure {
         @Override
         public Boolean invoke(@javax.annotation.Nullable PsiElement input) {
             return input instanceof PsiMethod
-                   || ((input instanceof JetNamedFunction || input instanceof JetClassOrObject || input instanceof JetProperty)
-                       && !JetPsiUtil.isLocal((JetNamedDeclaration) input));
+                   || ((input instanceof KtNamedFunction || input instanceof KtClassOrObject || input instanceof KtProperty)
+                       && !KtPsiUtil.isLocal((KtNamedDeclaration) input));
         }
     };
 
@@ -91,18 +91,18 @@ public abstract class KotlinCallTreeStructure extends HierarchyTreeStructure {
             return (PsiMethod) element;
         }
 
-        if (element instanceof JetNamedFunction || element instanceof JetSecondaryConstructor) {
-            return LightClassUtil.INSTANCE$.getLightClassMethod((JetFunction) element);
+        if (element instanceof KtNamedFunction || element instanceof KtSecondaryConstructor) {
+            return LightClassUtil.INSTANCE$.getLightClassMethod((KtFunction) element);
         }
 
-        if (element instanceof JetProperty) {
+        if (element instanceof KtProperty) {
             LightClassUtil.PropertyAccessorsPsiMethods propertyMethods =
-                    LightClassUtil.INSTANCE$.getLightClassPropertyMethods((JetProperty) element);
+                    LightClassUtil.INSTANCE$.getLightClassPropertyMethods((KtProperty) element);
             return (propertyMethods.getGetter() != null) ? propertyMethods.getGetter() : propertyMethods.getSetter();
         }
 
-        if (element instanceof JetClassOrObject) {
-            PsiClass psiClass = LightClassUtil.INSTANCE$.getPsiClass((JetClassOrObject) element);
+        if (element instanceof KtClassOrObject) {
+            PsiClass psiClass = LightClassUtil.INSTANCE$.getPsiClass((KtClassOrObject) element);
             if (psiClass == null) return null;
 
             PsiMethod[] constructors = psiClass.getConstructors();
diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCalleeMethodsTreeStructure.java b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCalleeMethodsTreeStructure.java
index 6e7b61cf074..a1fcabbd355 100644
--- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCalleeMethodsTreeStructure.java
+++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCalleeMethodsTreeStructure.java
@@ -50,35 +50,35 @@ public class KotlinCalleeMethodsTreeStructure extends KotlinCallTreeStructure {
         this.javaTreeStructure = new CalleeMethodsTreeStructure(project, representativePsiMethod, scopeType);
     }
 
-    private static Map<PsiReference, PsiElement> getReferencesToCalleeElements(@NotNull JetElement rootElement) {
-        List<JetElement> elementsToAnalyze = new ArrayList<JetElement>();
-        if (rootElement instanceof JetNamedFunction) {
-            elementsToAnalyze.add(((JetNamedFunction) rootElement).getBodyExpression());
-        } else if (rootElement instanceof JetProperty) {
-            for (JetPropertyAccessor accessor : ((JetProperty) rootElement).getAccessors()) {
-                JetExpression body = accessor.getBodyExpression();
+    private static Map<PsiReference, PsiElement> getReferencesToCalleeElements(@NotNull KtElement rootElement) {
+        List<KtElement> elementsToAnalyze = new ArrayList<KtElement>();
+        if (rootElement instanceof KtNamedFunction) {
+            elementsToAnalyze.add(((KtNamedFunction) rootElement).getBodyExpression());
+        } else if (rootElement instanceof KtProperty) {
+            for (KtPropertyAccessor accessor : ((KtProperty) rootElement).getAccessors()) {
+                KtExpression body = accessor.getBodyExpression();
                 if (body != null) {
                     elementsToAnalyze.add(body);
                 }
             }
         } else {
-            JetClassOrObject classOrObject = (JetClassOrObject) rootElement;
-            for (JetDelegationSpecifier specifier : classOrObject.getDelegationSpecifiers()) {
-                if (specifier instanceof JetCallElement) {
+            KtClassOrObject classOrObject = (KtClassOrObject) rootElement;
+            for (KtDelegationSpecifier specifier : classOrObject.getDelegationSpecifiers()) {
+                if (specifier instanceof KtCallElement) {
                     elementsToAnalyze.add(specifier);
                 }
             }
 
-            JetClassBody body = classOrObject.getBody();
+            KtClassBody body = classOrObject.getBody();
             if (body != null) {
-                for (JetClassInitializer initializer : body.getAnonymousInitializers()) {
-                    JetExpression initializerBody = initializer.getBody();
+                for (KtClassInitializer initializer : body.getAnonymousInitializers()) {
+                    KtExpression initializerBody = initializer.getBody();
                     if (initializerBody != null) {
                         elementsToAnalyze.add(initializerBody);
                     }
                 }
-                for (JetProperty property : body.getProperties()) {
-                    JetExpression initializer = property.getInitializer();
+                for (KtProperty property : body.getProperties()) {
+                    KtExpression initializer = property.getInitializer();
                     if (initializer != null) {
                         elementsToAnalyze.add(initializer);
                     }
@@ -87,11 +87,11 @@ public class KotlinCalleeMethodsTreeStructure extends KotlinCallTreeStructure {
         }
 
         final Map<PsiReference, PsiElement> referencesToCalleeElements = new HashMap<PsiReference, PsiElement>();
-        for (JetElement element : elementsToAnalyze) {
+        for (KtElement element : elementsToAnalyze) {
             element.accept(
                     new CalleeReferenceVisitorBase(ResolutionUtils.analyze(element, BodyResolveMode.FULL), false) {
                         @Override
-                        protected void processDeclaration(JetSimpleNameExpression reference, PsiElement declaration) {
+                        protected void processDeclaration(KtSimpleNameExpression reference, PsiElement declaration) {
                             referencesToCalleeElements.put(ReferenceUtilKt.getMainReference(reference), declaration);
                         }
                     }
@@ -112,8 +112,8 @@ public class KotlinCalleeMethodsTreeStructure extends KotlinCallTreeStructure {
             if (psiMethod.isConstructor()) {
                 PsiClass psiClass = psiMethod.getContainingClass();
                 PsiElement navigationElement = psiClass != null ? psiClass.getNavigationElement() : null;
-                if (navigationElement instanceof JetClass) {
-                    return buildChildrenByKotlinTarget(descriptor, (JetElement) navigationElement);
+                if (navigationElement instanceof KtClass) {
+                    return buildChildrenByKotlinTarget(descriptor, (KtElement) navigationElement);
                 }
             }
         }
@@ -123,8 +123,8 @@ public class KotlinCalleeMethodsTreeStructure extends KotlinCallTreeStructure {
             return buildChildrenByKotlinTarget(descriptor, ((KotlinLightMethod) targetElement).getOrigin());
         }
 
-        if (targetElement instanceof JetElement) {
-            return buildChildrenByKotlinTarget(descriptor, (JetElement) targetElement);
+        if (targetElement instanceof KtElement) {
+            return buildChildrenByKotlinTarget(descriptor, (KtElement) targetElement);
         }
 
         CallHierarchyNodeDescriptor javaDescriptor = descriptor instanceof CallHierarchyNodeDescriptor
@@ -133,7 +133,7 @@ public class KotlinCalleeMethodsTreeStructure extends KotlinCallTreeStructure {
         return javaTreeStructure.getChildElements(javaDescriptor);
     }
 
-    private Object[] buildChildrenByKotlinTarget(HierarchyNodeDescriptor descriptor, JetElement targetElement) {
+    private Object[] buildChildrenByKotlinTarget(HierarchyNodeDescriptor descriptor, KtElement targetElement) {
         Map<PsiReference, PsiElement> referencesToCalleeElements = getReferencesToCalleeElements(targetElement);
         return collectNodeDescriptors(descriptor, referencesToCalleeElements, representativePsiClass);
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallerMethodsTreeStructure.java b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallerMethodsTreeStructure.java
index db18ced80b5..3821164cba5 100644
--- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallerMethodsTreeStructure.java
+++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallerMethodsTreeStructure.java
@@ -38,7 +38,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.asJava.LightClassUtil;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
 import org.jetbrains.kotlin.idea.hierarchy.HierarchyUtils;
-import org.jetbrains.kotlin.idea.references.JetReference;
+import org.jetbrains.kotlin.idea.references.KtReference;
 import org.jetbrains.kotlin.idea.references.ReferenceUtilKt;
 import org.jetbrains.kotlin.idea.search.usagesSearch.UtilsKt;
 import org.jetbrains.kotlin.psi.*;
@@ -66,23 +66,23 @@ public class KotlinCallerMethodsTreeStructure extends KotlinCallTreeStructure {
     protected Object[] buildChildren(@NotNull HierarchyNodeDescriptor descriptor) {
         final PsiElement element = getTargetElement(descriptor);
 
-        JetElement codeBlockForLocalDeclaration = getEnclosingElementForLocalDeclaration(element);
+        KtElement codeBlockForLocalDeclaration = getEnclosingElementForLocalDeclaration(element);
         if (codeBlockForLocalDeclaration != null) {
-            BindingContext bindingContext = ResolutionUtils.analyze((JetElement) element, BodyResolveMode.FULL);
+            BindingContext bindingContext = ResolutionUtils.analyze((KtElement) element, BodyResolveMode.FULL);
 
             final Map<PsiReference, PsiElement> referencesToElements = new HashMap<PsiReference, PsiElement>();
             codeBlockForLocalDeclaration.accept(new CalleeReferenceVisitorBase(bindingContext, true) {
                 @Override
-                protected void processDeclaration(JetSimpleNameExpression reference, PsiElement declaration) {
+                protected void processDeclaration(KtSimpleNameExpression reference, PsiElement declaration) {
                     if (!declaration.equals(element)) return;
 
                     //noinspection unchecked
                     PsiElement container = PsiTreeUtil.getParentOfType(
                             reference,
-                            JetNamedFunction.class, JetPropertyAccessor.class, JetClassOrObject.class
+                            KtNamedFunction.class, KtPropertyAccessor.class, KtClassOrObject.class
                     );
-                    if (container instanceof JetPropertyAccessor) {
-                        container = PsiTreeUtil.getParentOfType(container, JetProperty.class);
+                    if (container instanceof KtPropertyAccessor) {
+                        container = PsiTreeUtil.getParentOfType(container, KtProperty.class);
                     }
 
                     if (container != null) {
@@ -103,23 +103,23 @@ public class KotlinCallerMethodsTreeStructure extends KotlinCallTreeStructure {
                     Collections.singleton((PsiMethod) element), descriptor, methodToDescriptorMap, searchScope, true
             );
         }
-        if (element instanceof JetNamedFunction || element instanceof JetSecondaryConstructor) {
-            Collection<PsiMethod> lightMethods = LightClassUtil.INSTANCE$.getLightClassMethods((JetFunction) element);
+        if (element instanceof KtNamedFunction || element instanceof KtSecondaryConstructor) {
+            Collection<PsiMethod> lightMethods = LightClassUtil.INSTANCE$.getLightClassMethods((KtFunction) element);
             processPsiMethodCallers(lightMethods, descriptor, methodToDescriptorMap, searchScope, false);
         }
-        if (element instanceof JetProperty) {
+        if (element instanceof KtProperty) {
             LightClassUtil.PropertyAccessorsPsiMethods propertyMethods =
-                    LightClassUtil.INSTANCE$.getLightClassPropertyMethods((JetProperty) element);
+                    LightClassUtil.INSTANCE$.getLightClassPropertyMethods((KtProperty) element);
             processPsiMethodCallers(propertyMethods, descriptor, methodToDescriptorMap, searchScope, false);
         }
-        if (element instanceof JetClassOrObject) {
-            JetPrimaryConstructor constructor = ((JetClassOrObject) element).getPrimaryConstructor();
+        if (element instanceof KtClassOrObject) {
+            KtPrimaryConstructor constructor = ((KtClassOrObject) element).getPrimaryConstructor();
             if (constructor != null) {
                 PsiMethod lightMethod = LightClassUtil.INSTANCE$.getLightClassMethod(constructor);
                 processPsiMethodCallers(Collections.singleton(lightMethod), descriptor, methodToDescriptorMap, searchScope, false);
             }
             else {
-                processJetClassOrObjectCallers((JetClassOrObject) element, descriptor, methodToDescriptorMap, searchScope);
+                processJetClassOrObjectCallers((KtClassOrObject) element, descriptor, methodToDescriptorMap, searchScope);
             }
         }
 
@@ -165,7 +165,7 @@ public class KotlinCallerMethodsTreeStructure extends KotlinCallTreeStructure {
     }
 
     private void processJetClassOrObjectCallers(
-            final JetClassOrObject classOrObject,
+            final KtClassOrObject classOrObject,
             HierarchyNodeDescriptor descriptor,
             Map<PsiElement, HierarchyNodeDescriptor> methodToDescriptorMap,
             SearchScope searchScope
@@ -205,7 +205,7 @@ public class KotlinCallerMethodsTreeStructure extends KotlinCallTreeStructure {
         @Override
         public boolean processInReadAction(PsiReference ref) {
             // copied from Java
-            if (!(ref instanceof PsiReferenceExpression || ref instanceof JetReference)) {
+            if (!(ref instanceof PsiReferenceExpression || ref instanceof KtReference)) {
                 if (!(ref instanceof PsiElement)) {
                     return true;
                 }
@@ -232,15 +232,15 @@ public class KotlinCallerMethodsTreeStructure extends KotlinCallTreeStructure {
             }
 
             PsiElement refElement = ref.getElement();
-            if (PsiTreeUtil.getParentOfType(refElement, JetImportDirective.class, true) != null) return true;
+            if (PsiTreeUtil.getParentOfType(refElement, KtImportDirective.class, true) != null) return true;
 
             PsiElement element = HierarchyUtils.getCallHierarchyElement(refElement);
 
-            if (kotlinOnly && !(element instanceof JetNamedDeclaration)) return true;
+            if (kotlinOnly && !(element instanceof KtNamedDeclaration)) return true;
 
             // If reference belongs to property initializer, show enclosing declaration instead
-            if (element instanceof JetProperty) {
-                JetProperty property = (JetProperty) element;
+            if (element instanceof KtProperty) {
+                KtProperty property = (KtProperty) element;
                 if (PsiTreeUtil.isAncestor(property.getInitializer(), refElement, false)) {
                     element = HierarchyUtils.getCallHierarchyElement(element.getParent());
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/overrides/KotlinOverrideHierarchyBrowser.kt b/idea/src/org/jetbrains/kotlin/idea/hierarchy/overrides/KotlinOverrideHierarchyBrowser.kt
index 999fa32a2cd..5dce0d471b0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/overrides/KotlinOverrideHierarchyBrowser.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/overrides/KotlinOverrideHierarchyBrowser.kt
@@ -29,7 +29,7 @@ import com.intellij.psi.PsiMethod
 import com.intellij.psi.ElementDescriptionUtil
 import com.intellij.refactoring.util.RefactoringDescriptionLocation
 import com.intellij.usageView.UsageViewLongNameLocation
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.asJava.unwrapped
 
 class KotlinOverrideHierarchyBrowser(
@@ -57,7 +57,7 @@ class KotlinOverrideHierarchyBrowser(
 
     override fun getContentDisplayName(typeName: String, element: PsiElement): String? {
         val targetElement = element.unwrapped
-        if (targetElement is JetDeclaration) {
+        if (targetElement is KtDeclaration) {
             return ElementDescriptionUtil.getElementDescription(targetElement, UsageViewLongNameLocation.INSTANCE)
         }
         return super.getContentDisplayName(typeName, element)
diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/overrides/KotlinOverrideHierarchyProvider.kt b/idea/src/org/jetbrains/kotlin/idea/hierarchy/overrides/KotlinOverrideHierarchyProvider.kt
index cdcb8fcfd84..29b318736ba 100644
--- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/overrides/KotlinOverrideHierarchyProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/overrides/KotlinOverrideHierarchyProvider.kt
@@ -25,8 +25,8 @@ import com.intellij.openapi.actionSystem.DataContext
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiMethod
 import org.jetbrains.kotlin.idea.hierarchy.HierarchyUtils
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypesAndPredicate
 
 public class KotlinOverrideHierarchyProvider: HierarchyProvider {
@@ -48,4 +48,4 @@ public class KotlinOverrideHierarchyProvider: HierarchyProvider {
 }
 
 fun PsiElement.isOverrideHierarchyElement(): Boolean
-        = this is PsiMethod || this is JetNamedFunction || this is JetProperty
+        = this is PsiMethod || this is KtNamedFunction || this is KtProperty
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/ErrorDuringFileAnalyzeNotificationProvider.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/ErrorDuringFileAnalyzeNotificationProvider.kt
index 9d4947f33c6..951b2957396 100644
--- a/idea/src/org/jetbrains/kotlin/idea/highlighter/ErrorDuringFileAnalyzeNotificationProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/ErrorDuringFileAnalyzeNotificationProvider.kt
@@ -21,10 +21,10 @@ import com.intellij.ui.EditorNotificationPanel
 import com.intellij.openapi.util.Key
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.fileEditor.FileEditor
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import com.intellij.psi.PsiManager
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import com.intellij.icons.AllIcons
 import com.intellij.ide.actions.ActivateToolWindowAction
 import com.intellij.notification.EventLog
@@ -32,7 +32,7 @@ import com.intellij.notification.EventLog
 private val ERROR_HIGHLIGHT_PANEL_KEY = Key.create<EditorNotificationPanel>("kotlin.error.highlight.panel.key")
 private val HAS_ERRORS_IN_HIGHLIHTING_KEY = Key.create<Boolean>("kotlin.has.errors.in.higlighting.key")
 
-fun updateHighlightingResult(file: JetFile, hasErrors: Boolean) {
+fun updateHighlightingResult(file: KtFile, hasErrors: Boolean) {
     if (hasErrors != file.getUserData(HAS_ERRORS_IN_HIGHLIHTING_KEY)) {
         file.putUserData(HAS_ERRORS_IN_HIGHLIHTING_KEY, hasErrors)
 
@@ -55,13 +55,13 @@ public class ErrorDuringFileAnalyzeNotificationProvider(val project: Project) :
     override fun getKey() = ERROR_HIGHLIGHT_PANEL_KEY
 
     override fun createNotificationPanel(file: VirtualFile, fileEditor: FileEditor): EditorNotificationPanel? {
-        if (file.getFileType() != JetFileType.INSTANCE) {
+        if (file.getFileType() != KotlinFileType.INSTANCE) {
             return null
         }
 
         val psiFile = PsiManager.getInstance(project).findFile(file) ?: return null
 
-        if (psiFile !is JetFile) {
+        if (psiFile !is KtFile) {
             return null
         }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/JetPsiCheckerAndHighlightingUpdater.java b/idea/src/org/jetbrains/kotlin/idea/highlighter/JetPsiCheckerAndHighlightingUpdater.java
index 61fd486ede9..6439fe8034e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/highlighter/JetPsiCheckerAndHighlightingUpdater.java
+++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/JetPsiCheckerAndHighlightingUpdater.java
@@ -21,31 +21,31 @@ import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.inspections.UnusedSymbolInspection;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
-import org.jetbrains.kotlin.psi.JetParameter;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
+import org.jetbrains.kotlin.psi.KtParameter;
 
 public class JetPsiCheckerAndHighlightingUpdater extends JetPsiChecker {
     @Override
     public void annotate(@NotNull PsiElement element, @NotNull AnnotationHolder holder) {
         try {
             super.annotate(element, holder);
-            if (element instanceof JetFile) {
+            if (element instanceof KtFile) {
                 //noinspection StaticMethodReferencedViaSubclass
-                ErrorDuringFileAnalyzeNotificationProviderKt.updateHighlightingResult((JetFile) element, false);
+                ErrorDuringFileAnalyzeNotificationProviderKt.updateHighlightingResult((KtFile) element, false);
             }
         }
         catch (ProcessCanceledException e) {
-            ErrorDuringFileAnalyzeNotificationProviderKt.updateHighlightingResult((JetFile)element.getContainingFile(), false);
+            ErrorDuringFileAnalyzeNotificationProviderKt.updateHighlightingResult((KtFile)element.getContainingFile(), false);
             throw e;
         }
     }
 
     @Override
-    protected boolean shouldSuppressUnusedParameter(@NotNull JetParameter parameter) {
+    protected boolean shouldSuppressUnusedParameter(@NotNull KtParameter parameter) {
         PsiElement grandParent = parameter.getParent().getParent();
-        if (grandParent instanceof JetNamedFunction) {
-            JetNamedFunction function = (JetNamedFunction) grandParent;
+        if (grandParent instanceof KtNamedFunction) {
+            KtNamedFunction function = (KtNamedFunction) grandParent;
             return UnusedSymbolInspection.Companion.isEntryPoint(function);
         }
         return false;
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinColorSettingsPage.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinColorSettingsPage.kt
index 153d2311623..70b4de5b192 100644
--- a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinColorSettingsPage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinColorSettingsPage.kt
@@ -23,7 +23,7 @@ import com.intellij.openapi.options.colors.AttributesDescriptor
 import com.intellij.openapi.options.colors.ColorDescriptor
 import com.intellij.openapi.options.colors.ColorSettingsPage
 import org.jetbrains.kotlin.idea.JetBundle
-import org.jetbrains.kotlin.idea.JetIcons
+import org.jetbrains.kotlin.idea.KtIcons
 import org.jetbrains.kotlin.idea.KotlinLanguage
 
 import javax.swing.*
@@ -32,7 +32,7 @@ import java.lang.reflect.Modifier
 import java.util.HashMap
 
 public class KotlinColorSettingsPage : ColorSettingsPage {
-    override fun getIcon() = JetIcons.SMALL_LOGO
+    override fun getIcon() = KtIcons.SMALL_LOGO
     override fun getHighlighter(): SyntaxHighlighter = JetHighlighter()
 
     override fun getDemoText(): String {
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinHighlightExitPointsHandlerFactory.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinHighlightExitPointsHandlerFactory.kt
index 5602581d7d4..0b943556e4b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinHighlightExitPointsHandlerFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinHighlightExitPointsHandlerFactory.kt
@@ -27,7 +27,7 @@ import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.util.Consumer
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.references.mainReference
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
@@ -37,15 +37,15 @@ import org.jetbrains.kotlin.resolve.inline.InlineUtil
 
 public class KotlinHighlightExitPointsHandlerFactory: HighlightUsagesHandlerFactoryBase() {
     companion object {
-        private val RETURN_AND_THROW = TokenSet.create(JetTokens.RETURN_KEYWORD, JetTokens.THROW_KEYWORD)
+        private val RETURN_AND_THROW = TokenSet.create(KtTokens.RETURN_KEYWORD, KtTokens.THROW_KEYWORD)
     }
 
     override fun createHighlightUsagesHandler(editor: Editor, file: PsiFile, target: PsiElement): HighlightUsagesHandlerBase<*>? {
         if (target is LeafPsiElement && (target.getElementType() in RETURN_AND_THROW)) {
-            val returnOrThrow = PsiTreeUtil.getParentOfType<JetExpression>(
+            val returnOrThrow = PsiTreeUtil.getParentOfType<KtExpression>(
                     target,
-                    javaClass<JetReturnExpression>(),
-                    javaClass<JetThrowExpression>()
+                    javaClass<KtReturnExpression>(),
+                    javaClass<KtThrowExpression>()
             ) ?: return null
 
             return MyHandler(editor, file, returnOrThrow)
@@ -53,7 +53,7 @@ public class KotlinHighlightExitPointsHandlerFactory: HighlightUsagesHandlerFact
         return null
     }
 
-    private class MyHandler(editor: Editor, file: PsiFile, val target: JetExpression) : HighlightUsagesHandlerBase<PsiElement>(editor, file) {
+    private class MyHandler(editor: Editor, file: PsiFile, val target: KtExpression) : HighlightUsagesHandlerBase<PsiElement>(editor, file) {
         override fun getTargets() = listOf(target)
 
         override fun selectTargets(targets: MutableList<PsiElement>, selectionConsumer: Consumer<MutableList<PsiElement>>) {
@@ -62,22 +62,22 @@ public class KotlinHighlightExitPointsHandlerFactory: HighlightUsagesHandlerFact
 
         override fun computeUsages(targets: MutableList<PsiElement>?) {
             val relevantFunction = target.getRelevantFunction()
-            relevantFunction?.accept(object : JetVisitorVoid() {
-                override fun visitJetElement(element: JetElement) {
+            relevantFunction?.accept(object : KtVisitorVoid() {
+                override fun visitJetElement(element: KtElement) {
                     element.acceptChildren(this)
                 }
 
-                private fun visitReturnOrThrow(expression: JetExpression) {
+                private fun visitReturnOrThrow(expression: KtExpression) {
                     if (expression.getRelevantFunction() == relevantFunction) {
                         addOccurrence(expression)
                     }
                 }
 
-                override fun visitReturnExpression(expression: JetReturnExpression) {
+                override fun visitReturnExpression(expression: KtReturnExpression) {
                     visitReturnOrThrow(expression)
                 }
 
-                override fun visitThrowExpression(expression: JetThrowExpression) {
+                override fun visitThrowExpression(expression: KtThrowExpression) {
                     visitReturnOrThrow(expression)
                 }
             })
@@ -85,13 +85,13 @@ public class KotlinHighlightExitPointsHandlerFactory: HighlightUsagesHandlerFact
     }
 }
 
-private fun JetExpression.getRelevantFunction(): JetFunction? {
-    if (this is JetReturnExpression) {
-        (this.getTargetLabel()?.mainReference?.resolve() as? JetFunction)?.let { return it }
+private fun KtExpression.getRelevantFunction(): KtFunction? {
+    if (this is KtReturnExpression) {
+        (this.getTargetLabel()?.mainReference?.resolve() as? KtFunction)?.let { return it }
     }
     for (parent in parents) {
-        if (InlineUtil.canBeInlineArgument(parent) && !InlineUtil.isInlinedArgument(parent as JetFunction, parent.analyze(), false)) {
-            return parent as JetFunction
+        if (InlineUtil.canBeInlineArgument(parent) && !InlineUtil.isInlinedArgument(parent as KtFunction, parent.analyze(), false)) {
+            return parent as KtFunction
         }
     }
     return null
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinRecursiveCallLineMarkerProvider.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinRecursiveCallLineMarkerProvider.kt
index e1413acc632..2d48b4c5e5b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinRecursiveCallLineMarkerProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinRecursiveCallLineMarkerProvider.kt
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.util.getThisReceiverOwner
-import org.jetbrains.kotlin.lexer.JetToken
+import org.jetbrains.kotlin.lexer.KtToken
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.parents
@@ -47,7 +47,7 @@ public class KotlinRecursiveCallLineMarkerProvider() : LineMarkerProvider {
 
         for (element in elements) {
             ProgressManager.checkCanceled()
-            if (element is JetElement) {
+            if (element is KtElement) {
                 val lineNumber = element.getLineNumber()
                 if (lineNumber !in markedLineNumbers && isRecursiveCall(element)) {
                     markedLineNumbers.add(lineNumber)
@@ -57,23 +57,23 @@ public class KotlinRecursiveCallLineMarkerProvider() : LineMarkerProvider {
         }
     }
 
-    private fun getEnclosingFunction(element: JetElement, stopOnNonInlinedLambdas: Boolean): JetNamedFunction? {
+    private fun getEnclosingFunction(element: KtElement, stopOnNonInlinedLambdas: Boolean): KtNamedFunction? {
         for (parent in element.parents) {
             when (parent) {
-                is JetFunctionLiteral -> if (stopOnNonInlinedLambdas && !InlineUtil.isInlinedArgument(parent, parent.analyze(), false)) return null
-                is JetNamedFunction -> {
+                is KtFunctionLiteral -> if (stopOnNonInlinedLambdas && !InlineUtil.isInlinedArgument(parent, parent.analyze(), false)) return null
+                is KtNamedFunction -> {
                     when (parent.getParent()) {
-                        is JetBlockExpression, is JetClassBody, is JetFile, is JetScript -> return parent
+                        is KtBlockExpression, is KtClassBody, is KtFile, is KtScript -> return parent
                         else -> if (stopOnNonInlinedLambdas && !InlineUtil.isInlinedArgument(parent, parent.analyze(), false)) return null
                     }
                 }
-                is JetClassOrObject -> return null
+                is KtClassOrObject -> return null
             }
         }
         return null
     }
 
-    private fun isRecursiveCall(element: JetElement): Boolean {
+    private fun isRecursiveCall(element: KtElement): Boolean {
         // Fast check for names without resolve
         val resolveName = getCallNameFromPsi(element) ?: return false
         val enclosingFunction = getEnclosingFunction(element, false) ?: return false
@@ -108,8 +108,8 @@ public class KotlinRecursiveCallLineMarkerProvider() : LineMarkerProvider {
         return true
     }
 
-    private class RecursiveMethodCallMarkerInfo(callElement: JetElement)
-            : LineMarkerInfo<JetElement>(
+    private class RecursiveMethodCallMarkerInfo(callElement: KtElement)
+            : LineMarkerInfo<KtElement>(
                     callElement,
                     callElement.getTextRange(),
                     AllIcons.Gutter.RecursiveMethod,
@@ -120,7 +120,7 @@ public class KotlinRecursiveCallLineMarkerProvider() : LineMarkerProvider {
     ) {
 
         override fun createGutterRenderer(): GutterIconRenderer? {
-            return object : LineMarkerInfo.LineMarkerGutterIconRenderer<JetElement>(this) {
+            return object : LineMarkerInfo.LineMarkerGutterIconRenderer<KtElement>(this) {
                 override fun getClickAction() = null // to place breakpoint on mouse click
             }
         }
@@ -132,18 +132,18 @@ private fun PsiElement.getLineNumber(): Int {
     return PsiDocumentManager.getInstance(getProject()).getDocument(getContainingFile())!!.getLineNumber(getTextOffset())
 }
 
-private fun getCallNameFromPsi(element: JetElement): Name? {
+private fun getCallNameFromPsi(element: KtElement): Name? {
     when (element) {
-        is JetSimpleNameExpression -> {
+        is KtSimpleNameExpression -> {
             val elementParent = element.getParent()
             when (elementParent) {
-                is JetCallExpression -> return Name.identifier(element.getText())
-                is JetOperationExpression -> {
+                is KtCallExpression -> return Name.identifier(element.getText())
+                is KtOperationExpression -> {
                     val operationReference = elementParent.getOperationReference()
                     if (element == operationReference) {
                         val node = operationReference.getReferencedNameElementType()
-                        return if (node is JetToken) {
-                            val conventionName = if (elementParent is JetPrefixExpression)
+                        return if (node is KtToken) {
+                            val conventionName = if (elementParent is KtPrefixExpression)
                                 OperatorConventions.getNameForOperationSymbol(node, true,  false)
                             else
                                 OperatorConventions.getNameForOperationSymbol(node)
@@ -157,10 +157,10 @@ private fun getCallNameFromPsi(element: JetElement): Name? {
                 }
             }
         }
-        is JetArrayAccessExpression ->
+        is KtArrayAccessExpression ->
             return Name.identifier("get")
-        is JetThisExpression ->
-            if (element.getParent() is JetCallExpression) {
+        is KtThisExpression ->
+            if (element.getParent() is KtCallExpression) {
                 return OperatorNameConventions.INVOKE
             }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinRunLineMarkerContributor.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinRunLineMarkerContributor.kt
index 402ccd93c86..e4345a3a7ae 100644
--- a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinRunLineMarkerContributor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinRunLineMarkerContributor.kt
@@ -20,15 +20,15 @@ import com.intellij.execution.lineMarker.ExecutorAction
 import com.intellij.execution.lineMarker.RunLineMarkerContributor
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.idea.JetIcons
+import org.jetbrains.kotlin.idea.KtIcons
 import org.jetbrains.kotlin.idea.MainFunctionDetector
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtNamedFunction
 
 
 public class KotlinRunLineMarkerContributor : RunLineMarkerContributor() {
     override fun getInfo(element: PsiElement?): RunLineMarkerContributor.Info? {
-        val function = element?.parent as? JetNamedFunction
+        val function = element?.parent as? KtNamedFunction
         if (function == null) return null
 
         if (function.nameIdentifier != element) return null
@@ -38,7 +38,7 @@ public class KotlinRunLineMarkerContributor : RunLineMarkerContributor() {
         }
 
         if (detector.isMain(function)) {
-            return RunLineMarkerContributor.Info(JetIcons.LAUNCH, null, ExecutorAction.getActions(0))
+            return RunLineMarkerContributor.Info(KtIcons.LAUNCH, null, ExecutorAction.getActions(0))
         }
 
         return null
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinTestRunLineMarkerContributor.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinTestRunLineMarkerContributor.kt
index a539d011ef3..76f473cebe6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinTestRunLineMarkerContributor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinTestRunLineMarkerContributor.kt
@@ -27,9 +27,9 @@ import org.jetbrains.kotlin.asJava.KotlinLightClass
 import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.asJava.toLightMethods
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
+import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import javax.swing.Icon
 
@@ -41,7 +41,7 @@ class KotlinTestRunLineMarkerContributor : RunLineMarkerContributor() {
     }
 
     override fun getInfo(element: PsiElement): RunLineMarkerContributor.Info? {
-        val declaration = element.getStrictParentOfType<JetNamedDeclaration>() ?: return null
+        val declaration = element.getStrictParentOfType<KtNamedDeclaration>() ?: return null
         if (declaration.nameIdentifier != element) return null
 
         // To prevent IDEA failing on red code
@@ -50,7 +50,7 @@ class KotlinTestRunLineMarkerContributor : RunLineMarkerContributor() {
         val project = element.project
 
         val (url, framework) = when (declaration) {
-            is JetClassOrObject -> {
+            is KtClassOrObject -> {
                 val lightClass = declaration.toLightClass() ?: return null
                 val framework = TestFrameworks.detectFramework(lightClass) ?: return null
                 if (!framework.isTestClass(lightClass)) return null
@@ -58,7 +58,7 @@ class KotlinTestRunLineMarkerContributor : RunLineMarkerContributor() {
                 "java:suite://${lightClass.qualifiedName!!}" to framework
             }
 
-            is JetNamedFunction -> {
+            is KtNamedFunction -> {
                 val lightMethod = declaration.toLightMethods().firstOrNull() ?: return null
                 val lightClass = lightMethod.containingClass as? KotlinLightClass ?: return null
                 val framework = TestFrameworks.detectFramework(lightClass) ?: return null
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/JavaPsiUtils.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/JavaPsiUtils.kt
index b0c4ebed8b4..e63958b1a5d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/JavaPsiUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/JavaPsiUtils.kt
@@ -22,10 +22,10 @@ import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiMethod
 import org.jetbrains.kotlin.asJava.LightClassUtil
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetFunction
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetSecondaryConstructor
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtSecondaryConstructor
 import java.util.*
 
 fun collectContainingClasses(methods: Collection<PsiMethod>): Set<PsiClass> {
@@ -45,8 +45,8 @@ internal fun getPsiClass(element: PsiElement?): PsiClass? {
     return when {
         element == null -> null
         element is PsiClass -> element
-        element is JetClass -> LightClassUtil.getPsiClass(element)
-        element.getParent() is JetClass -> LightClassUtil.getPsiClass(element.getParent() as JetClass)
+        element is KtClass -> LightClassUtil.getPsiClass(element)
+        element.getParent() is KtClass -> LightClassUtil.getPsiClass(element.getParent() as KtClass)
         else -> null
     }
 }
@@ -56,7 +56,7 @@ internal fun getPsiMethod(element: PsiElement?): PsiMethod? {
     return when {
         element == null -> null
         element is PsiMethod -> element
-        parent is JetNamedFunction, parent is JetSecondaryConstructor -> LightClassUtil.getLightClassMethod(parent as JetFunction)
+        parent is KtNamedFunction, parent is KtSecondaryConstructor -> LightClassUtil.getLightClassMethod(parent as KtFunction)
         else -> null
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/KotlinLineMarkerProvider.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/KotlinLineMarkerProvider.kt
index df30887b629..f2ffaa7d56c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/KotlinLineMarkerProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/KotlinLineMarkerProvider.kt
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.isOverridable
 import java.awt.event.MouseEvent
@@ -52,21 +52,21 @@ public class KotlinLineMarkerProvider : LineMarkerProvider {
         val first = elements.first()
         if (DumbService.getInstance(first.getProject()).isDumb() || !ProjectRootsUtil.isInProjectOrLibSource(first)) return
 
-        val functions = HashSet<JetNamedFunction>()
-        val properties = HashSet<JetProperty>()
+        val functions = HashSet<KtNamedFunction>()
+        val properties = HashSet<KtProperty>()
 
         for (element in elements) {
             ProgressManager.checkCanceled()
 
             when (element) {
-                is JetClass -> {
+                is KtClass -> {
                     collectInheritedClassMarker(element, result)
                 }
-                is JetNamedFunction -> {
+                is KtNamedFunction -> {
                     functions.add(element)
                     collectSuperDeclarationMarkers(element, result)
                 }
-                is JetProperty -> {
+                is KtProperty -> {
                     properties.add(element)
                     collectSuperDeclarationMarkers(element, result)
                 }
@@ -100,10 +100,10 @@ private val OVERRIDDEN_FUNCTION = MarkerType(
         })
 
 private val OVERRIDDEN_PROPERTY = MarkerType(
-        { it?.let { getOverriddenPropertyTooltip(it.getParent() as JetProperty) } },
+        { it?.let { getOverriddenPropertyTooltip(it.getParent() as KtProperty) } },
         object : LineMarkerNavigator() {
             override fun browse(e: MouseEvent?, element: PsiElement?) {
-                element?.let { navigateToPropertyOverriddenDeclarations(e, it.getParent() as JetProperty) }
+                element?.let { navigateToPropertyOverriddenDeclarations(e, it.getParent() as KtProperty) }
             }
         })
 
@@ -111,10 +111,10 @@ private fun isImplementsAndNotOverrides(descriptor: CallableMemberDescriptor, ov
     return descriptor.getModality() != Modality.ABSTRACT && overriddenMembers.all { it.getModality() == Modality.ABSTRACT }
 }
 
-private fun collectSuperDeclarationMarkers(declaration: JetDeclaration, result: MutableCollection<LineMarkerInfo<*>>) {
-    assert(declaration is JetNamedFunction || declaration is JetProperty)
+private fun collectSuperDeclarationMarkers(declaration: KtDeclaration, result: MutableCollection<LineMarkerInfo<*>>) {
+    assert(declaration is KtNamedFunction || declaration is KtProperty)
 
-    if (!declaration.hasModifier(JetTokens.OVERRIDE_KEYWORD)) return
+    if (!declaration.hasModifier(KtTokens.OVERRIDE_KEYWORD)) return
 
     val resolveWithParents = resolveDeclarationWithParents(declaration)
     if (resolveWithParents.overriddenDescriptors.isEmpty()) return
@@ -135,9 +135,9 @@ private fun collectSuperDeclarationMarkers(declaration: JetDeclaration, result:
     result.add(marker)
 }
 
-private fun collectInheritedClassMarker(element: JetClass, result: MutableCollection<LineMarkerInfo<*>>) {
+private fun collectInheritedClassMarker(element: KtClass, result: MutableCollection<LineMarkerInfo<*>>) {
     val isTrait = element.isInterface()
-    if (!(isTrait || element.hasModifier(JetTokens.OPEN_KEYWORD) || element.hasModifier(JetTokens.ABSTRACT_KEYWORD))) {
+    if (!(isTrait || element.hasModifier(KtTokens.OPEN_KEYWORD) || element.hasModifier(KtTokens.ABSTRACT_KEYWORD))) {
         return
     }
 
@@ -157,8 +157,8 @@ private fun collectInheritedClassMarker(element: JetClass, result: MutableCollec
     ))
 }
 
-private fun collectOverriddenPropertyAccessors(properties: Collection<JetProperty>, result: MutableCollection<LineMarkerInfo<*>>) {
-    val mappingToJava = HashMap<PsiMethod, JetProperty>()
+private fun collectOverriddenPropertyAccessors(properties: Collection<KtProperty>, result: MutableCollection<LineMarkerInfo<*>>) {
+    val mappingToJava = HashMap<PsiMethod, KtProperty>()
     for (property in properties) {
         if (property.isOverridable()) {
             val accessorsPsiMethods = LightClassUtil.getLightClassPropertyMethods(property)
@@ -187,8 +187,8 @@ private fun collectOverriddenPropertyAccessors(properties: Collection<JetPropert
     }
 }
 
-private fun collectOverriddenFunctions(functions: Collection<JetNamedFunction>, result: MutableCollection<LineMarkerInfo<*>>) {
-    val mappingToJava = HashMap<PsiMethod, JetNamedFunction>()
+private fun collectOverriddenFunctions(functions: Collection<KtNamedFunction>, result: MutableCollection<LineMarkerInfo<*>>) {
+    val mappingToJava = HashMap<PsiMethod, KtNamedFunction>()
     for (function in functions) {
         if (function.isOverridable()) {
             val method = LightClassUtil.getLightClassMethod(function)
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/OverridenPropertyMarker.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/OverridenPropertyMarker.kt
index 46b610ce270..ed6ff154882 100644
--- a/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/OverridenPropertyMarker.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/OverridenPropertyMarker.kt
@@ -39,10 +39,10 @@ import javax.swing.JComponent
 import com.intellij.codeInsight.daemon.impl.PsiElementListNavigator
 import com.intellij.psi.NavigatablePsiElement
 import com.intellij.util.Function
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 
-fun getOverriddenPropertyTooltip(property: JetProperty): String? {
+fun getOverriddenPropertyTooltip(property: KtProperty): String? {
     val overriddenInClassesProcessor = PsiElementProcessor.CollectElementsWithLimit<PsiClass>(5)
 
     val consumer = AdapterProcessor<PsiMethod, PsiClass>(
@@ -76,7 +76,7 @@ fun getOverriddenPropertyTooltip(property: JetProperty): String? {
     return GutterIconTooltipHelper.composeText(collectedClasses.sortedWith(PsiClassListCellRenderer().comparator), start, pattern)
 }
 
-fun navigateToPropertyOverriddenDeclarations(e: MouseEvent?, property: JetProperty) {
+fun navigateToPropertyOverriddenDeclarations(e: MouseEvent?, property: KtProperty) {
     val project = property.getProject()
 
     if (DumbService.isDumb(project)) {
@@ -115,14 +115,14 @@ fun navigateToPropertyOverriddenDeclarations(e: MouseEvent?, property: JetProper
 }
 
 
-public fun isImplemented(declaration: JetNamedDeclaration): Boolean {
-    if (declaration.hasModifier(JetTokens.ABSTRACT_KEYWORD)) return true
+public fun isImplemented(declaration: KtNamedDeclaration): Boolean {
+    if (declaration.hasModifier(KtTokens.ABSTRACT_KEYWORD)) return true
 
     var parent = declaration.getParent()
-    parent = if (parent is JetClassBody) parent.getParent() else parent
+    parent = if (parent is KtClassBody) parent.getParent() else parent
 
-    if (parent !is JetClass) return false
+    if (parent !is KtClass) return false
 
-    return parent.isInterface() && (declaration !is JetDeclarationWithBody || !declaration.hasBody()) && (declaration !is JetWithExpressionInitializer || !declaration.hasInitializer())
+    return parent.isInterface() && (declaration !is KtDeclarationWithBody || !declaration.hasBody()) && (declaration !is KtWithExpressionInitializer || !declaration.hasInitializer())
 }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/SuperDeclarationMarker.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/SuperDeclarationMarker.kt
index bef35e75d01..a0b2cb9d704 100644
--- a/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/SuperDeclarationMarker.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/SuperDeclarationMarker.kt
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.codeInsight.JetFunctionPsiElementCellRenderer
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.RenderingFormat
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -39,9 +39,9 @@ import org.jetbrains.kotlin.resolve.OverrideResolver
 import java.awt.event.MouseEvent
 import java.util.ArrayList
 
-object SuperDeclarationMarkerTooltip: Function<JetDeclaration, String> {
-    override fun `fun`(jetDeclaration: JetDeclaration?): String? {
-        val (elementDescriptor, overriddenDescriptors) = resolveDeclarationWithParents(jetDeclaration!!)
+object SuperDeclarationMarkerTooltip: Function<KtDeclaration, String> {
+    override fun `fun`(ktDeclaration: KtDeclaration?): String? {
+        val (elementDescriptor, overriddenDescriptors) = resolveDeclarationWithParents(ktDeclaration!!)
         if (overriddenDescriptors.isEmpty()) return ""
 
         val isAbstract = elementDescriptor!!.getModality() == Modality.ABSTRACT
@@ -65,7 +65,7 @@ object SuperDeclarationMarkerTooltip: Function<JetDeclaration, String> {
     }
 }
 
-public class SuperDeclarationMarkerNavigationHandler : GutterIconNavigationHandler<JetDeclaration> {
+public class SuperDeclarationMarkerNavigationHandler : GutterIconNavigationHandler<KtDeclaration> {
     private var testNavigableElements: List<NavigatablePsiElement>? = null
 
     @TestOnly
@@ -75,7 +75,7 @@ public class SuperDeclarationMarkerNavigationHandler : GutterIconNavigationHandl
         return navigationResult
     }
 
-    override fun navigate(e: MouseEvent?, element: JetDeclaration?) {
+    override fun navigate(e: MouseEvent?, element: KtDeclaration?) {
         if (element == null) return
 
         val (elementDescriptor, overriddenDescriptors) = resolveDeclarationWithParents(element)
@@ -112,7 +112,7 @@ public data class ResolveWithParentsResult(
         val descriptor: CallableMemberDescriptor?,
         val overriddenDescriptors: Collection<CallableMemberDescriptor>)
 
-public fun resolveDeclarationWithParents(element: JetDeclaration): ResolveWithParentsResult {
+public fun resolveDeclarationWithParents(element: KtDeclaration): ResolveWithParentsResult {
     val descriptor = element.resolveToDescriptorIfAny()
 
     if (descriptor !is CallableMemberDescriptor) return ResolveWithParentsResult(null, listOf())
diff --git a/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt b/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt
index 4866915100b..1c1ed8ee170 100644
--- a/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.getFileTopLevelScope
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.core.formatter.JetCodeStyleSettings
 import org.jetbrains.kotlin.idea.core.getResolutionScope
-import org.jetbrains.kotlin.idea.references.JetReference
+import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.idea.references.canBeResolvedViaImport
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.renderer.render
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.ImportPath
 import org.jetbrains.kotlin.resolve.descriptorUtil.getImportableDescriptor
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.utils.asJetScope
 import org.jetbrains.kotlin.resolve.scopes.utils.getImplicitReceiversHierarchy
 import org.jetbrains.kotlin.resolve.scopes.utils.withNoFileScope
@@ -47,13 +47,13 @@ import java.util.*
 
 public class KotlinImportOptimizer() : ImportOptimizer {
 
-    override fun supports(file: PsiFile?) = file is JetFile
+    override fun supports(file: PsiFile?) = file is KtFile
 
     override fun processFile(file: PsiFile?) = Runnable() {
-        OptimizeProcess(file as JetFile).execute()
+        OptimizeProcess(file as KtFile).execute()
     }
 
-    private class OptimizeProcess(private val file: JetFile) {
+    private class OptimizeProcess(private val file: KtFile) {
         public fun execute() {
             val oldImports = file.importDirectives
             if (oldImports.isEmpty()) return
@@ -68,7 +68,7 @@ public class KotlinImportOptimizer() : ImportOptimizer {
         }
     }
 
-    private class CollectUsedDescriptorsVisitor(val file: JetFile) : JetVisitorVoid() {
+    private class CollectUsedDescriptorsVisitor(val file: KtFile) : KtVisitorVoid() {
         private val _descriptors = HashSet<DeclarationDescriptor>()
         private val currentPackageName = file.packageFqName
 
@@ -80,21 +80,21 @@ public class KotlinImportOptimizer() : ImportOptimizer {
             element.acceptChildren(this)
         }
 
-        override fun visitImportList(importList: JetImportList) {
+        override fun visitImportList(importList: KtImportList) {
         }
 
-        override fun visitPackageDirective(directive: JetPackageDirective) {
+        override fun visitPackageDirective(directive: KtPackageDirective) {
         }
 
-        override fun visitJetElement(element: JetElement) {
+        override fun visitJetElement(element: KtElement) {
             for (reference in element.references) {
-                if (reference !is JetReference) continue
+                if (reference !is KtReference) continue
 
-                val referencedName = (element as? JetNameReferenceExpression)?.getReferencedNameAsName() //TODO: other types of references
+                val referencedName = (element as? KtNameReferenceExpression)?.getReferencedNameAsName() //TODO: other types of references
 
                 val bindingContext = element.analyze()
                 //class qualifiers that refer to companion objects should be considered (containing) class references
-                val targets = bindingContext[BindingContext.SHORT_REFERENCE_TO_COMPANION_OBJECT, element as? JetReferenceExpression]?.let { listOf(it) }
+                val targets = bindingContext[BindingContext.SHORT_REFERENCE_TO_COMPANION_OBJECT, element as? KtReferenceExpression]?.let { listOf(it) }
                               ?: reference.resolveToDescriptors(bindingContext)
                 for (target in targets) {
                     val importableFqName = target.importableFqName ?: continue
@@ -117,10 +117,10 @@ public class KotlinImportOptimizer() : ImportOptimizer {
             super.visitJetElement(element)
         }
 
-        private fun isAccessibleAsMember(target: DeclarationDescriptor, place: JetElement, bindingContext: BindingContext): Boolean {
+        private fun isAccessibleAsMember(target: DeclarationDescriptor, place: KtElement, bindingContext: BindingContext): Boolean {
             if (target.containingDeclaration !is ClassDescriptor) return false
 
-            fun isInScope(scope: JetScope): Boolean {
+            fun isInScope(scope: KtScope): Boolean {
                 return when (target) {
                     is FunctionDescriptor ->
                         scope.getFunctions(target.name, NoLookupLocation.FROM_IDE).contains(target)
@@ -144,14 +144,14 @@ public class KotlinImportOptimizer() : ImportOptimizer {
     }
 
     companion object {
-        public fun collectDescriptorsToImport(file: JetFile): Set<DeclarationDescriptor> {
+        public fun collectDescriptorsToImport(file: KtFile): Set<DeclarationDescriptor> {
             val visitor = CollectUsedDescriptorsVisitor(file)
             file.accept(visitor)
             return visitor.descriptors
         }
 
         public fun prepareOptimizedImports(
-                file: JetFile,
+                file: KtFile,
                 descriptorsToImport: Collection<DeclarationDescriptor>
         ): List<ImportPath>? {
             val importInsertHelper = ImportInsertHelper.getInstance(file.project)
@@ -217,7 +217,7 @@ public class KotlinImportOptimizer() : ImportOptimizer {
                 append("package ").append(file.packageFqName.render()).append("\n")
                 importsToGenerate.filter { it.isAllUnder() }.map { "import " + it.pathStr }.joinTo(this, "\n")
             }.toString()
-            val fileWithImports = JetPsiFactory(file).createAnalyzableFile("Dummy.kt", fileWithImportsText, file)
+            val fileWithImports = KtPsiFactory(file).createAnalyzableFile("Dummy.kt", fileWithImportsText, file)
             val scope = fileWithImports.getResolutionFacade().getFileTopLevelScope(fileWithImports)
 
             for (fqName in classNamesToCheck) {
@@ -249,7 +249,7 @@ public class KotlinImportOptimizer() : ImportOptimizer {
             return sortedImportsToGenerate
         }
 
-        private fun buildAliasImportMap(file: JetFile): Map<Name, FqName> {
+        private fun buildAliasImportMap(file: KtFile): Map<Name, FqName> {
             val imports = file.importDirectives
             val aliasImports = HashMap<Name, FqName>()
             for (import in imports) {
@@ -262,10 +262,10 @@ public class KotlinImportOptimizer() : ImportOptimizer {
             return aliasImports
         }
 
-        public fun replaceImports(file: JetFile, imports: List<ImportPath>) {
+        public fun replaceImports(file: KtFile, imports: List<ImportPath>) {
             val importList = file.importList!!
             val oldImports = importList.imports
-            val psiFactory = JetPsiFactory(file.project)
+            val psiFactory = KtPsiFactory(file.project)
             for (importPath in imports) {
                 importList.addBefore(psiFactory.createImportDirective(importPath), oldImports.lastOrNull()) // insert into the middle to keep collapsed state
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/AddModifierFixFactory.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/AddModifierFixFactory.kt
index 72cfca74513..b360e4b0b39 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/AddModifierFixFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/AddModifierFixFactory.kt
@@ -24,14 +24,14 @@ import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.quickfix.AddModifierFix
 import org.jetbrains.kotlin.idea.quickfix.CleanupFix
 import org.jetbrains.kotlin.idea.quickfix.JetSingleIntentionActionFactory
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.psi.JetModifierListOwner
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.psi.KtModifierListOwner
 
-class AddModifierFixFactory(val token: JetModifierKeywordToken) : JetSingleIntentionActionFactory() {
+class AddModifierFixFactory(val token: KtModifierKeywordToken) : JetSingleIntentionActionFactory() {
     override fun createAction(diagnostic: Diagnostic): IntentionAction? {
         val functionDescriptor = (diagnostic as? DiagnosticWithParameters2<*, *, *>)?.a as? FunctionDescriptor ?: return null
         val target = DescriptorToSourceUtilsIde.getAnyDeclaration(diagnostic.psiFile.project, functionDescriptor)
-                as? JetModifierListOwner ?: return null
+                as? KtModifierListOwner ?: return null
         return object : AddModifierFix(target, token), CleanupFix {}
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/AddReflectionQuickFix.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/AddReflectionQuickFix.kt
index 766fa57c375..5ded2bfa782 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/AddReflectionQuickFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/AddReflectionQuickFix.kt
@@ -32,17 +32,17 @@ import org.jetbrains.kotlin.idea.quickfix.KotlinQuickFixAction
 import org.jetbrains.kotlin.idea.quickfix.JetSingleIntentionActionFactory
 import org.jetbrains.kotlin.idea.quickfix.quickfixUtil.createIntentionForFirstParentOfType
 import org.jetbrains.kotlin.idea.versions.KotlinRuntimeLibraryUtil
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.utils.PathUtil
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import java.io.File
 
-public class AddReflectionQuickFix(element: JetElement) : KotlinQuickFixAction<JetElement>(element) {
+public class AddReflectionQuickFix(element: KtElement) : KotlinQuickFixAction<KtElement>(element) {
     override fun getText() = JetBundle.message("add.reflection.to.classpath")
     override fun getFamilyName() = getText()
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         val pluginReflectJar = PathUtil.getKotlinPathsForIdeaPlugin().getReflectPath()
         if (!pluginReflectJar.exists()) return
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/ConflictingExtensionPropertyInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/ConflictingExtensionPropertyInspection.kt
index 9f0d4a1b438..43a72c5f611 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/ConflictingExtensionPropertyInspection.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/ConflictingExtensionPropertyInspection.kt
@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.core.targetDescriptors
 import org.jetbrains.kotlin.idea.imports.importableFqName
 import org.jetbrains.kotlin.idea.quickfix.KotlinQuickFixAction
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.idea.stubindex.JetSourceFilterScope
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.idea.util.application.runReadAction
@@ -55,11 +55,11 @@ import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 
 public class ConflictingExtensionPropertyInspection : AbstractKotlinInspection(), CleanupLocalInspectionTool {
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean, session: LocalInspectionToolSession): PsiElementVisitor {
-        val file = session.file as? JetFile ?: return PsiElementVisitor.EMPTY_VISITOR
+        val file = session.file as? KtFile ?: return PsiElementVisitor.EMPTY_VISITOR
         val fileScope = file.getResolutionFacade().getFileTopLevelScope(file)
 
-        return object : JetVisitorVoid() {
-            override fun visitProperty(property: JetProperty) {
+        return object : KtVisitorVoid() {
+            override fun visitProperty(property: KtProperty) {
                 super.visitProperty(property)
 
                 if (property.receiverTypeReference != null) {
@@ -93,7 +93,7 @@ public class ConflictingExtensionPropertyInspection : AbstractKotlinInspection()
                 .firstIsInstanceOrNull()
     }
 
-    private fun isSameAsSynthetic(declaration: JetProperty, syntheticProperty: SyntheticJavaPropertyDescriptor): Boolean {
+    private fun isSameAsSynthetic(declaration: KtProperty, syntheticProperty: SyntheticJavaPropertyDescriptor): Boolean {
         val getter = declaration.getter ?: return false
         val setter = declaration.setter
 
@@ -107,20 +107,20 @@ public class ConflictingExtensionPropertyInspection : AbstractKotlinInspection()
         return true
     }
 
-    private fun checkGetterBodyIsGetMethodCall(getter: JetPropertyAccessor, getMethod: FunctionDescriptor): Boolean {
+    private fun checkGetterBodyIsGetMethodCall(getter: KtPropertyAccessor, getMethod: FunctionDescriptor): Boolean {
         if (getter.hasBlockBody()) {
-            val statement = (getter.bodyExpression as? JetBlockExpression)?.statements?.singleOrNull() ?: return false
-            return (statement as? JetReturnExpression)?.returnedExpression.isGetMethodCall(getMethod)
+            val statement = (getter.bodyExpression as? KtBlockExpression)?.statements?.singleOrNull() ?: return false
+            return (statement as? KtReturnExpression)?.returnedExpression.isGetMethodCall(getMethod)
         }
         else {
             return getter.bodyExpression.isGetMethodCall(getMethod)
         }
     }
 
-    private fun checkSetterBodyIsSetMethodCall(setter: JetPropertyAccessor, setMethod: FunctionDescriptor): Boolean {
+    private fun checkSetterBodyIsSetMethodCall(setter: KtPropertyAccessor, setMethod: FunctionDescriptor): Boolean {
         val valueParameterName = setter.valueParameters.singleOrNull()?.nameAsName ?: return false
         if (setter.hasBlockBody()) {
-            val statement = (setter.bodyExpression as? JetBlockExpression)?.statements?.singleOrNull() ?: return false
+            val statement = (setter.bodyExpression as? KtBlockExpression)?.statements?.singleOrNull() ?: return false
             return statement.isSetMethodCall(setMethod, valueParameterName)
         }
         else {
@@ -128,40 +128,40 @@ public class ConflictingExtensionPropertyInspection : AbstractKotlinInspection()
         }
     }
 
-    private fun JetExpression?.isGetMethodCall(getMethod: FunctionDescriptor): Boolean {
+    private fun KtExpression?.isGetMethodCall(getMethod: FunctionDescriptor): Boolean {
         when (this) {
-            is JetCallExpression -> {
+            is KtCallExpression -> {
                 val resolvedCall = getResolvedCall(analyze())
                 return resolvedCall != null && resolvedCall.isReallySuccess() && resolvedCall.resultingDescriptor.original == getMethod.original
             }
 
-            is JetQualifiedExpression -> {
+            is KtQualifiedExpression -> {
                 val receiver = receiverExpression
-                return receiver is JetThisExpression && receiver.labelQualifier == null && selectorExpression.isGetMethodCall(getMethod)
+                return receiver is KtThisExpression && receiver.labelQualifier == null && selectorExpression.isGetMethodCall(getMethod)
             }
 
             else -> return false
         }
     }
 
-    private fun JetExpression?.isSetMethodCall(setMethod: FunctionDescriptor, valueParameterName: Name): Boolean {
+    private fun KtExpression?.isSetMethodCall(setMethod: FunctionDescriptor, valueParameterName: Name): Boolean {
         when (this) {
-            is JetCallExpression -> {
-                if ((valueArguments.singleOrNull()?.getArgumentExpression() as? JetSimpleNameExpression)?.getReferencedNameAsName() != valueParameterName) return false
+            is KtCallExpression -> {
+                if ((valueArguments.singleOrNull()?.getArgumentExpression() as? KtSimpleNameExpression)?.getReferencedNameAsName() != valueParameterName) return false
                 val resolvedCall = getResolvedCall(analyze())
                 return resolvedCall != null && resolvedCall.isReallySuccess() && resolvedCall.resultingDescriptor.original == setMethod.original
             }
 
-            is JetQualifiedExpression -> {
+            is KtQualifiedExpression -> {
                 val receiver = receiverExpression
-                return receiver is JetThisExpression && receiver.labelQualifier == null && selectorExpression.isSetMethodCall(setMethod, valueParameterName)
+                return receiver is KtThisExpression && receiver.labelQualifier == null && selectorExpression.isSetMethodCall(setMethod, valueParameterName)
             }
 
             else -> return false
         }
     }
 
-    private fun createFixes(property: JetProperty, conflictingExtension: SyntheticJavaPropertyDescriptor, isOnTheFly: Boolean): Array<IntentionWrapper> {
+    private fun createFixes(property: KtProperty, conflictingExtension: SyntheticJavaPropertyDescriptor, isOnTheFly: Boolean): Array<IntentionWrapper> {
         val fixes = if (isSameAsSynthetic(property, conflictingExtension)) {
             val fix1 = IntentionWrapper(DeleteRedundantExtensionAction(property), property.containingFile)
             // don't add the second fix when on the fly to allow code cleanup
@@ -177,7 +177,7 @@ public class ConflictingExtensionPropertyInspection : AbstractKotlinInspection()
         return fixes
     }
 
-    private class DeleteRedundantExtensionAction(property: JetProperty) : KotlinQuickFixAction<JetProperty>(property) {
+    private class DeleteRedundantExtensionAction(property: KtProperty) : KotlinQuickFixAction<KtProperty>(property) {
         private val LOG = Logger.getInstance(DeleteRedundantExtensionAction::class.java);
 
         override fun getFamilyName() = "Delete redundant extension property"
@@ -185,7 +185,7 @@ public class ConflictingExtensionPropertyInspection : AbstractKotlinInspection()
 
         override fun startInWriteAction() = false
 
-        override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+        override fun invoke(project: Project, editor: Editor?, file: KtFile) {
             val declaration = element
             val fqName = declaration.resolveToDescriptor().importableFqName
             if (fqName != null) {
@@ -195,8 +195,8 @@ public class ConflictingExtensionPropertyInspection : AbstractKotlinInspection()
                                 val importsToDelete = runReadAction {
                                     val searchScope = JetSourceFilterScope.kotlinSources(GlobalSearchScope.projectScope(project), project)
                                     ReferencesSearch.search(declaration, searchScope)
-                                            .filterIsInstance<JetSimpleNameReference>()
-                                            .map { ref -> ref.expression.getStrictParentOfType<JetImportDirective>() }
+                                            .filterIsInstance<KtSimpleNameReference>()
+                                            .map { ref -> ref.expression.getStrictParentOfType<KtImportDirective>() }
                                             .filterNotNull()
                                             .filter { import -> !import.isAllUnder && import.targetDescriptors().size() == 1 }
                                 }
@@ -222,19 +222,19 @@ public class ConflictingExtensionPropertyInspection : AbstractKotlinInspection()
         }
     }
 
-    private class MarkHiddenAndDeprecatedAction(property: JetProperty) : KotlinQuickFixAction<JetProperty>(property) {
+    private class MarkHiddenAndDeprecatedAction(property: KtProperty) : KotlinQuickFixAction<KtProperty>(property) {
         override fun getFamilyName() = "Mark as @Deprecated(..., level = DeprecationLevel.HIDDEN)"
         override fun getText() = familyName
 
-        override fun invoke(project: Project, editor: Editor?, file: JetFile) {
-            val factory = JetPsiFactory(project)
+        override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+            val factory = KtPsiFactory(project)
             val name = element.nameAsName!!.render()
             element.addAnnotationWithLineBreak(factory.createAnnotationEntry("@Deprecated(\"Is replaced with automatic synthetic extension\", ReplaceWith(\"$name\"), level = DeprecationLevel.HIDDEN)"))
         }
 
         //TODO: move into PSI?
-        private fun JetNamedDeclaration.addAnnotationWithLineBreak(annotationEntry: JetAnnotationEntry): JetAnnotationEntry {
-            val newLine = JetPsiFactory(this).createNewLine()
+        private fun KtNamedDeclaration.addAnnotationWithLineBreak(annotationEntry: KtAnnotationEntry): KtAnnotationEntry {
+            val newLine = KtPsiFactory(this).createNewLine()
             if (modifierList != null) {
                 val result = addAnnotationEntry(annotationEntry)
                 modifierList!!.addAfter(newLine, result)
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/DeprecatedObjectInstanceFieldReference.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/DeprecatedObjectInstanceFieldReference.kt
index 62e551c9725..93fcbe18777 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/DeprecatedObjectInstanceFieldReference.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/DeprecatedObjectInstanceFieldReference.kt
@@ -22,7 +22,7 @@ import com.intellij.psi.*
 import com.intellij.psi.codeStyle.JavaCodeStyleManager
 import org.jetbrains.kotlin.asJava.KotlinLightClass
 import org.jetbrains.kotlin.load.java.JvmAbi
-import org.jetbrains.kotlin.psi.JetObjectDeclaration
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
 
 public class DeprecatedObjectInstanceFieldReferenceInspection : LocalInspectionTool(), CleanupLocalInspectionTool {
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean, session: LocalInspectionToolSession): PsiElementVisitor {
@@ -32,7 +32,7 @@ public class DeprecatedObjectInstanceFieldReferenceInspection : LocalInspectionT
                 if (!(resolvedTo is PsiField && resolvedTo.name == JvmAbi.DEPRECATED_INSTANCE_FIELD)) return
 
                 val containingClass = resolvedTo.containingClass
-                if (containingClass !is KotlinLightClass || containingClass.getOrigin() !is JetObjectDeclaration) return
+                if (containingClass !is KotlinLightClass || containingClass.getOrigin() !is KtObjectDeclaration) return
 
                 holder.registerProblem(
                         expression, "Use of deprecated '${JvmAbi.DEPRECATED_INSTANCE_FIELD}' field",
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/DeprecatedUsageOfStaticField.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/DeprecatedUsageOfStaticField.kt
index e63287ff1ba..b2607e6b12a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/DeprecatedUsageOfStaticField.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/DeprecatedUsageOfStaticField.kt
@@ -24,12 +24,12 @@ import org.jetbrains.kotlin.asJava.KotlinLightFieldForDeclaration
 import org.jetbrains.kotlin.idea.quickfix.AddConstModifierFix
 import org.jetbrains.kotlin.idea.quickfix.AddConstModifierIntention
 import org.jetbrains.kotlin.idea.quickfix.replaceReferencesToGetterByReferenceToField
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.load.java.JvmAbi
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetObjectDeclaration
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import java.util.*
 
 class DeprecatedUsageOfStaticFieldInspection : LocalInspectionTool(), CleanupLocalInspectionTool {
@@ -39,7 +39,7 @@ class DeprecatedUsageOfStaticFieldInspection : LocalInspectionTool(), CleanupLoc
                 val resolvedTo = expression.reference?.resolve() as? PsiField ?: return
                 if (!resolvedTo.hasModifierProperty(PsiModifier.STATIC) || !resolvedTo.isDeprecated) return
 
-                val kotlinProperty = (resolvedTo as? KotlinLightFieldForDeclaration)?.getOrigin() as? JetProperty
+                val kotlinProperty = (resolvedTo as? KotlinLightFieldForDeclaration)?.getOrigin() as? KtProperty
 
                 // NOTE: this is hack to avoid test failing with "action is still available" error
                 if (kotlinProperty?.hasJvmFieldAnnotationOrConstModifier() ?: false) return
@@ -47,8 +47,8 @@ class DeprecatedUsageOfStaticFieldInspection : LocalInspectionTool(), CleanupLoc
                 val kotlinClassOrObject = (resolvedTo.containingClass as? KotlinLightClass)?.getOrigin() ?: return
 
                 val containingObject = when (kotlinClassOrObject) {
-                    is JetObjectDeclaration -> kotlinClassOrObject as JetObjectDeclaration // KT-9578
-                    is JetClass -> kotlinClassOrObject.getCompanionObjects().singleOrNull() ?: return
+                    is KtObjectDeclaration -> kotlinClassOrObject as KtObjectDeclaration // KT-9578
+                    is KtClass -> kotlinClassOrObject.getCompanionObjects().singleOrNull() ?: return
                     else -> return
                 }
                 holder.registerProblem(
@@ -61,7 +61,7 @@ class DeprecatedUsageOfStaticFieldInspection : LocalInspectionTool(), CleanupLoc
     }
 
 
-    private fun createFixes(containingObject: JetObjectDeclaration, property: JetProperty?): List<LocalQuickFix> {
+    private fun createFixes(containingObject: KtObjectDeclaration, property: KtProperty?): List<LocalQuickFix> {
         if (containingObject.getContainingJetFile().isCompiled) return listOf(ReplaceWithGetterInvocationFix())
 
         // order matters here, 'cleanup' applies fixes in this order
@@ -71,7 +71,7 @@ class DeprecatedUsageOfStaticFieldInspection : LocalInspectionTool(), CleanupLoc
         }
 
         if (containingObject.isCompanion()) {
-            val classWithCompanion = containingObject.parent?.parent as? JetClass ?: return listOf()
+            val classWithCompanion = containingObject.parent?.parent as? KtClass ?: return listOf()
             if (!classWithCompanion.isInterface()) {
                 fixes.add(AddJvmFieldAnnotationFix())
             }
@@ -88,21 +88,21 @@ class DeprecatedUsageOfStaticFieldInspection : LocalInspectionTool(), CleanupLoc
 abstract class StaticFieldUsageFix: LocalQuickFix {
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
         val deprecatedField = descriptor.psiElement.reference?.resolve() as? PsiField ?: return
-        val kotlinProperty = (deprecatedField as? KotlinLightFieldForDeclaration)?.getOrigin() as? JetProperty
+        val kotlinProperty = (deprecatedField as? KotlinLightFieldForDeclaration)?.getOrigin() as? KtProperty
 
         if (kotlinProperty != null && kotlinProperty.hasJvmFieldAnnotationOrConstModifier()) return
 
         doFix(deprecatedField, kotlinProperty, descriptor)
     }
 
-    abstract fun doFix(deprecatedField: PsiField, property: JetProperty?, problemDescriptor: ProblemDescriptor)
+    abstract fun doFix(deprecatedField: PsiField, property: KtProperty?, problemDescriptor: ProblemDescriptor)
 }
 
 class AddJvmFieldAnnotationFix : StaticFieldUsageFix() {
-    override fun doFix(deprecatedField: PsiField, property: JetProperty?, problemDescriptor: ProblemDescriptor) {
+    override fun doFix(deprecatedField: PsiField, property: KtProperty?, problemDescriptor: ProblemDescriptor) {
         replaceReferencesToGetterByReferenceToField(property ?: return)
 
-        property.addAnnotationEntry(JetPsiFactory(property).createAnnotationEntry("@JvmField"))
+        property.addAnnotationEntry(KtPsiFactory(property).createAnnotationEntry("@JvmField"))
     }
 
     override fun getName(): String = "Annotate property with @JvmField"
@@ -113,7 +113,7 @@ class AddConstModifierLocalFix : StaticFieldUsageFix() {
     override fun getName(): String = "Add 'const' modifier to a property"
     override fun getFamilyName(): String = name
 
-    override fun doFix(deprecatedField: PsiField, property: JetProperty?, problemDescriptor: ProblemDescriptor) {
+    override fun doFix(deprecatedField: PsiField, property: KtProperty?, problemDescriptor: ProblemDescriptor) {
         AddConstModifierFix.addConstModifier(property ?: return)
     }
 }
@@ -122,7 +122,7 @@ class ReplaceWithGetterInvocationFix : StaticFieldUsageFix() {
     override fun getName(): String = "Replace with getter invocation"
     override fun getFamilyName(): String = name
 
-    override fun doFix(deprecatedField: PsiField, property: JetProperty?, problemDescriptor: ProblemDescriptor) {
+    override fun doFix(deprecatedField: PsiField, property: KtProperty?, problemDescriptor: ProblemDescriptor) {
         val lightClass = deprecatedField.containingClass as? KotlinLightClass ?: return
 
         fun replaceWithGetterInvocation(objectField: PsiField) {
@@ -138,11 +138,11 @@ class ReplaceWithGetterInvocationFix : StaticFieldUsageFix() {
 
         val kotlinClass = lightClass.getOrigin()
         when (kotlinClass) {
-            is JetObjectDeclaration -> {
+            is KtObjectDeclaration -> {
                 val instanceField = lightClass.findFieldByName(JvmAbi.INSTANCE_FIELD, false) ?: return
                 replaceWithGetterInvocation(instanceField)
             }
-            is JetClass -> {
+            is KtClass -> {
                 val companionObjectName = kotlinClass.getCompanionObjects().singleOrNull()?.name ?: return
                 val companionObjectField = lightClass.findFieldByName(companionObjectName, false) ?: return
                 replaceWithGetterInvocation(companionObjectField)
@@ -151,6 +151,6 @@ class ReplaceWithGetterInvocationFix : StaticFieldUsageFix() {
     }
 }
 
-private fun JetProperty.hasJvmFieldAnnotationOrConstModifier(): Boolean {
-    return hasModifier(JetTokens.CONST_KEYWORD) || annotationEntries.any { it.text == "@JvmField" }
+private fun KtProperty.hasJvmFieldAnnotationOrConstModifier(): Boolean {
+    return hasModifier(KtTokens.CONST_KEYWORD) || annotationEntries.any { it.text == "@JvmField" }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/EqualsOrHashCodeInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/EqualsOrHashCodeInspection.kt
index b59e003f175..a08db2b84a9 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/EqualsOrHashCodeInspection.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/EqualsOrHashCodeInspection.kt
@@ -28,10 +28,10 @@ import org.jetbrains.kotlin.idea.actions.generate.KotlinGenerateEqualsAndHashcod
 import org.jetbrains.kotlin.idea.actions.generate.findDeclaredEquals
 import org.jetbrains.kotlin.idea.actions.generate.findDeclaredHashCode
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetObjectDeclaration
-import org.jetbrains.kotlin.psi.JetVisitorVoid
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
+import org.jetbrains.kotlin.psi.KtVisitorVoid
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.source.getPsi
 
@@ -41,7 +41,7 @@ object DeleteEqualsAndHashCodeFix : LocalQuickFix {
     override fun getFamilyName() = name
 
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        val objectDeclaration = descriptor.psiElement.getStrictParentOfType<JetObjectDeclaration>() ?: return
+        val objectDeclaration = descriptor.psiElement.getStrictParentOfType<KtObjectDeclaration>() ?: return
         val classDescriptor = objectDeclaration.resolveToDescriptorIfAny() as? ClassDescriptor ?: return
         classDescriptor.findDeclaredEquals(false)?.source?.getPsi()?.delete()
         classDescriptor.findDeclaredHashCode(false)?.source?.getPsi()?.delete()
@@ -60,14 +60,14 @@ sealed class GenerateEqualsOrHashCodeFix : LocalQuickFix {
     override fun getFamilyName() = name
 
     override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
-        KotlinGenerateEqualsAndHashcodeAction().doInvoke(project, null, descriptor.psiElement.parent as JetClass)
+        KotlinGenerateEqualsAndHashcodeAction().doInvoke(project, null, descriptor.psiElement.parent as KtClass)
     }
 }
 
 class EqualsOrHashCodeInspection : AbstractKotlinInspection() {
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object: JetVisitorVoid() {
-            override fun visitClassOrObject(classOrObject: JetClassOrObject) {
+        return object: KtVisitorVoid() {
+            override fun visitClassOrObject(classOrObject: KtClassOrObject) {
                 val nameIdentifier = classOrObject.nameIdentifier ?: return
                 val classDescriptor = classOrObject.resolveToDescriptorIfAny() as? ClassDescriptor ?: return
                 val hasEquals = classDescriptor.findDeclaredEquals(false) != null
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/KotlinCleanupInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/KotlinCleanupInspection.kt
index 8216b89acbc..619f5997383 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/KotlinCleanupInspection.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/KotlinCleanupInspection.kt
@@ -33,9 +33,9 @@ import org.jetbrains.kotlin.idea.quickfix.KotlinQuickFixAction
 import org.jetbrains.kotlin.idea.quickfix.ReplaceObsoleteLabelSyntaxFix
 import org.jetbrains.kotlin.idea.quickfix.replaceWith.DeprecatedSymbolUsageFix
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
-import org.jetbrains.kotlin.psi.JetAnnotationEntry
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetImportDirective
+import org.jetbrains.kotlin.psi.KtAnnotationEntry
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtImportDirective
 import org.jetbrains.kotlin.psi.psiUtil.forEachDescendantOfType
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
@@ -45,7 +45,7 @@ public class KotlinCleanupInspection(): LocalInspectionTool(), CleanupLocalInspe
     override fun getDisplayName(): String = "Usage of redundant or deprecated syntax or deprecated symbols"
 
     override fun checkFile(file: PsiFile, manager: InspectionManager, isOnTheFly: Boolean): Array<out ProblemDescriptor>? {
-        if (isOnTheFly || file !is JetFile || !ProjectRootsUtil.isInProjectSource(file)) {
+        if (isOnTheFly || file !is KtFile || !ProjectRootsUtil.isInProjectSource(file)) {
             return null
         }
 
@@ -101,7 +101,7 @@ public class KotlinCleanupInspection(): LocalInspectionTool(), CleanupLocalInspe
     )
 
     private fun Diagnostic.isObsoleteLabel(): Boolean {
-        val annotationEntry = getPsiElement().getNonStrictParentOfType<JetAnnotationEntry>() ?: return false
+        val annotationEntry = getPsiElement().getNonStrictParentOfType<KtAnnotationEntry>() ?: return false
         return ReplaceObsoleteLabelSyntaxFix.looksLikeObsoleteLabel(annotationEntry)
     }
 
@@ -109,7 +109,7 @@ public class KotlinCleanupInspection(): LocalInspectionTool(), CleanupLocalInspe
         return JetPsiChecker.createQuickfixes(this).filterIsInstance<CleanupFix>()
     }
 
-    private class Wrapper(val intention: IntentionAction, file: JetFile) : IntentionWrapper(intention, file) {
+    private class Wrapper(val intention: IntentionAction, file: KtFile) : IntentionWrapper(intention, file) {
         override fun invoke(project: Project, editor: Editor?, file: PsiFile?) {
             if (intention.isAvailable(project, editor, file)) { // we should check isAvailable here because some elements may get invalidated (or other conditions may change)
                 super.invoke(project, editor, file)
@@ -117,11 +117,11 @@ public class KotlinCleanupInspection(): LocalInspectionTool(), CleanupLocalInspe
         }
     }
 
-    private fun Diagnostic.toProblemDescriptor(fixes: Collection<CleanupFix>, file: JetFile, manager: InspectionManager): ProblemDescriptor {
+    private fun Diagnostic.toProblemDescriptor(fixes: Collection<CleanupFix>, file: KtFile, manager: InspectionManager): ProblemDescriptor {
         return createProblemDescriptor(psiElement, DefaultErrorMessages.render(this), fixes, file, manager)
     }
 
-    private fun createProblemDescriptor(element: PsiElement, message: String, fixes: Collection<CleanupFix>, file: JetFile, manager: InspectionManager): ProblemDescriptor {
+    private fun createProblemDescriptor(element: PsiElement, message: String, fixes: Collection<CleanupFix>, file: KtFile, manager: InspectionManager): ProblemDescriptor {
         return manager.createProblemDescriptor(element,
                                                message,
                                                false,
@@ -129,11 +129,11 @@ public class KotlinCleanupInspection(): LocalInspectionTool(), CleanupLocalInspe
                                                ProblemHighlightType.GENERIC_ERROR_OR_WARNING)
     }
 
-    private class RemoveImportFix(import: JetImportDirective) : KotlinQuickFixAction<JetImportDirective>(import), CleanupFix {
+    private class RemoveImportFix(import: KtImportDirective) : KotlinQuickFixAction<KtImportDirective>(import), CleanupFix {
         override fun getFamilyName() = "Remove deprecated symbol import"
         override fun getText() = familyName
 
-        override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+        override fun invoke(project: Project, editor: Editor?, file: KtFile) {
             element.delete()
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/KotlinInvalidBundleOrPropertyInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/KotlinInvalidBundleOrPropertyInspection.kt
index 4bd2c898b30..3e24928ee6f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/KotlinInvalidBundleOrPropertyInspection.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/KotlinInvalidBundleOrPropertyInspection.kt
@@ -39,8 +39,8 @@ class KotlinInvalidBundleOrPropertyInspection : AbstractKotlinInspection() {
     override fun getDisplayName() = CodeInsightBundle.message("inspection.unresolved.property.key.reference.name")
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        return object : JetVisitorVoid() {
-            private fun processResourceBundleReference(ref: ResourceBundleReference, template: JetStringTemplateExpression) {
+        return object : KtVisitorVoid() {
+            private fun processResourceBundleReference(ref: ResourceBundleReference, template: KtStringTemplateExpression) {
                 if (ref.resolve() == null) {
                     holder.registerProblem(
                             template,
@@ -51,7 +51,7 @@ class KotlinInvalidBundleOrPropertyInspection : AbstractKotlinInspection() {
                 }
             }
 
-            private fun processPropertyReference(ref: PropertyReference, template: JetStringTemplateExpression) {
+            private fun processPropertyReference(ref: PropertyReference, template: KtStringTemplateExpression) {
                 val property = ref.resolve() as? Property
                 if (property == null) {
                     holder.registerProblem(
@@ -64,10 +64,10 @@ class KotlinInvalidBundleOrPropertyInspection : AbstractKotlinInspection() {
                     return
                 }
 
-                val argument = template.parents.firstIsInstanceOrNull<JetValueArgument>() ?: return
-                if (argument.getArgumentExpression() != JetPsiUtil.deparenthesize(template) ) return
+                val argument = template.parents.firstIsInstanceOrNull<KtValueArgument>() ?: return
+                if (argument.getArgumentExpression() != KtPsiUtil.deparenthesize(template) ) return
 
-                val callExpression = argument.getStrictParentOfType<JetCallExpression>() ?: return
+                val callExpression = argument.getStrictParentOfType<KtCallExpression>() ?: return
                 val resolvedCall = callExpression.getResolvedCall(callExpression.analyze(BodyResolveMode.PARTIAL)) ?: return
 
                 val resolvedArguments = resolvedCall.valueArgumentsByIndex ?: return
@@ -91,7 +91,7 @@ class KotlinInvalidBundleOrPropertyInspection : AbstractKotlinInspection() {
                 }
             }
 
-            override fun visitStringTemplateExpression(expression: JetStringTemplateExpression) {
+            override fun visitStringTemplateExpression(expression: KtStringTemplateExpression) {
                 for (ref in expression.references) {
                     when (ref) {
                         is ResourceBundleReference -> processResourceBundleReference(ref, expression)
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/RedundantSamConstructorInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/RedundantSamConstructorInspection.kt
index 1029575c0a5..02b04dae6df 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/RedundantSamConstructorInspection.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/RedundantSamConstructorInspection.kt
@@ -49,8 +49,8 @@ import org.jetbrains.kotlin.utils.addToStdlib.singletonList
 
 public class RedundantSamConstructorInspection : AbstractKotlinInspection() {
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean, session: LocalInspectionToolSession): PsiElementVisitor {
-        return object : JetVisitorVoid() {
-            private fun createQuickFix(expression: JetCallExpression): LocalQuickFix {
+        return object : KtVisitorVoid() {
+            private fun createQuickFix(expression: KtCallExpression): LocalQuickFix {
                 return object : LocalQuickFix {
                     override fun getName() = "Remove redundant SAM-constructor"
                     override fun getFamilyName() = name
@@ -60,7 +60,7 @@ public class RedundantSamConstructorInspection : AbstractKotlinInspection() {
                 }
             }
 
-            private fun createQuickFix(expressions: List<JetCallExpression>): LocalQuickFix {
+            private fun createQuickFix(expressions: List<KtCallExpression>): LocalQuickFix {
                 return object : LocalQuickFix {
                     override fun getName() = "Remove redundant SAM-constructors"
                     override fun getFamilyName() = name
@@ -72,7 +72,7 @@ public class RedundantSamConstructorInspection : AbstractKotlinInspection() {
                 }
             }
 
-            override fun visitCallExpression(expression: JetCallExpression) {
+            override fun visitCallExpression(expression: KtCallExpression) {
                 if (expression.valueArguments.isEmpty()) return
 
                 val samConstructorCalls = samConstructorCallsToBeConverted(expression)
@@ -104,13 +104,13 @@ public class RedundantSamConstructorInspection : AbstractKotlinInspection() {
     }
 
     companion  object {
-        public fun replaceSamConstructorCall(callExpression: JetCallExpression): JetExpression {
+        public fun replaceSamConstructorCall(callExpression: KtCallExpression): KtExpression {
             val functionalArgument = callExpression.samConstructorValueArgument()?.getArgumentExpression()
                                      ?: throw AssertionError("SAM-constructor should have a FunctionLiteralExpression as single argument: ${callExpression.getElementTextWithContext()}")
-            return callExpression.replace(functionalArgument) as JetExpression
+            return callExpression.replace(functionalArgument) as KtExpression
         }
 
-        private fun canBeReplaced(parentCall: JetCallExpression, callExpressions: List<JetCallExpression>): Boolean {
+        private fun canBeReplaced(parentCall: KtCallExpression, callExpressions: List<KtCallExpression>): Boolean {
             val context = parentCall.analyze(BodyResolveMode.PARTIAL)
 
             val calleeExpression = parentCall.calleeExpression ?: return false
@@ -133,15 +133,15 @@ public class RedundantSamConstructorInspection : AbstractKotlinInspection() {
             return samAdapterOriginalDescriptor.original == originalCall.resultingDescriptor.original
         }
 
-        private class CallWithNewArguments(original: Call, val callExpressions: List<JetCallExpression>): DelegatingCall(original) {
+        private class CallWithNewArguments(original: Call, val callExpressions: List<KtCallExpression>): DelegatingCall(original) {
             private val newArguments: List<ValueArgument>
 
             init {
-                val factory = JetPsiFactory(callElement)
+                val factory = KtPsiFactory(callElement)
                 newArguments = original.valueArguments.map { argument ->
                     argument.getArgumentExpression()
                             ?.check { callExpressions.contains(it) }
-                            ?.let { factory.createArgument(replaceSamConstructorCall(it.copy() as JetCallExpression), argument.getArgumentName()?.asName) }
+                            ?.let { factory.createArgument(replaceSamConstructorCall(it.copy() as KtCallExpression), argument.getArgumentName()?.asName) }
                     ?: argument
                 }
             }
@@ -149,7 +149,7 @@ public class RedundantSamConstructorInspection : AbstractKotlinInspection() {
             override fun getValueArguments() = newArguments
         }
 
-        public fun samConstructorCallsToBeConverted(functionCall: JetCallExpression): List<JetCallExpression> {
+        public fun samConstructorCallsToBeConverted(functionCall: KtCallExpression): List<KtCallExpression> {
             if (functionCall.valueArguments.all { !canBeSamConstructorCall(it) }) {
                 return emptyList()
             }
@@ -159,7 +159,7 @@ public class RedundantSamConstructorInspection : AbstractKotlinInspection() {
             if (!functionResolvedCall.isReallySuccess()) return emptyList()
 
             val samConstructorCalls = functionCall.valueArguments.map {
-                (it.getArgumentExpression() as? JetCallExpression)
+                (it.getArgumentExpression() as? KtCallExpression)
                         ?.check { it.getResolvedCall(bindingContext)?.resultingDescriptor?.original is SamConstructorDescriptor }
             }.filterNotNull()
 
@@ -194,15 +194,15 @@ public class RedundantSamConstructorInspection : AbstractKotlinInspection() {
             return emptyList()
         }
 
-        private fun canBeSamConstructorCall(argument: JetValueArgument): Boolean {
+        private fun canBeSamConstructorCall(argument: KtValueArgument): Boolean {
             val argumentExpression = argument.getArgumentExpression()
-            if (argumentExpression !is JetCallExpression) return false
+            if (argumentExpression !is KtCallExpression) return false
 
             return argumentExpression.samConstructorValueArgument() != null
         }
 
-        private fun JetCallExpression.samConstructorValueArgument(): JetValueArgument? {
-            return valueArguments.singleOrNull()?.check { it.getArgumentExpression() is JetFunctionLiteralExpression }
+        private fun KtCallExpression.samConstructorValueArgument(): KtValueArgument? {
+            return valueArguments.singleOrNull()?.check { it.getArgumentExpression() is KtFunctionLiteralExpression }
         }
 
         private fun isSamAdapterSuitableForCall(
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedImportInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedImportInspection.kt
index 3b377a8a52b..40e8a7fbd27 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedImportInspection.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedImportInspection.kt
@@ -46,7 +46,7 @@ import org.jetbrains.kotlin.idea.core.targetDescriptors
 import org.jetbrains.kotlin.idea.imports.KotlinImportOptimizer
 import org.jetbrains.kotlin.idea.imports.importableFqName
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.ImportPath
 import java.util.*
 
@@ -54,7 +54,7 @@ class UnusedImportInspection : AbstractKotlinInspection() {
     override fun runForWholeFile() = true
 
     override fun checkFile(file: PsiFile, manager: InspectionManager, isOnTheFly: Boolean): Array<out ProblemDescriptor>? {
-        if (file !is JetFile) return null
+        if (file !is KtFile) return null
         if (!file.manager.isInProject(file)) return null
         if (file.importDirectives.isEmpty()) return null
 
@@ -125,7 +125,7 @@ class UnusedImportInspection : AbstractKotlinInspection() {
         return problems.toTypedArray()
     }
 
-    private fun scheduleOptimizeImportsOnTheFly(file: JetFile, descriptorsToImport: Set<DeclarationDescriptor>) {
+    private fun scheduleOptimizeImportsOnTheFly(file: KtFile, descriptorsToImport: Set<DeclarationDescriptor>) {
         if (!CodeInsightSettings.getInstance().OPTIMIZE_IMPORTS_ON_THE_FLY) return
         val optimizedImports = KotlinImportOptimizer.prepareOptimizedImports(file, descriptorsToImport) ?: return // return if already optimized
 
@@ -160,7 +160,7 @@ class UnusedImportInspection : AbstractKotlinInspection() {
         }
     }
 
-    private fun timeToOptimizeImportsOnTheFly(file: JetFile, editor: Editor, project: Project): Boolean {
+    private fun timeToOptimizeImportsOnTheFly(file: KtFile, editor: Editor, project: Project): Boolean {
         if (project.isDisposed || !file.isValid || editor.isDisposed || !file.isWritable) return false
 
         // do not optimize imports on the fly during undo/redo
@@ -191,7 +191,7 @@ class UnusedImportInspection : AbstractKotlinInspection() {
         return DaemonListeners.canChangeFileSilently(file)
     }
 
-    private fun optimizeImportsOnTheFly(file: JetFile, optimizedImports: List<ImportPath>, editor: Editor, project: Project) {
+    private fun optimizeImportsOnTheFly(file: KtFile, optimizedImports: List<ImportPath>, editor: Editor, project: Project) {
         PsiDocumentManager.getInstance(file.project).commitAllDocuments()
         DocumentUtil.writeInRunUndoTransparentAction {
             KotlinImportOptimizer.replaceImports(file, optimizedImports)
@@ -199,7 +199,7 @@ class UnusedImportInspection : AbstractKotlinInspection() {
         }
     }
 
-    private class OptimizeImportsQuickFix(private val file: JetFile): LocalQuickFix {
+    private class OptimizeImportsQuickFix(private val file: KtFile): LocalQuickFix {
         override fun getName() = "Optimize imports"
 
         override fun getFamilyName() = name
@@ -209,7 +209,7 @@ class UnusedImportInspection : AbstractKotlinInspection() {
         }
     }
 
-    private class EnableOptimizeImportsOnTheFlyFix(private val file: JetFile) : LocalQuickFix, LowPriorityAction {
+    private class EnableOptimizeImportsOnTheFlyFix(private val file: KtFile) : LocalQuickFix, LowPriorityAction {
         override fun getName() = QuickFixBundle.message("enable.optimize.imports.on.the.fly")
 
         override fun getFamilyName() = name
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedReceiverParameterInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedReceiverParameterInspection.kt
index eb2e406a5da..1d081408883 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedReceiverParameterInspection.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedReceiverParameterInspection.kt
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.idea.JetBundle
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.search.usagesSearch.descriptor
 import org.jetbrains.kotlin.idea.util.getThisReceiverOwner
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.isOverridable
 import org.jetbrains.kotlin.psi.typeRefHelpers.setReceiverTypeReference
@@ -40,20 +40,20 @@ import kotlin.properties.Delegates
 
 public class UnusedReceiverParameterInspection : AbstractKotlinInspection() {
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean, session: LocalInspectionToolSession): PsiElementVisitor {
-        return object : JetVisitorVoid() {
-            private fun check(callableDeclaration: JetCallableDeclaration) {
+        return object : KtVisitorVoid() {
+            private fun check(callableDeclaration: KtCallableDeclaration) {
                 val receiverTypeReference = callableDeclaration.getReceiverTypeReference()
                 if (receiverTypeReference == null || receiverTypeReference.textRange.isEmpty) return
-                if (callableDeclaration.isOverridable() || callableDeclaration.hasModifier(JetTokens.OVERRIDE_KEYWORD)) return
+                if (callableDeclaration.isOverridable() || callableDeclaration.hasModifier(KtTokens.OVERRIDE_KEYWORD)) return
 
-                if (callableDeclaration is JetProperty && callableDeclaration.getAccessors().isEmpty()) return
-                if (callableDeclaration is JetNamedFunction && !callableDeclaration.hasBody()) return
+                if (callableDeclaration is KtProperty && callableDeclaration.getAccessors().isEmpty()) return
+                if (callableDeclaration is KtNamedFunction && !callableDeclaration.hasBody()) return
 
                 val callable = callableDeclaration.descriptor
 
                 var used = false
-                callableDeclaration.acceptChildren(object : JetVisitorVoid() {
-                    override fun visitJetElement(element: JetElement) {
+                callableDeclaration.acceptChildren(object : KtVisitorVoid() {
+                    override fun visitJetElement(element: KtElement) {
                         if (used) return
                         element.acceptChildren(this)
 
@@ -80,17 +80,17 @@ public class UnusedReceiverParameterInspection : AbstractKotlinInspection() {
                 }
             }
 
-            override fun visitNamedFunction(function: JetNamedFunction) {
+            override fun visitNamedFunction(function: KtNamedFunction) {
                 check(function)
             }
 
-            override fun visitProperty(property: JetProperty) {
+            override fun visitProperty(property: KtProperty) {
                 check(property)
             }
         }
     }
 
-    private class MyQuickFix(val declaration: JetCallableDeclaration): LocalQuickFix {
+    private class MyQuickFix(val declaration: KtCallableDeclaration): LocalQuickFix {
         override fun getName(): String {
             return JetBundle.message("unused.receiver.parameter.remove")
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt
index e73f4d12a85..2bcee720505 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt
@@ -48,7 +48,7 @@ import org.jetbrains.kotlin.idea.findUsages.KotlinFindUsagesHandlerFactory
 import org.jetbrains.kotlin.idea.findUsages.handlers.KotlinFindClassUsagesHandler
 import org.jetbrains.kotlin.idea.search.usagesSearch.*
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
@@ -70,11 +70,11 @@ public class UnusedSymbolInspection : AbstractKotlinInspection() {
     companion object {
         private val javaInspection = UnusedDeclarationInspection()
 
-        public fun isEntryPoint(declaration: JetNamedDeclaration): Boolean {
+        public fun isEntryPoint(declaration: KtNamedDeclaration): Boolean {
             val lightElement: PsiElement? = when (declaration) {
-                is JetClassOrObject -> declaration.toLightClass()
-                is JetNamedFunction, is JetSecondaryConstructor -> LightClassUtil.getLightClassMethod(declaration as JetFunction)
-                is JetProperty -> {
+                is KtClassOrObject -> declaration.toLightClass()
+                is KtNamedFunction, is KtSecondaryConstructor -> LightClassUtil.getLightClassMethod(declaration as KtFunction)
+                is KtProperty -> {
                     // can't rely on light element, check annotation ourselves
                     val descriptor = declaration.descriptor ?: return false
                     val entryPointsManager = EntryPointsManager.getInstance(declaration.getProject()) as EntryPointsManagerBase
@@ -88,17 +88,17 @@ public class UnusedSymbolInspection : AbstractKotlinInspection() {
             return lightElement != null && javaInspection.isEntryPoint(lightElement)
         }
 
-        private fun JetProperty.isSerializationImplicitlyUsedField(): Boolean {
-            val ownerObject = getNonStrictParentOfType<JetClassOrObject>()
-            if (ownerObject is JetObjectDeclaration && ownerObject.isCompanion()) {
-                val lightClass = ownerObject.getNonStrictParentOfType<JetClass>()?.toLightClass() ?: return false
+        private fun KtProperty.isSerializationImplicitlyUsedField(): Boolean {
+            val ownerObject = getNonStrictParentOfType<KtClassOrObject>()
+            if (ownerObject is KtObjectDeclaration && ownerObject.isCompanion()) {
+                val lightClass = ownerObject.getNonStrictParentOfType<KtClass>()?.toLightClass() ?: return false
                 return lightClass.getFields().any { it.getName() == getName() && HighlightUtil.isSerializationImplicitlyUsedField(it) }
             }
             return false
         }
 
-        private fun JetObjectDeclaration.hasSerializationImplicitlyUsedField(): Boolean {
-            return getDeclarations().any { it is JetProperty && it.isSerializationImplicitlyUsedField() }
+        private fun KtObjectDeclaration.hasSerializationImplicitlyUsedField(): Boolean {
+            return getDeclarations().any { it is KtProperty && it.isSerializationImplicitlyUsedField() }
         }
 
         // variation of IDEA's AnnotationUtil.checkAnnotatedUsingPatterns()
@@ -128,8 +128,8 @@ public class UnusedSymbolInspection : AbstractKotlinInspection() {
     override fun runForWholeFile() = true
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean, session: LocalInspectionToolSession): PsiElementVisitor {
-        return object : JetVisitorVoid() {
-            private fun createQuickFix(declaration: JetNamedDeclaration): LocalQuickFix {
+        return object : KtVisitorVoid() {
+            private fun createQuickFix(declaration: KtNamedDeclaration): LocalQuickFix {
                 return object : LocalQuickFix {
                     override fun getName() = QuickFixBundle.message("safe.delete.text", declaration.getName())
 
@@ -142,41 +142,41 @@ public class UnusedSymbolInspection : AbstractKotlinInspection() {
                 }
             }
 
-            override fun visitNamedDeclaration(declaration: JetNamedDeclaration) {
+            override fun visitNamedDeclaration(declaration: KtNamedDeclaration) {
                 val messageKey = when (declaration) {
-                    is JetClass -> "unused.class"
-                    is JetObjectDeclaration -> "unused.object"
-                    is JetNamedFunction -> "unused.function"
-                    is JetProperty, is JetParameter -> "unused.property"
-                    is JetTypeParameter -> "unused.type.parameter"
+                    is KtClass -> "unused.class"
+                    is KtObjectDeclaration -> "unused.object"
+                    is KtNamedFunction -> "unused.function"
+                    is KtProperty, is KtParameter -> "unused.property"
+                    is KtTypeParameter -> "unused.type.parameter"
                     else -> return
                 }
 
                 if (!ProjectRootsUtil.isInProjectSource(declaration)) return
 
                 // Simple PSI-based checks
-                val isCompanionObject = declaration is JetObjectDeclaration && declaration.isCompanion()
+                val isCompanionObject = declaration is KtObjectDeclaration && declaration.isCompanion()
                 if (declaration.getName() == null) return
-                if (declaration is JetEnumEntry) return
-                if (declaration.hasModifier(JetTokens.OVERRIDE_KEYWORD)) return
-                if (declaration is JetProperty && declaration.isLocal()) return
-                if (declaration is JetParameter && (declaration.getParent()?.getParent() !is JetPrimaryConstructor || !declaration.hasValOrVar())) return
-                if (declaration is JetNamedFunction && isConventionalName(declaration)) return
+                if (declaration is KtEnumEntry) return
+                if (declaration.hasModifier(KtTokens.OVERRIDE_KEYWORD)) return
+                if (declaration is KtProperty && declaration.isLocal()) return
+                if (declaration is KtParameter && (declaration.getParent()?.getParent() !is KtPrimaryConstructor || !declaration.hasValOrVar())) return
+                if (declaration is KtNamedFunction && isConventionalName(declaration)) return
 
                 // More expensive, resolve-based checks
                 if (declaration.resolveToDescriptorIfAny() == null) return
                 if (isEntryPoint(declaration)) return
-                if (declaration is JetProperty && declaration.isSerializationImplicitlyUsedField()) return
-                if (isCompanionObject && (declaration as JetObjectDeclaration).hasSerializationImplicitlyUsedField()) return
+                if (declaration is KtProperty && declaration.isSerializationImplicitlyUsedField()) return
+                if (isCompanionObject && (declaration as KtObjectDeclaration).hasSerializationImplicitlyUsedField()) return
                 // properties can be referred by component1/component2, which is too expensive to search, don't mark them as unused
-                if (declaration is JetParameter && declaration.dataClassComponentFunction() != null) return
+                if (declaration is KtParameter && declaration.dataClassComponentFunction() != null) return
 
                 // Main checks: finding reference usages && text usages
                 if (hasNonTrivialUsages(declaration)) return
-                if (declaration is JetClassOrObject && classOrObjectHasTextUsages(declaration)) return
+                if (declaration is KtClassOrObject && classOrObjectHasTextUsages(declaration)) return
 
                 val (inspectionTarget, textRange) = if (isCompanionObject && declaration.getNameIdentifier() == null) {
-                    val objectKeyword = (declaration as JetObjectDeclaration).getObjectKeyword()
+                    val objectKeyword = (declaration as KtObjectDeclaration).getObjectKeyword()
                     Pair(declaration, TextRange(0, objectKeyword.getStartOffsetInParent() + objectKeyword.getTextLength()))
                 } else {
                     Pair(declaration.getNameIdentifier()!!, null)
@@ -196,7 +196,7 @@ public class UnusedSymbolInspection : AbstractKotlinInspection() {
         }
     }
 
-    private fun classOrObjectHasTextUsages(classOrObject: JetClassOrObject): Boolean {
+    private fun classOrObjectHasTextUsages(classOrObject: KtClassOrObject): Boolean {
         var hasTextUsages = false
 
         // Finding text usages
@@ -212,12 +212,12 @@ public class UnusedSymbolInspection : AbstractKotlinInspection() {
         return hasTextUsages
     }
 
-    private fun isConventionalName(namedDeclaration: JetNamedDeclaration): Boolean {
+    private fun isConventionalName(namedDeclaration: KtNamedDeclaration): Boolean {
         val name = namedDeclaration.getNameAsName()
         return name!!.getOperationSymbolsToSearch().isNotEmpty() || name == OperatorNameConventions.INVOKE
     }
 
-    private fun hasNonTrivialUsages(declaration: JetNamedDeclaration): Boolean {
+    private fun hasNonTrivialUsages(declaration: KtNamedDeclaration): Boolean {
         val psiSearchHelper = PsiSearchHelper.SERVICE.getInstance(declaration.getProject())
 
         val useScope = declaration.getUseScope()
@@ -234,7 +234,7 @@ public class UnusedSymbolInspection : AbstractKotlinInspection() {
             }
 
             if (zeroOccurrences) {
-                if (declaration is JetObjectDeclaration && declaration.isCompanion()) {
+                if (declaration is KtObjectDeclaration && declaration.isCompanion()) {
                     // go on: companion object can be used only in containing class
                 }
                 else {
@@ -243,23 +243,23 @@ public class UnusedSymbolInspection : AbstractKotlinInspection() {
             }
         }
 
-        return (declaration is JetObjectDeclaration && declaration.isCompanion() &&
+        return (declaration is KtObjectDeclaration && declaration.isCompanion() &&
                 declaration.getBody()?.declarations?.isNotEmpty() == true) ||
                hasReferences(declaration, useScope) ||
                hasOverrides(declaration, useScope)
 
     }
 
-    private fun hasReferences(declaration: JetNamedDeclaration, useScope: SearchScope): Boolean {
+    private fun hasReferences(declaration: KtNamedDeclaration, useScope: SearchScope): Boolean {
         return !ReferencesSearch.search(declaration, useScope).forEach(Processor {
             assert(it != null, { "Found reference is null, was looking for: " + declaration.getElementTextWithContext() })
             declaration.isAncestor(it.getElement()) ||
-            it.element.parent is JetValueArgumentName ||
-            it.element.getParentOfType<JetImportDirective>(false) != null
+            it.element.parent is KtValueArgumentName ||
+            it.element.getParentOfType<KtImportDirective>(false) != null
         })
     }
 
-    private fun hasOverrides(declaration: JetNamedDeclaration, useScope: SearchScope): Boolean {
+    private fun hasOverrides(declaration: KtNamedDeclaration, useScope: SearchScope): Boolean {
         return DefinitionsScopedSearch.search(declaration, useScope).findFirst() != null
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/AddBracesIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/AddBracesIntention.kt
index 57892487ac3..991699df6c9 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/AddBracesIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/AddBracesIntention.kt
@@ -21,34 +21,34 @@ import com.intellij.psi.PsiWhiteSpace
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
-public class AddBracesIntention : JetSelfTargetingIntention<JetExpression>(javaClass(), "Add braces") {
-    override fun isApplicableTo(element: JetExpression, caretOffset: Int): Boolean {
+public class AddBracesIntention : JetSelfTargetingIntention<KtExpression>(javaClass(), "Add braces") {
+    override fun isApplicableTo(element: KtExpression, caretOffset: Int): Boolean {
         val expression = element.getTargetExpression(caretOffset) ?: return false
-        if (expression is JetBlockExpression) return false
+        if (expression is KtBlockExpression) return false
 
-        val description = (expression.getParent() as JetContainerNode).description()!!
+        val description = (expression.getParent() as KtContainerNode).description()!!
         setText("Add braces to '$description' statement")
         return true
     }
 
-    override fun applyTo(element: JetExpression, editor: Editor) {
+    override fun applyTo(element: KtExpression, editor: Editor) {
         val expression = element.getTargetExpression(editor.getCaretModel().getOffset())!!
 
         if (element.getNextSibling()?.getText() == ";") {
             element.getNextSibling()!!.delete()
         }
 
-        val psiFactory = JetPsiFactory(element)
+        val psiFactory = KtPsiFactory(element)
         expression.replace(psiFactory.createSingleStatementBlock(expression))
 
-        if (element is JetDoWhileExpression) { // remove new line between '}' and while
+        if (element is KtDoWhileExpression) { // remove new line between '}' and while
             (element.getBody()!!.getParent().getNextSibling() as? PsiWhiteSpace)?.delete()
         }
     }
 
-    private fun JetExpression.getTargetExpression(caretLocation: Int): JetExpression? {
+    private fun KtExpression.getTargetExpression(caretLocation: Int): KtExpression? {
         when (this) {
-            is JetIfExpression -> {
+            is KtIfExpression -> {
                 val thenExpr = getThen() ?: return null
                 val elseExpr = getElse()
                 if (elseExpr != null && caretLocation >= getElseKeyword()!!.startOffset) {
@@ -57,11 +57,11 @@ public class AddBracesIntention : JetSelfTargetingIntention<JetExpression>(javaC
                 return thenExpr
             }
 
-            is JetWhileExpression -> return getBody()
+            is KtWhileExpression -> return getBody()
 
-            is JetDoWhileExpression -> return getBody()
+            is KtDoWhileExpression -> return getBody()
 
-            is JetForExpression -> return getBody()
+            is KtForExpression -> return getBody()
 
             else -> return null
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/AddForLoopIndicesIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/AddForLoopIndicesIntention.kt
index bc22fdd27b0..02f24efab40 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/AddForLoopIndicesIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/AddForLoopIndicesIntention.kt
@@ -32,10 +32,10 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 
-public class AddForLoopIndicesIntention : JetSelfTargetingRangeIntention<JetForExpression>(javaClass(), "Add indices to 'for' loop"), LowPriorityAction {
+public class AddForLoopIndicesIntention : JetSelfTargetingRangeIntention<KtForExpression>(javaClass(), "Add indices to 'for' loop"), LowPriorityAction {
     private val WITH_INDEX_FQ_NAME = "kotlin.withIndex"
 
-    override fun applicabilityRange(element: JetForExpression): TextRange? {
+    override fun applicabilityRange(element: KtForExpression): TextRange? {
         if (element.loopParameter == null) return null
         val loopRange = element.loopRange ?: return null
 
@@ -54,14 +54,14 @@ public class AddForLoopIndicesIntention : JetSelfTargetingRangeIntention<JetForE
         return TextRange(element.startOffset, element.body?.startOffset ?: element.endOffset)
     }
 
-    override fun applyTo(element: JetForExpression, editor: Editor) {
+    override fun applyTo(element: KtForExpression, editor: Editor) {
         val loopRange = element.loopRange!!
         val loopParameter = element.loopParameter!!
-        val psiFactory = JetPsiFactory(element)
+        val psiFactory = KtPsiFactory(element)
 
         loopRange.replace(createWithIndexExpression(loopRange))
 
-        var multiParameter = (psiFactory.createExpressionByPattern("for((index, $0) in x){}", loopParameter.text) as JetForExpression).multiParameter!!
+        var multiParameter = (psiFactory.createExpressionByPattern("for((index, $0) in x){}", loopParameter.text) as KtForExpression).multiParameter!!
 
         multiParameter = loopParameter.replaced(multiParameter)
 
@@ -71,7 +71,7 @@ public class AddForLoopIndicesIntention : JetSelfTargetingRangeIntention<JetForE
         runTemplate(editor, element, indexVariable)
     }
 
-    private fun runTemplate(editor: Editor, forExpression: JetForExpression, indexVariable: JetMultiDeclarationEntry) {
+    private fun runTemplate(editor: Editor, forExpression: KtForExpression, indexVariable: KtMultiDeclarationEntry) {
         PsiDocumentManager.getInstance(forExpression.project).doPostponedOperationsAndUnblockDocument(editor.document)
 
         val templateBuilder = TemplateBuilderImpl(forExpression)
@@ -79,7 +79,7 @@ public class AddForLoopIndicesIntention : JetSelfTargetingRangeIntention<JetForE
 
         val body = forExpression.body
         when (body) {
-            is JetBlockExpression -> {
+            is KtBlockExpression -> {
                 val statement = body.statements.firstOrNull()
                 if (statement != null) {
                     templateBuilder.setEndVariableBefore(statement)
@@ -97,7 +97,7 @@ public class AddForLoopIndicesIntention : JetSelfTargetingRangeIntention<JetForE
         templateBuilder.run(editor, true)
     }
 
-    private fun createWithIndexExpression(originalExpression: JetExpression): JetExpression {
-        return JetPsiFactory(originalExpression).createExpressionByPattern("$0.withIndex()", originalExpression)
+    private fun createWithIndexExpression(originalExpression: KtExpression): KtExpression {
+        return KtPsiFactory(originalExpression).createExpressionByPattern("$0.withIndex()", originalExpression)
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/AddNameToArgumentIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/AddNameToArgumentIntention.kt
index ef55f433491..4650f279985 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/AddNameToArgumentIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/AddNameToArgumentIntention.kt
@@ -32,15 +32,15 @@ import org.jetbrains.kotlin.resolve.calls.model.VarargValueArgument
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 
 public class AddNameToArgumentIntention
-  : JetSelfTargetingIntention<JetValueArgument>(javaClass(), "Add name to argument"), LowPriorityAction {
+  : JetSelfTargetingIntention<KtValueArgument>(javaClass(), "Add name to argument"), LowPriorityAction {
 
-    override fun isApplicableTo(element: JetValueArgument, caretOffset: Int): Boolean {
+    override fun isApplicableTo(element: KtValueArgument, caretOffset: Int): Boolean {
         val expression = element.getArgumentExpression() ?: return false
         val name = detectNameToAdd(element) ?: return false
 
         setText("Add '$name =' to argument")
 
-        if (expression is JetFunctionLiteralExpression) {
+        if (expression is KtFunctionLiteralExpression) {
             val range = expression.getTextRange()
             return caretOffset == range.start || caretOffset == range.end
         }
@@ -49,22 +49,22 @@ public class AddNameToArgumentIntention
     }
 
     override fun allowCaretInsideElement(element: PsiElement)
-            = element !is JetValueArgumentList && element !is JetContainerNode
+            = element !is KtValueArgumentList && element !is KtContainerNode
 
-    override fun applyTo(element: JetValueArgument, editor: Editor) {
+    override fun applyTo(element: KtValueArgument, editor: Editor) {
         val name = detectNameToAdd(element)!!
-        val newArgument = JetPsiFactory(element).createArgument(element.getArgumentExpression()!!, name, element.getSpreadElement() != null)
+        val newArgument = KtPsiFactory(element).createArgument(element.getArgumentExpression()!!, name, element.getSpreadElement() != null)
         element.replace(newArgument)
     }
 
-    private fun detectNameToAdd(argument: JetValueArgument): Name? {
+    private fun detectNameToAdd(argument: KtValueArgument): Name? {
         if (argument.isNamed()) return null
-        if (argument is JetFunctionLiteralArgument) return null
+        if (argument is KtFunctionLiteralArgument) return null
 
-        val argumentList = argument.getParent() as? JetValueArgumentList ?: return null
+        val argumentList = argument.getParent() as? KtValueArgumentList ?: return null
         if (argument != argumentList.arguments.last { !it.isNamed() }) return null
 
-        val callExpr = argumentList.getParent() as? JetExpression ?: return null
+        val callExpr = argumentList.getParent() as? KtExpression ?: return null
         val resolvedCall = callExpr.getResolvedCall(callExpr.analyze(BodyResolveMode.PARTIAL)) ?: return null
         val argumentMatch = resolvedCall.getArgumentMapping(argument) as? ArgumentMatch ?: return null
         if (argumentMatch.status != ArgumentMatchStatus.SUCCESS) return null
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/AddOperatorModifierIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/AddOperatorModifierIntention.kt
index 275fbb00c22..25f8b722b2b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/AddOperatorModifierIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/AddOperatorModifierIntention.kt
@@ -20,24 +20,24 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.util.OperatorChecks
 
-class AddOperatorModifierIntention : JetSelfTargetingRangeIntention<JetNamedFunction>(JetNamedFunction::class.java, "Add 'operator' modifier") {
-    override fun applicabilityRange(element: JetNamedFunction): TextRange? {
+class AddOperatorModifierIntention : JetSelfTargetingRangeIntention<KtNamedFunction>(KtNamedFunction::class.java, "Add 'operator' modifier") {
+    override fun applicabilityRange(element: KtNamedFunction): TextRange? {
         val nameIdentifier = element.nameIdentifier ?: return null
         val functionDescriptor = element.resolveToDescriptor() as? FunctionDescriptor ?: return null
         if (functionDescriptor.isOperator || !OperatorChecks.canBeOperator(functionDescriptor)) return null
         return nameIdentifier.textRange
     }
 
-    override fun applyTo(element: JetNamedFunction, editor: Editor) {
+    override fun applyTo(element: KtNamedFunction, editor: Editor) {
         applyTo(element)
     }
 
-    fun applyTo(element: JetNamedFunction) {
-        element.addModifier(JetTokens.OPERATOR_KEYWORD)
+    fun applyTo(element: KtNamedFunction) {
+        element.addModifier(KtTokens.OPERATOR_KEYWORD)
     }
 }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ChangeVisibilityModifierIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ChangeVisibilityModifierIntention.kt
index 0bc72e6b427..e9943e23b0e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ChangeVisibilityModifierIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ChangeVisibilityModifierIntention.kt
@@ -23,18 +23,18 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.core.setVisibility
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.psi.psiUtil.visibilityModifier
 import org.jetbrains.kotlin.resolve.BindingContext
 
 public open class ChangeVisibilityModifierIntention protected constructor(
-        val modifier: JetModifierKeywordToken
-) : JetSelfTargetingRangeIntention<JetDeclaration>(javaClass(), "Make ${modifier.getValue()}") {
+        val modifier: KtModifierKeywordToken
+) : JetSelfTargetingRangeIntention<KtDeclaration>(javaClass(), "Make ${modifier.getValue()}") {
 
-    override fun applicabilityRange(element: JetDeclaration): TextRange? {
+    override fun applicabilityRange(element: KtDeclaration): TextRange? {
         val modifierList = element.getModifierList()
         if (modifierList?.hasModifier(modifier) ?: false) return null
 
@@ -42,7 +42,7 @@ public open class ChangeVisibilityModifierIntention protected constructor(
         val targetVisibility = modifier.toVisibility()
         if (descriptor.getVisibility() == targetVisibility) return null
 
-        if (modifierList?.hasModifier(JetTokens.OVERRIDE_KEYWORD) ?: false) {
+        if (modifierList?.hasModifier(KtTokens.OVERRIDE_KEYWORD) ?: false) {
             val callableDescriptor = descriptor  as? CallableDescriptor ?: return null
             // cannot make visibility less than (or non-comparable with) any of the supers
             if (callableDescriptor.getOverriddenDescriptors()
@@ -59,7 +59,7 @@ public open class ChangeVisibilityModifierIntention protected constructor(
 
         val defaultRange = noModifierYetApplicabilityRange(element) ?: return null
 
-        if (element is JetPrimaryConstructor && defaultRange.isEmpty()) {
+        if (element is KtPrimaryConstructor && defaultRange.isEmpty()) {
             setText("Make primary constructor ${modifier.getValue()}") // otherwise it may be confusing
         }
 
@@ -69,10 +69,10 @@ public open class ChangeVisibilityModifierIntention protected constructor(
             defaultRange
     }
 
-    private fun JetDeclaration.toDescriptor(): DeclarationDescriptor? {
+    private fun KtDeclaration.toDescriptor(): DeclarationDescriptor? {
         val bindingContext = analyze()
         // TODO: temporary code
-        if (this is JetPrimaryConstructor) {
+        if (this is KtPrimaryConstructor) {
             return (this.getContainingClassOrObject().resolveToDescriptor() as ClassDescriptor).getUnsubstitutedPrimaryConstructor()
         }
 
@@ -83,60 +83,60 @@ public open class ChangeVisibilityModifierIntention protected constructor(
         return descriptor
     }
 
-    override fun applyTo(element: JetDeclaration, editor: Editor) {
+    override fun applyTo(element: KtDeclaration, editor: Editor) {
         element.setVisibility(modifier)
     }
 
-    private fun JetModifierKeywordToken.toVisibility(): Visibility {
+    private fun KtModifierKeywordToken.toVisibility(): Visibility {
         return when (this) {
-            JetTokens.PUBLIC_KEYWORD -> Visibilities.PUBLIC
-            JetTokens.PRIVATE_KEYWORD -> Visibilities.PRIVATE
-            JetTokens.PROTECTED_KEYWORD -> Visibilities.PROTECTED
-            JetTokens.INTERNAL_KEYWORD -> Visibilities.INTERNAL
+            KtTokens.PUBLIC_KEYWORD -> Visibilities.PUBLIC
+            KtTokens.PRIVATE_KEYWORD -> Visibilities.PRIVATE
+            KtTokens.PROTECTED_KEYWORD -> Visibilities.PROTECTED
+            KtTokens.INTERNAL_KEYWORD -> Visibilities.INTERNAL
             else -> throw IllegalArgumentException("Unknown visibility modifier:$this")
         }
     }
 
-    private fun noModifierYetApplicabilityRange(declaration: JetDeclaration): TextRange? {
-        if (JetPsiUtil.isLocal(declaration)) return null
+    private fun noModifierYetApplicabilityRange(declaration: KtDeclaration): TextRange? {
+        if (KtPsiUtil.isLocal(declaration)) return null
         return when (declaration) {
-            is JetNamedFunction -> declaration.getFunKeyword()?.getTextRange()
-            is JetProperty -> declaration.getValOrVarKeyword().getTextRange()
-            is JetClass -> declaration.getClassOrInterfaceKeyword()?.getTextRange()
-            is JetObjectDeclaration -> declaration.getObjectKeyword().getTextRange()
-            is JetPrimaryConstructor -> declaration.getValueParameterList()?.let { TextRange.from(it.startOffset, 0) } //TODO: use constructor keyword if exist
-            is JetSecondaryConstructor -> declaration.getConstructorKeyword().getTextRange()
-            is JetParameter -> declaration.getValOrVarKeyword()?.getTextRange()
+            is KtNamedFunction -> declaration.getFunKeyword()?.getTextRange()
+            is KtProperty -> declaration.getValOrVarKeyword().getTextRange()
+            is KtClass -> declaration.getClassOrInterfaceKeyword()?.getTextRange()
+            is KtObjectDeclaration -> declaration.getObjectKeyword().getTextRange()
+            is KtPrimaryConstructor -> declaration.getValueParameterList()?.let { TextRange.from(it.startOffset, 0) } //TODO: use constructor keyword if exist
+            is KtSecondaryConstructor -> declaration.getConstructorKeyword().getTextRange()
+            is KtParameter -> declaration.getValOrVarKeyword()?.getTextRange()
             else -> null
         }
     }
 
-    public class Public : ChangeVisibilityModifierIntention(JetTokens.PUBLIC_KEYWORD), HighPriorityAction
+    public class Public : ChangeVisibilityModifierIntention(KtTokens.PUBLIC_KEYWORD), HighPriorityAction
 
-    public class Private : ChangeVisibilityModifierIntention(JetTokens.PRIVATE_KEYWORD), HighPriorityAction {
-        override fun applicabilityRange(element: JetDeclaration): TextRange? {
+    public class Private : ChangeVisibilityModifierIntention(KtTokens.PRIVATE_KEYWORD), HighPriorityAction {
+        override fun applicabilityRange(element: KtDeclaration): TextRange? {
             return if (canBePrivate(element)) super<ChangeVisibilityModifierIntention>.applicabilityRange(element) else null
         }
 
-        private fun canBePrivate(declaration: JetDeclaration): Boolean {
-            if (declaration.getModifierList()?.hasModifier(JetTokens.ABSTRACT_KEYWORD) ?: false) return false
+        private fun canBePrivate(declaration: KtDeclaration): Boolean {
+            if (declaration.getModifierList()?.hasModifier(KtTokens.ABSTRACT_KEYWORD) ?: false) return false
             return true
         }
     }
 
-    public class Protected : ChangeVisibilityModifierIntention(JetTokens.PROTECTED_KEYWORD) {
-        override fun applicabilityRange(element: JetDeclaration): TextRange? {
+    public class Protected : ChangeVisibilityModifierIntention(KtTokens.PROTECTED_KEYWORD) {
+        override fun applicabilityRange(element: KtDeclaration): TextRange? {
             return if (canBeProtected(element)) super.applicabilityRange(element) else null
         }
 
-        private fun canBeProtected(declaration: JetDeclaration): Boolean {
+        private fun canBeProtected(declaration: KtDeclaration): Boolean {
             var parent = declaration.getParent()
-            if (parent is JetClassBody) {
+            if (parent is KtClassBody) {
                 parent = parent.getParent()
             }
-            return parent is JetClass
+            return parent is KtClass
         }
     }
 
-    public class Internal : ChangeVisibilityModifierIntention(JetTokens.INTERNAL_KEYWORD)
+    public class Internal : ChangeVisibilityModifierIntention(KtTokens.INTERNAL_KEYWORD)
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertAssertToIfWithThrowIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertAssertToIfWithThrowIntention.kt
index 5b7f8de9515..ed9c25f912f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertAssertToIfWithThrowIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertAssertToIfWithThrowIntention.kt
@@ -26,8 +26,8 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 
-public class ConvertAssertToIfWithThrowIntention : JetSelfTargetingIntention<JetCallExpression>(javaClass(), "Replace 'assert' with 'if' statement"), LowPriorityAction {
-    override fun isApplicableTo(element: JetCallExpression, caretOffset: Int): Boolean {
+public class ConvertAssertToIfWithThrowIntention : JetSelfTargetingIntention<KtCallExpression>(javaClass(), "Replace 'assert' with 'if' statement"), LowPriorityAction {
+    override fun isApplicableTo(element: KtCallExpression, caretOffset: Int): Boolean {
         val callee = element.getCalleeExpression() ?: return false
         if (!callee.getTextRange().containsOffset(caretOffset)) return false
 
@@ -41,13 +41,13 @@ public class ConvertAssertToIfWithThrowIntention : JetSelfTargetingIntention<Jet
         return DescriptorUtils.getFqName(resolvedCall.getResultingDescriptor()).asString() == "kotlin.assert"
     }
 
-    override fun applyTo(element: JetCallExpression, editor: Editor) {
+    override fun applyTo(element: KtCallExpression, editor: Editor) {
         val args = element.getValueArguments()
         val conditionText = args[0]?.getArgumentExpression()?.getText() ?: return
         val functionLiteral = element.getFunctionLiteralArguments().singleOrNull()
         val messageIsFunction = messageIsFunction(element)
 
-        val psiFactory = JetPsiFactory(element)
+        val psiFactory = KtPsiFactory(element)
 
         val messageExpr = when {
             args.size() == 2 -> args[1]?.getArgumentExpression() ?: return
@@ -60,17 +60,17 @@ public class ConvertAssertToIfWithThrowIntention : JetSelfTargetingIntention<Jet
         // shorten java.lang.AssertionError
         ShortenReferences.DEFAULT.process(ifExpression.getThen()!!)
 
-        val ifCondition = ifExpression.getCondition() as JetPrefixExpression
+        val ifCondition = ifExpression.getCondition() as KtPrefixExpression
         ifCondition.getBaseExpression()!!.replace(psiFactory.createExpression(conditionText))
 
-        val thrownExpression = ((ifExpression.getThen() as JetBlockExpression).getStatements().single() as JetThrowExpression).getThrownExpression()
-        val assertionErrorCall = if (thrownExpression is JetCallExpression)
+        val thrownExpression = ((ifExpression.getThen() as KtBlockExpression).getStatements().single() as KtThrowExpression).getThrownExpression()
+        val assertionErrorCall = if (thrownExpression is KtCallExpression)
             thrownExpression
         else
-            (thrownExpression as JetDotQualifiedExpression).getSelectorExpression() as JetCallExpression
+            (thrownExpression as KtDotQualifiedExpression).getSelectorExpression() as KtCallExpression
 
         val message = psiFactory.createExpression(
-                if (messageIsFunction && messageExpr is JetCallableReferenceExpression) {
+                if (messageIsFunction && messageExpr is KtCallableReferenceExpression) {
                     messageExpr.getCallableReference().getText() + "()"
                 }
                 else if (messageIsFunction) {
@@ -85,24 +85,24 @@ public class ConvertAssertToIfWithThrowIntention : JetSelfTargetingIntention<Jet
         simplifyConditionIfPossible(ifExpression)
     }
 
-    private fun messageIsFunction(callExpr: JetCallExpression): Boolean {
+    private fun messageIsFunction(callExpr: KtCallExpression): Boolean {
         val resolvedCall = callExpr.getResolvedCall(callExpr.analyze()) ?: return false
         val valParameters = resolvedCall.getResultingDescriptor().getValueParameters()
         return valParameters.size() > 1 && !KotlinBuiltIns.isAny(valParameters[1].type)
     }
 
-    private fun simplifyConditionIfPossible(ifExpression: JetIfExpression) {
-        val condition = ifExpression.getCondition() as JetPrefixExpression
+    private fun simplifyConditionIfPossible(ifExpression: KtIfExpression) {
+        val condition = ifExpression.getCondition() as KtPrefixExpression
         val simplifier = SimplifyNegatedBinaryExpressionIntention()
         if (simplifier.isApplicableTo(condition)) {
             simplifier.applyTo(condition)
         }
     }
 
-    private fun replaceWithIfThenThrowExpression(original: JetCallExpression): JetIfExpression {
-        val replacement = JetPsiFactory(original).createExpression("if (!true) { throw java.lang.AssertionError(\"\") }") as JetIfExpression
+    private fun replaceWithIfThenThrowExpression(original: KtCallExpression): KtIfExpression {
+        val replacement = KtPsiFactory(original).createExpression("if (!true) { throw java.lang.AssertionError(\"\") }") as KtIfExpression
         val parent = original.getParent()
-        return if (parent is JetDotQualifiedExpression)
+        return if (parent is KtDotQualifiedExpression)
             parent.replaced(replacement)
         else
             original.replaced(replacement)
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertForEachToForLoopIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertForEachToForLoopIntention.kt
index f348afa0d4f..cfb4693c1b2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertForEachToForLoopIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertForEachToForLoopIntention.kt
@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 
-public class ConvertForEachToForLoopIntention : JetSelfTargetingOffsetIndependentIntention<JetSimpleNameExpression>(javaClass(), "Replace with a 'for' loop") {
-    override fun isApplicableTo(element: JetSimpleNameExpression): Boolean {
+public class ConvertForEachToForLoopIntention : JetSelfTargetingOffsetIndependentIntention<KtSimpleNameExpression>(javaClass(), "Replace with a 'for' loop") {
+    override fun isApplicableTo(element: KtSimpleNameExpression): Boolean {
         if (element.getReferencedName() != "forEach") return false
 
         val data = extractData(element) ?: return false
@@ -35,7 +35,7 @@ public class ConvertForEachToForLoopIntention : JetSelfTargetingOffsetIndependen
         return true
     }
 
-    override fun applyTo(element: JetSimpleNameExpression, editor: Editor) {
+    override fun applyTo(element: KtSimpleNameExpression, editor: Editor) {
         val (expressionToReplace, receiver, functionLiteral) = extractData(element)!!
 
         val commentSaver = CommentSaver(expressionToReplace)
@@ -47,31 +47,31 @@ public class ConvertForEachToForLoopIntention : JetSelfTargetingOffsetIndependen
     }
 
     private data class Data(
-            val expressionToReplace: JetExpression,
-            val receiver: JetExpression,
-            val functionLiteral: JetFunctionLiteralExpression
+            val expressionToReplace: KtExpression,
+            val receiver: KtExpression,
+            val functionLiteral: KtFunctionLiteralExpression
     )
 
-    private fun extractData(nameExpr: JetSimpleNameExpression): Data? {
+    private fun extractData(nameExpr: KtSimpleNameExpression): Data? {
         val parent = nameExpr.getParent()
         val expression = (when (parent) {
-            is JetCallExpression -> parent.getParent() as? JetDotQualifiedExpression
-            is JetBinaryExpression -> parent
+            is KtCallExpression -> parent.getParent() as? KtDotQualifiedExpression
+            is KtBinaryExpression -> parent
             else -> null
-        } ?: return null) as JetExpression //TODO: submit bug
+        } ?: return null) as KtExpression //TODO: submit bug
 
         val resolvedCall = expression.getResolvedCall(expression.analyze()) ?: return null
         if (DescriptorUtils.getFqName(resolvedCall.getResultingDescriptor()).toString() != "kotlin.forEach") return null
 
         val receiver = resolvedCall.getCall().getExplicitReceiver() as? ExpressionReceiver ?: return null
         val argument = resolvedCall.getCall().getValueArguments().singleOrNull() ?: return null
-        val functionLiteral = argument.getArgumentExpression() as? JetFunctionLiteralExpression ?: return null
+        val functionLiteral = argument.getArgumentExpression() as? KtFunctionLiteralExpression ?: return null
         return Data(expression, receiver.getExpression(), functionLiteral)
     }
 
-    private fun generateLoop(functionLiteral: JetFunctionLiteralExpression, receiver: JetExpression): JetExpression {
-        val factory = JetPsiFactory(functionLiteral)
-        val loopRange = JetPsiUtil.safeDeparenthesize(receiver)
+    private fun generateLoop(functionLiteral: KtFunctionLiteralExpression, receiver: KtExpression): KtExpression {
+        val factory = KtPsiFactory(functionLiteral)
+        val loopRange = KtPsiUtil.safeDeparenthesize(receiver)
         val body = functionLiteral.getBodyExpression()!!
         val parameter = functionLiteral.getValueParameters().singleOrNull()
         return factory.createExpressionByPattern("for($0 in $1){ $2 }", parameter ?: "it", loopRange, body)
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertFunctionToPropertyIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertFunctionToPropertyIntention.kt
index ac19626a170..1c027681735 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertFunctionToPropertyIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertFunctionToPropertyIntention.kt
@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.idea.core.refactoring.reportDeclarationConflict
 import org.jetbrains.kotlin.idea.refactoring.CallableRefactoring
 import org.jetbrains.kotlin.idea.refactoring.getAffectedCallables
 import org.jetbrains.kotlin.idea.refactoring.getContainingScope
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
@@ -55,22 +55,22 @@ import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.types.typeUtil.supertypes
 import java.util.*
 
-public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetNamedFunction>(javaClass(), "Convert function to property"), LowPriorityAction {
-    private var JetNamedFunction.typeFqNameToAdd: String? by UserDataProperty(Key.create("TYPE_FQ_NAME_TO_ADD"))
+public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<KtNamedFunction>(javaClass(), "Convert function to property"), LowPriorityAction {
+    private var KtNamedFunction.typeFqNameToAdd: String? by UserDataProperty(Key.create("TYPE_FQ_NAME_TO_ADD"))
 
     private inner class Converter(
             project: Project,
             descriptor: FunctionDescriptor
     ): CallableRefactoring<FunctionDescriptor>(project, descriptor, getText()) {
-        private val elementsToShorten = ArrayList<JetElement>()
+        private val elementsToShorten = ArrayList<KtElement>()
 
         private val newName: String by lazy {
             val name = callableDescriptor.name
             (SyntheticJavaPropertyDescriptor.propertyNameByGetMethodName(name) ?: name).asString()
         }
 
-        private fun convertFunction(originalFunction: JetNamedFunction, psiFactory: JetPsiFactory) {
-            val function = originalFunction.copy() as JetNamedFunction
+        private fun convertFunction(originalFunction: KtNamedFunction, psiFactory: KtPsiFactory) {
+            val function = originalFunction.copy() as KtNamedFunction
 
             val propertySample = psiFactory.createProperty("val foo: Int get() = 1")
 
@@ -90,7 +90,7 @@ public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetN
             }
             function.setName(newName)
 
-            val property = originalFunction.replace(psiFactory.createProperty(function.getText())) as JetProperty
+            val property = originalFunction.replace(psiFactory.createProperty(function.getText())) as KtProperty
             if (needsExplicitType) {
                 elementsToShorten.add(property.getTypeReference()!!)
             }
@@ -100,7 +100,7 @@ public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetN
             val conflicts = MultiMap<PsiElement, String>()
             val getterName = JvmAbi.getterName(callableDescriptor.getName().asString())
             val callables = getAffectedCallables(project, descriptorsForChange)
-            val kotlinCalls = ArrayList<JetCallElement>()
+            val kotlinCalls = ArrayList<KtCallElement>()
             val kotlinRefsToRename = ArrayList<PsiReference>()
             val foreignRefs = ArrayList<PsiReference>()
             for (callable in callables) {
@@ -110,7 +110,7 @@ public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetN
                     reportDeclarationConflict(conflicts, callable) { "Can't modify $it" }
                 }
 
-                if (callable is JetNamedFunction) {
+                if (callable is KtNamedFunction) {
                     if (callable.getTypeReference() == null) {
                         val functionDescriptor = callable.resolveToDescriptor() as FunctionDescriptor
                         val type = functionDescriptor.getReturnType()
@@ -138,10 +138,10 @@ public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetN
 
                 val usages = ReferencesSearch.search(callable)
                 for (usage in usages) {
-                    if (usage is JetSimpleNameReference) {
+                    if (usage is KtSimpleNameReference) {
                         val expression = usage.expression
-                        val callElement = expression.getParentOfTypeAndBranch<JetCallElement> { getCalleeExpression() }
-                        if (callElement != null && expression.getStrictParentOfType<JetCallableReferenceExpression>() == null) {
+                        val callElement = expression.getParentOfTypeAndBranch<KtCallElement> { getCalleeExpression() }
+                        if (callElement != null && expression.getStrictParentOfType<KtCallableReferenceExpression>() == null) {
                             if (callElement.getTypeArguments().isNotEmpty()) {
                                 conflicts.putValue(
                                         callElement,
@@ -171,7 +171,7 @@ public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetN
 
             project.checkConflictsInteractively(conflicts) {
                 project.executeWriteCommand(getText()) {
-                    val psiFactory = JetPsiFactory(project)
+                    val psiFactory = KtPsiFactory(project)
                     val newGetterName = JvmAbi.getterName(newName)
                     val newRefExpr = psiFactory.createExpression(newName)
 
@@ -180,7 +180,7 @@ public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetN
                     foreignRefs.forEach { it.handleElementRename(newGetterName) }
                     callables.forEach {
                         when (it) {
-                            is JetNamedFunction -> convertFunction(it, psiFactory)
+                            is KtNamedFunction -> convertFunction(it, psiFactory)
                             is PsiMethod -> it.setName(newGetterName)
                         }
                     }
@@ -193,7 +193,7 @@ public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetN
 
     override fun startInWriteAction(): Boolean = false
 
-    override fun isApplicableTo(element: JetNamedFunction, caretOffset: Int): Boolean {
+    override fun isApplicableTo(element: KtNamedFunction, caretOffset: Int): Boolean {
         val identifier = element.getNameIdentifier() ?: return false
         if (!identifier.getTextRange().containsOffset(caretOffset)) return false
 
@@ -210,7 +210,7 @@ public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetN
         return !KotlinBuiltIns.isUnit(returnType) && !KotlinBuiltIns.isNothing(returnType)
     }
 
-    override fun applyTo(element: JetNamedFunction, editor: Editor) {
+    override fun applyTo(element: KtNamedFunction, editor: Editor) {
         val context = element.analyze(BodyResolveMode.PARTIAL)
         val descriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, element] as FunctionDescriptor
         Converter(element.getProject(), descriptor).run()
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertIfWithThrowToAssertIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertIfWithThrowToAssertIntention.kt
index 24d49f3e11d..3d22308f32c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertIfWithThrowToAssertIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertIfWithThrowToAssertIntention.kt
@@ -27,14 +27,14 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.idea.core.copied
 import org.jetbrains.kotlin.idea.core.replaced
 
-public class ConvertIfWithThrowToAssertIntention : JetSelfTargetingOffsetIndependentIntention<JetIfExpression>(javaClass(), "Replace 'if' with 'assert' statement") {
+public class ConvertIfWithThrowToAssertIntention : JetSelfTargetingOffsetIndependentIntention<KtIfExpression>(javaClass(), "Replace 'if' with 'assert' statement") {
 
-    override fun isApplicableTo(element: JetIfExpression): Boolean {
+    override fun isApplicableTo(element: KtIfExpression): Boolean {
         if (element.getElse() != null) return false
 
-        val throwExpr = element.getThen()?.unwrapBlockOrParenthesis() as? JetThrowExpression
+        val throwExpr = element.getThen()?.unwrapBlockOrParenthesis() as? KtThrowExpression
         val thrownExpr = getSelector(throwExpr?.getThrownExpression())
-        if (thrownExpr !is JetCallExpression) return false
+        if (thrownExpr !is KtCallExpression) return false
 
         if (thrownExpr.getValueArguments().size() > 1) return false
 
@@ -42,18 +42,18 @@ public class ConvertIfWithThrowToAssertIntention : JetSelfTargetingOffsetIndepen
         return DescriptorUtils.getFqName(resolvedCall.getResultingDescriptor()).toString() == "java.lang.AssertionError.<init>"
     }
 
-    override fun applyTo(element: JetIfExpression, editor: Editor) {
+    override fun applyTo(element: KtIfExpression, editor: Editor) {
         val condition = element.getCondition() ?: return
 
-        val thenExpr = element.getThen()?.unwrapBlockOrParenthesis() as JetThrowExpression
-        val thrownExpr = getSelector(thenExpr.getThrownExpression()) as JetCallExpression
+        val thenExpr = element.getThen()?.unwrapBlockOrParenthesis() as KtThrowExpression
+        val thrownExpr = getSelector(thenExpr.getThrownExpression()) as KtCallExpression
 
-        val psiFactory = JetPsiFactory(element)
+        val psiFactory = KtPsiFactory(element)
         condition.replace(psiFactory.createExpressionByPattern("!$0", condition))
 
         var newCondition = element.getCondition()!!
         val simplifier = SimplifyNegatedBinaryExpressionIntention()
-        if (simplifier.isApplicableTo(newCondition as JetPrefixExpression)) {
+        if (simplifier.isApplicableTo(newCondition as KtPrefixExpression)) {
             simplifier.applyTo(newCondition, editor)
             newCondition = element.getCondition()!!
         }
@@ -68,8 +68,8 @@ public class ConvertIfWithThrowToAssertIntention : JetSelfTargetingOffsetIndepen
         ShortenReferences.DEFAULT.process(newExpr)
     }
 
-    private fun getSelector(element: JetExpression?): JetExpression? {
-        if (element is JetDotQualifiedExpression) {
+    private fun getSelector(element: KtExpression?): KtExpression? {
+        if (element is KtDotQualifiedExpression) {
             return element.getSelectorExpression()
         }
         return element
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedBooleanSequenceIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedBooleanSequenceIntention.kt
index edc0ac382bf..d65d7b603c1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedBooleanSequenceIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedBooleanSequenceIntention.kt
@@ -17,27 +17,27 @@
 package org.jetbrains.kotlin.idea.intentions
 
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.lexer.JetSingleValueToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtSingleValueToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import java.util.LinkedList
 
 
-public class ConvertNegatedBooleanSequenceIntention : JetSelfTargetingOffsetIndependentIntention<JetBinaryExpression>(
+public class ConvertNegatedBooleanSequenceIntention : JetSelfTargetingOffsetIndependentIntention<KtBinaryExpression>(
         javaClass(), "Replace negated sequence with DeMorgan equivalent") {
 
-    override fun isApplicableTo(element: JetBinaryExpression): Boolean {
-        if (element.getParent() is JetBinaryExpression) return false // operate only on the longest sequence
+    override fun isApplicableTo(element: KtBinaryExpression): Boolean {
+        if (element.getParent() is KtBinaryExpression) return false // operate only on the longest sequence
         val opToken = element.getOperationToken()
-        if (opToken != JetTokens.ANDAND && opToken != JetTokens.OROR) return false
+        if (opToken != KtTokens.ANDAND && opToken != KtTokens.OROR) return false
 
         return splitBooleanSequence(element) != null
     }
 
-    override fun applyTo(element: JetBinaryExpression, editor: Editor) {
+    override fun applyTo(element: KtBinaryExpression, editor: Editor) {
         val operatorText = when(element.getOperationToken()) {
-            JetTokens.ANDAND -> JetTokens.OROR.getValue()
-            JetTokens.OROR -> JetTokens.ANDAND.getValue()
+            KtTokens.ANDAND -> KtTokens.OROR.getValue()
+            KtTokens.OROR -> KtTokens.ANDAND.getValue()
             else -> throw IllegalArgumentException() // checked in isApplicableTo
         }
 
@@ -47,34 +47,34 @@ public class ConvertNegatedBooleanSequenceIntention : JetSelfTargetingOffsetInde
                 "!(${bareExpressions.last()}", { negated, expression -> "$expression $operatorText $negated" }
         )
 
-        val newExpression = JetPsiFactory(element).createExpression("$negatedExpression)")
+        val newExpression = KtPsiFactory(element).createExpression("$negatedExpression)")
 
         val insertedElement = element.replace(newExpression)
-        val insertedElementParent = insertedElement.getParent() as? JetParenthesizedExpression ?: return
+        val insertedElementParent = insertedElement.getParent() as? KtParenthesizedExpression ?: return
 
-        if (JetPsiUtil.areParenthesesUseless(insertedElementParent)) {
+        if (KtPsiUtil.areParenthesesUseless(insertedElementParent)) {
             insertedElementParent.replace(insertedElement)
         }
     }
 
-    private fun splitBooleanSequence(expression: JetBinaryExpression): List<JetPrefixExpression>? {
-        val itemList = LinkedList<JetPrefixExpression>()
+    private fun splitBooleanSequence(expression: KtBinaryExpression): List<KtPrefixExpression>? {
+        val itemList = LinkedList<KtPrefixExpression>()
         val firstOperator = expression.getOperationToken()
 
-        var currentItem: JetBinaryExpression? = expression
+        var currentItem: KtBinaryExpression? = expression
         while (currentItem != null) {
             if (currentItem.getOperationToken() != firstOperator) return null //Boolean sequence must be homogeneous
 
-            val rightChild = currentItem.getRight() as? JetPrefixExpression ?: return null
+            val rightChild = currentItem.getRight() as? KtPrefixExpression ?: return null
             itemList.add(rightChild)
 
             val leftChild = currentItem.getLeft()
             when (leftChild) {
-                is JetPrefixExpression -> itemList.add(leftChild)
-                !is JetBinaryExpression -> return null
+                is KtPrefixExpression -> itemList.add(leftChild)
+                !is KtBinaryExpression -> return null
             }
 
-            currentItem = leftChild as? JetBinaryExpression
+            currentItem = leftChild as? KtBinaryExpression
         }
 
         return itemList
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt
index a5ab6d3c865..7194f7fff69 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt
@@ -18,42 +18,42 @@ package org.jetbrains.kotlin.idea.intentions
 
 import com.intellij.openapi.editor.Editor
 import com.intellij.psi.impl.source.tree.PsiErrorElementImpl
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.*
 
-public class ConvertNegatedExpressionWithDemorgansLawIntention : JetSelfTargetingOffsetIndependentIntention<JetPrefixExpression>(javaClass(), "DeMorgan Law") {
+public class ConvertNegatedExpressionWithDemorgansLawIntention : JetSelfTargetingOffsetIndependentIntention<KtPrefixExpression>(javaClass(), "DeMorgan Law") {
 
-    override fun isApplicableTo(element: JetPrefixExpression): Boolean {
+    override fun isApplicableTo(element: KtPrefixExpression): Boolean {
         val prefixOperator = element.getOperationReference().getReferencedNameElementType()
-        if (prefixOperator != JetTokens.EXCL) return false
+        if (prefixOperator != KtTokens.EXCL) return false
 
-        val parenthesizedExpression = element.getBaseExpression() as? JetParenthesizedExpression
-        val baseExpression = parenthesizedExpression?.getExpression() as? JetBinaryExpression ?: return false
+        val parenthesizedExpression = element.getBaseExpression() as? KtParenthesizedExpression
+        val baseExpression = parenthesizedExpression?.getExpression() as? KtBinaryExpression ?: return false
 
         when (baseExpression.getOperationToken()) {
-            JetTokens.ANDAND -> setText("Replace '&&' with '||'")
-            JetTokens.OROR -> setText("Replace '||' with '&&'")
+            KtTokens.ANDAND -> setText("Replace '&&' with '||'")
+            KtTokens.OROR -> setText("Replace '||' with '&&'")
             else -> return false
         }
 
         return splitBooleanSequence(baseExpression) != null
     }
 
-    override fun applyTo(element: JetPrefixExpression, editor: Editor) {
-        val parenthesizedExpression = element.getBaseExpression() as JetParenthesizedExpression
-        val baseExpression = parenthesizedExpression.getExpression() as JetBinaryExpression
+    override fun applyTo(element: KtPrefixExpression, editor: Editor) {
+        val parenthesizedExpression = element.getBaseExpression() as KtParenthesizedExpression
+        val baseExpression = parenthesizedExpression.getExpression() as KtBinaryExpression
 
         val operatorText = when (baseExpression.getOperationToken()) {
-            JetTokens.ANDAND -> JetTokens.OROR.getValue()
-            JetTokens.OROR -> JetTokens.ANDAND.getValue()
+            KtTokens.ANDAND -> KtTokens.OROR.getValue()
+            KtTokens.OROR -> KtTokens.ANDAND.getValue()
             else -> throw IllegalArgumentException()
         }
 
         val operands = splitBooleanSequence(baseExpression)!!.asReversed()
 
-        val newExpression = JetPsiFactory(element).buildExpression {
+        val newExpression = KtPsiFactory(element).buildExpression {
             for ((i, operand) in operands.withIndex()) {
                 if (i > 0) {
                     appendFixedText(operatorText)
@@ -65,16 +65,16 @@ public class ConvertNegatedExpressionWithDemorgansLawIntention : JetSelfTargetin
         element.replace(newExpression)
     }
 
-    private fun splitBooleanSequence(expression: JetBinaryExpression): List<JetExpression>? {
-        val result = ArrayList<JetExpression>()
+    private fun splitBooleanSequence(expression: KtBinaryExpression): List<KtExpression>? {
+        val result = ArrayList<KtExpression>()
         val firstOperator = expression.getOperationToken()
 
-        var remainingExpression: JetExpression = expression
+        var remainingExpression: KtExpression = expression
         while (true) {
-            if (remainingExpression !is JetBinaryExpression) break
+            if (remainingExpression !is KtBinaryExpression) break
 
             val operation = remainingExpression.getOperationToken()
-            if (operation != JetTokens.ANDAND && operation != JetTokens.OROR) break
+            if (operation != KtTokens.ANDAND && operation != KtTokens.OROR) break
 
             if (operation != firstOperator) return null //Boolean sequence must be homogenous
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertParameterToReceiverIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertParameterToReceiverIntention.kt
index 54e587447cb..1720a8eab9e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertParameterToReceiverIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertParameterToReceiverIntention.kt
@@ -24,17 +24,17 @@ import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeSignatureC
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.modify
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.runChangeSignature
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetParameter
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 
-public class ConvertParameterToReceiverIntention : JetSelfTargetingIntention<JetParameter>(javaClass(), "Convert parameter to receiver") {
-    override fun isApplicableTo(element: JetParameter, caretOffset: Int): Boolean {
+public class ConvertParameterToReceiverIntention : JetSelfTargetingIntention<KtParameter>(javaClass(), "Convert parameter to receiver") {
+    override fun isApplicableTo(element: KtParameter, caretOffset: Int): Boolean {
         val identifier = element.getNameIdentifier() ?: return false
         if (!identifier.getTextRange().containsOffset(caretOffset)) return false
         if (element.isVarArg()) return false
-        val function = element.getStrictParentOfType<JetNamedFunction>() ?: return false
+        val function = element.getStrictParentOfType<KtNamedFunction>() ?: return false
         return function.getValueParameterList() == element.getParent() && function.getReceiverTypeReference() == null
     }
 
@@ -50,8 +50,8 @@ public class ConvertParameterToReceiverIntention : JetSelfTargetingIntention<Jet
 
     override fun startInWriteAction() = false
 
-    override fun applyTo(element: JetParameter, editor: Editor) {
-        val function = element.getStrictParentOfType<JetNamedFunction>() ?: return
+    override fun applyTo(element: KtParameter, editor: Editor) {
+        val function = element.getStrictParentOfType<KtNamedFunction>() ?: return
         val parameterIndex = function.getValueParameters().indexOf(element)
         val context = function.analyze()
         val descriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, function] as? FunctionDescriptor ?: return
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertPropertyToFunctionIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertPropertyToFunctionIntention.kt
index 799acf24f8b..5d7589ee55d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertPropertyToFunctionIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertPropertyToFunctionIntention.kt
@@ -33,15 +33,15 @@ import org.jetbrains.kotlin.idea.core.refactoring.reportDeclarationConflict
 import org.jetbrains.kotlin.idea.refactoring.CallableRefactoring
 import org.jetbrains.kotlin.idea.refactoring.getAffectedCallables
 import org.jetbrains.kotlin.idea.refactoring.getContainingScope
-import org.jetbrains.kotlin.idea.references.JetReference
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.idea.references.KtReference
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.load.java.JvmAbi
-import org.jetbrains.kotlin.psi.JetCallableReferenceExpression
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.siblings
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -49,15 +49,15 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import java.util.*
 
-public class ConvertPropertyToFunctionIntention : JetSelfTargetingIntention<JetProperty>(javaClass(), "Convert property to function"), LowPriorityAction {
+public class ConvertPropertyToFunctionIntention : JetSelfTargetingIntention<KtProperty>(javaClass(), "Convert property to function"), LowPriorityAction {
     private inner class Converter(
             project: Project,
             descriptor: CallableDescriptor
     ): CallableRefactoring<CallableDescriptor>(project, descriptor, getText()) {
         private val newName: String = JvmAbi.getterName(callableDescriptor.name.asString())
 
-        private fun convertProperty(originalProperty: JetProperty, psiFactory: JetPsiFactory) {
-            val property = originalProperty.copy() as JetProperty;
+        private fun convertProperty(originalProperty: KtProperty, psiFactory: KtPsiFactory) {
+            val property = originalProperty.copy() as KtProperty;
             val getter = property.getGetter();
 
             val sampleFunction = psiFactory.createFunction("fun foo() {\n\n}");
@@ -89,7 +89,7 @@ public class ConvertPropertyToFunctionIntention : JetSelfTargetingIntention<JetP
             val getterName = JvmAbi.getterName(callableDescriptor.getName().asString())
             val conflicts = MultiMap<PsiElement, String>()
             val callables = getAffectedCallables(project, descriptorsForChange)
-            val kotlinRefsToReplaceWithCall = ArrayList<JetSimpleNameExpression>()
+            val kotlinRefsToReplaceWithCall = ArrayList<KtSimpleNameExpression>()
             val refsToRename = ArrayList<PsiReference>()
             val javaRefsToReplaceWithCall = ArrayList<PsiReferenceExpression>()
             for (callable in callables) {
@@ -100,7 +100,7 @@ public class ConvertPropertyToFunctionIntention : JetSelfTargetingIntention<JetP
                     conflicts.putValue(callable, "Can't modify $renderedCallable")
                 }
 
-                if (callable is JetProperty) {
+                if (callable is KtProperty) {
                     callableDescriptor.getContainingScope()
                             ?.getFunctions(callableDescriptor.name, NoLookupLocation.FROM_IDE)
                             ?.firstOrNull { it.getValueParameters().isEmpty() }
@@ -116,11 +116,11 @@ public class ConvertPropertyToFunctionIntention : JetSelfTargetingIntention<JetP
 
                 val usages = ReferencesSearch.search(callable)
                 for (usage in usages) {
-                    if (usage is JetReference) {
-                        if (usage is JetSimpleNameReference) {
+                    if (usage is KtReference) {
+                        if (usage is KtSimpleNameReference) {
                             val expression = usage.expression
                             if (expression.getCall(expression.analyze(BodyResolveMode.PARTIAL)) != null
-                                && expression.getStrictParentOfType<JetCallableReferenceExpression>() == null) {
+                                && expression.getStrictParentOfType<KtCallableReferenceExpression>() == null) {
                                 kotlinRefsToReplaceWithCall.add(expression)
                             }
                             else if (nameChanged) {
@@ -157,7 +157,7 @@ public class ConvertPropertyToFunctionIntention : JetSelfTargetingIntention<JetP
 
             project.checkConflictsInteractively(conflicts) {
                 project.executeWriteCommand(getText()) {
-                    val kotlinPsiFactory = JetPsiFactory(project)
+                    val kotlinPsiFactory = KtPsiFactory(project)
                     val javaPsiFactory = PsiElementFactory.SERVICE.getInstance(project)
                     val newKotlinCallExpr = kotlinPsiFactory.createExpression("$newName()")
 
@@ -169,7 +169,7 @@ public class ConvertPropertyToFunctionIntention : JetSelfTargetingIntention<JetP
                     }
                     callables.forEach {
                         when (it) {
-                            is JetProperty -> convertProperty(it, kotlinPsiFactory)
+                            is KtProperty -> convertProperty(it, kotlinPsiFactory)
                             is PsiMethod -> it.setName(newName)
                         }
                     }
@@ -180,13 +180,13 @@ public class ConvertPropertyToFunctionIntention : JetSelfTargetingIntention<JetP
 
     override fun startInWriteAction(): Boolean = false
 
-    override fun isApplicableTo(element: JetProperty, caretOffset: Int): Boolean {
+    override fun isApplicableTo(element: KtProperty, caretOffset: Int): Boolean {
         val identifier = element.getNameIdentifier() ?: return false
         if (!identifier.getTextRange().containsOffset(caretOffset)) return false
         return element.getDelegate() == null && !element.isVar() && !element.isLocal()
     }
 
-    override fun applyTo(element: JetProperty, editor: Editor) {
+    override fun applyTo(element: KtProperty, editor: Editor) {
         val context = element.analyze()
         val descriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, element] as? CallableDescriptor ?: return
         Converter(element.getProject(), descriptor).run()
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertReceiverToParameterIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertReceiverToParameterIntention.kt
index b0496149742..2139a48a485 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertReceiverToParameterIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertReceiverToParameterIntention.kt
@@ -24,13 +24,13 @@ import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeSignatureC
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.modify
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.runChangeSignature
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetTypeReference
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtTypeReference
 import org.jetbrains.kotlin.resolve.BindingContext
 
-public class ConvertReceiverToParameterIntention : JetSelfTargetingOffsetIndependentIntention<JetTypeReference>(javaClass(), "Convert receiver to parameter"), LowPriorityAction {
-    override fun isApplicableTo(element: JetTypeReference): Boolean {
-        return (element.getParent() as? JetNamedFunction)?.getReceiverTypeReference() == element
+public class ConvertReceiverToParameterIntention : JetSelfTargetingOffsetIndependentIntention<KtTypeReference>(javaClass(), "Convert receiver to parameter"), LowPriorityAction {
+    override fun isApplicableTo(element: KtTypeReference): Boolean {
+        return (element.getParent() as? KtNamedFunction)?.getReceiverTypeReference() == element
     }
 
     private fun configureChangeSignature(): JetChangeSignatureConfiguration {
@@ -43,8 +43,8 @@ public class ConvertReceiverToParameterIntention : JetSelfTargetingOffsetIndepen
 
     override fun startInWriteAction() = false
 
-    override fun applyTo(element: JetTypeReference, editor: Editor) {
-        val function = element.getParent() as? JetNamedFunction ?: return
+    override fun applyTo(element: KtTypeReference, editor: Editor) {
+        val function = element.getParent() as? KtNamedFunction ?: return
         val context = function.analyze()
         val descriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, function] as? FunctionDescriptor ?: return
         runChangeSignature(element.project, descriptor, configureChangeSignature(), element, getText())
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToBlockBodyIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToBlockBodyIntention.kt
index 274bf52c7e4..cdc0805a74a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToBlockBodyIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToBlockBodyIntention.kt
@@ -24,49 +24,49 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
-public class ConvertToBlockBodyIntention : JetSelfTargetingIntention<JetDeclarationWithBody>(
+public class ConvertToBlockBodyIntention : JetSelfTargetingIntention<KtDeclarationWithBody>(
         javaClass(), "Convert to block body"
 ), LowPriorityAction {
-    override fun isApplicableTo(element: JetDeclarationWithBody, caretOffset: Int): Boolean {
-        if (element is JetFunctionLiteral || element.hasBlockBody() || !element.hasBody()) return false
+    override fun isApplicableTo(element: KtDeclarationWithBody, caretOffset: Int): Boolean {
+        if (element is KtFunctionLiteral || element.hasBlockBody() || !element.hasBody()) return false
 
         when (element) {
-            is JetNamedFunction -> {
+            is KtNamedFunction -> {
                 val returnType = element.returnType() ?: return false
                 if (!element.hasDeclaredReturnType() && returnType.isError()) return false// do not convert when type is implicit and unknown
                 return true
             }
 
-            is JetPropertyAccessor -> return true
+            is KtPropertyAccessor -> return true
 
             else -> error("Unknown declaration type: $element")
         }
     }
 
-    override fun allowCaretInsideElement(element: PsiElement) = element !is JetDeclaration
+    override fun allowCaretInsideElement(element: PsiElement) = element !is KtDeclaration
 
-    override fun applyTo(element: JetDeclarationWithBody, editor: Editor) {
+    override fun applyTo(element: KtDeclarationWithBody, editor: Editor) {
         convert(element)
     }
 
     companion object {
-        public fun convert(declaration: JetDeclarationWithBody): JetDeclarationWithBody {
+        public fun convert(declaration: KtDeclarationWithBody): KtDeclarationWithBody {
             val body = declaration.getBodyExpression()!!
 
-            fun generateBody(returnsValue: Boolean): JetExpression {
+            fun generateBody(returnsValue: Boolean): KtExpression {
                 val bodyType = body.analyze().getType(body)
                 val needReturn = returnsValue &&
                                  (bodyType == null || (!KotlinBuiltIns.isUnit(bodyType) && !KotlinBuiltIns.isNothing(bodyType)))
 
-                val factory = JetPsiFactory(declaration)
+                val factory = KtPsiFactory(declaration)
                 val statement = if (needReturn) factory.createExpressionByPattern("return $0", body) else body
                 return factory.createSingleStatementBlock(statement)
             }
 
             val newBody = when (declaration) {
-                is JetNamedFunction -> {
+                is KtNamedFunction -> {
                     val returnType = declaration.returnType()!!
                     if (!declaration.hasDeclaredReturnType() && !KotlinBuiltIns.isUnit(returnType)) {
                         declaration.setType(returnType)
@@ -74,7 +74,7 @@ public class ConvertToBlockBodyIntention : JetSelfTargetingIntention<JetDeclarat
                     generateBody(!KotlinBuiltIns.isUnit(returnType) && !KotlinBuiltIns.isNothing(returnType))
                 }
 
-                is JetPropertyAccessor -> generateBody(declaration.isGetter())
+                is KtPropertyAccessor -> generateBody(declaration.isGetter())
 
                 else -> throw RuntimeException("Unknown declaration type: $declaration")
             }
@@ -84,7 +84,7 @@ public class ConvertToBlockBodyIntention : JetSelfTargetingIntention<JetDeclarat
             return declaration
         }
 
-        private fun JetNamedFunction.returnType(): JetType? {
+        private fun KtNamedFunction.returnType(): KtType? {
             val descriptor = analyze()[BindingContext.DECLARATION_TO_DESCRIPTOR, this] ?: return null
             return (descriptor as FunctionDescriptor).getReturnType()
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToConcatenatedStringIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToConcatenatedStringIntention.kt
index 2d2d83b1326..2cf91b6d94a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToConcatenatedStringIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToConcatenatedStringIntention.kt
@@ -20,37 +20,37 @@ import com.intellij.codeInsight.intention.LowPriorityAction
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContextUtils
 
-public class ConvertToConcatenatedStringIntention : JetSelfTargetingOffsetIndependentIntention<JetStringTemplateExpression>(javaClass(), "Convert template to concatenated string"), LowPriorityAction {
-    override fun isApplicableTo(element: JetStringTemplateExpression): Boolean {
-        if (element.getLastChild().getNode().getElementType() != JetTokens.CLOSING_QUOTE) return false // not available for unclosed literal
-        return element.getEntries().any { it is JetStringTemplateEntryWithExpression }
+public class ConvertToConcatenatedStringIntention : JetSelfTargetingOffsetIndependentIntention<KtStringTemplateExpression>(javaClass(), "Convert template to concatenated string"), LowPriorityAction {
+    override fun isApplicableTo(element: KtStringTemplateExpression): Boolean {
+        if (element.getLastChild().getNode().getElementType() != KtTokens.CLOSING_QUOTE) return false // not available for unclosed literal
+        return element.getEntries().any { it is KtStringTemplateEntryWithExpression }
     }
 
-    override fun applyTo(element: JetStringTemplateExpression, editor: Editor) {
+    override fun applyTo(element: KtStringTemplateExpression, editor: Editor) {
         val tripleQuoted = isTripleQuoted(element.getText()!!)
         val quote = if (tripleQuoted) "\"\"\"" else "\""
         val entries = element.getEntries()
 
         val text = entries
-                .filterNot { it is JetStringTemplateEntryWithExpression && it.getExpression() == null }
+                .filterNot { it is KtStringTemplateEntryWithExpression && it.getExpression() == null }
                 .mapIndexed { index, entry ->
                     entry.toSeparateString(quote, convertExplicitly = (index == 0), isFinalEntry = (index == entries.lastIndex))
                 }
                 .join(separator = "+")
                 .replace("""$quote+$quote""", "")
 
-        val replacement = JetPsiFactory(element).createExpression(text)
+        val replacement = KtPsiFactory(element).createExpression(text)
         element.replace(replacement)
     }
 
     private fun isTripleQuoted(str: String) = str.startsWith("\"\"\"") && str.endsWith("\"\"\"")
 
-    private fun JetStringTemplateEntry.toSeparateString(quote: String, convertExplicitly: Boolean, isFinalEntry: Boolean): String {
-        if (this !is JetStringTemplateEntryWithExpression) {
+    private fun KtStringTemplateEntry.toSeparateString(quote: String, convertExplicitly: Boolean, isFinalEntry: Boolean): String {
+        if (this !is KtStringTemplateEntryWithExpression) {
             return getText().quote(quote)
         }
 
@@ -67,15 +67,15 @@ public class ConvertToConcatenatedStringIntention : JetSelfTargetingOffsetIndepe
             text
     }
 
-    private fun needsParenthesis(expression: JetExpression, isFinalEntry: Boolean): Boolean {
+    private fun needsParenthesis(expression: KtExpression, isFinalEntry: Boolean): Boolean {
         return when (expression) {
-            is JetBinaryExpression -> true
-            is JetIfExpression -> expression.getElse() !is JetBlockExpression && !isFinalEntry
+            is KtBinaryExpression -> true
+            is KtIfExpression -> expression.getElse() !is KtBlockExpression && !isFinalEntry
             else -> false
         }
     }
 
     private fun String.quote(quote: String) = quote + this + quote
 
-    private fun JetExpression.isStringExpression() = KotlinBuiltIns.isString(analyze().getType(this))
+    private fun KtExpression.isStringExpression() = KotlinBuiltIns.isString(analyze().getType(this))
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToExpressionBodyIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToExpressionBodyIntention.kt
index 4ea7841a6ed..e07d49daf06 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToExpressionBodyIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToExpressionBodyIntention.kt
@@ -23,26 +23,26 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.CommentSaver
 import org.jetbrains.kotlin.idea.core.canOmitDeclaredType
 import org.jetbrains.kotlin.idea.core.replaced
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.anyDescendantOfType
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.utils.addToStdlib.check
 
-public class ConvertToExpressionBodyIntention : JetSelfTargetingOffsetIndependentIntention<JetDeclarationWithBody>(
+public class ConvertToExpressionBodyIntention : JetSelfTargetingOffsetIndependentIntention<KtDeclarationWithBody>(
         javaClass(), "Convert to expression body"
 ) {
-    override fun isApplicableTo(element: JetDeclarationWithBody): Boolean {
+    override fun isApplicableTo(element: KtDeclarationWithBody): Boolean {
         val value = calcValue(element) ?: return false
-        return !value.anyDescendantOfType<JetReturnExpression>(
-                canGoInside = { it !is JetFunctionLiteral && it !is JetNamedFunction && it !is JetPropertyAccessor }
+        return !value.anyDescendantOfType<KtReturnExpression>(
+                canGoInside = { it !is KtFunctionLiteral && it !is KtNamedFunction && it !is KtPropertyAccessor }
         )
     }
 
-    override fun allowCaretInsideElement(element: PsiElement) = element !is JetDeclaration
+    override fun allowCaretInsideElement(element: PsiElement) = element !is KtDeclaration
 
-    override fun applyTo(element: JetDeclarationWithBody, editor: Editor) {
+    override fun applyTo(element: KtDeclarationWithBody, editor: Editor) {
         applyTo(element) {
             val typeRef = it.typeReference!!
             val colon = it.colon!!
@@ -51,17 +51,17 @@ public class ConvertToExpressionBodyIntention : JetSelfTargetingOffsetIndependen
         }
     }
 
-    public fun applyTo(declaration: JetDeclarationWithBody, canDeleteTypeRef: Boolean) {
-        val deleteTypeHandler: (JetCallableDeclaration) -> Unit = {
+    public fun applyTo(declaration: KtDeclarationWithBody, canDeleteTypeRef: Boolean) {
+        val deleteTypeHandler: (KtCallableDeclaration) -> Unit = {
             it.deleteChildRange(it.getColon()!!, it.getTypeReference()!!)
         }
         applyTo(declaration, deleteTypeHandler.check { canDeleteTypeRef })
     }
 
-    private fun applyTo(declaration: JetDeclarationWithBody, deleteTypeHandler: ((JetCallableDeclaration) -> Unit)?) {
+    private fun applyTo(declaration: KtDeclarationWithBody, deleteTypeHandler: ((KtCallableDeclaration) -> Unit)?) {
         val value = calcValue(declaration)!!
 
-        if (!declaration.hasDeclaredReturnType() && declaration is JetNamedFunction) {
+        if (!declaration.hasDeclaredReturnType() && declaration is KtNamedFunction) {
             val valueType = value.analyze().getType(value)
             if (valueType == null || !KotlinBuiltIns.isUnit(valueType)) {
                 declaration.setType(KotlinBuiltIns.FQ_NAMES.unit.asString(), shortenReferences = true)
@@ -72,34 +72,34 @@ public class ConvertToExpressionBodyIntention : JetSelfTargetingOffsetIndependen
 
         val commentSaver = CommentSaver(body)
 
-        declaration.addBefore(JetPsiFactory(declaration).createEQ(), body)
+        declaration.addBefore(KtPsiFactory(declaration).createEQ(), body)
         val newBody = body.replaced(value)
 
         commentSaver.restore(newBody)
 
-        if (deleteTypeHandler != null && declaration is JetCallableDeclaration) {
+        if (deleteTypeHandler != null && declaration is KtCallableDeclaration) {
             if (declaration.hasDeclaredReturnType() && declaration.canOmitDeclaredType(newBody, canChangeTypeToSubtype = true)) {
                 deleteTypeHandler(declaration)
             }
         }
     }
 
-    private fun calcValue(declaration: JetDeclarationWithBody): JetExpression? {
-        if (declaration is JetFunctionLiteral) return null
+    private fun calcValue(declaration: KtDeclarationWithBody): KtExpression? {
+        if (declaration is KtFunctionLiteral) return null
         val body = declaration.getBodyExpression()
-        if (!declaration.hasBlockBody() || body !is JetBlockExpression) return null
+        if (!declaration.hasBlockBody() || body !is KtBlockExpression) return null
 
         val statement = body.getStatements().singleOrNull() ?: return null
         when(statement) {
-            is JetReturnExpression -> {
+            is KtReturnExpression -> {
                 return statement.getReturnedExpression()
             }
 
             //TODO: IMO this is not good code, there should be a way to detect that JetExpression does not have value
-            is JetDeclaration, is JetLoopExpression -> return null // is JetExpression but does not have value
+            is KtDeclaration, is KtLoopExpression -> return null // is JetExpression but does not have value
 
             else  -> {
-                if (statement is JetBinaryExpression && statement.operationToken in JetTokens.ALL_ASSIGNMENTS) return null // assignment does not have value
+                if (statement is KtBinaryExpression && statement.operationToken in KtTokens.ALL_ASSIGNMENTS) return null // assignment does not have value
                 val expressionType = statement.analyze().getType(statement) ?: return null
                 if (!KotlinBuiltIns.isUnit(expressionType) && !KotlinBuiltIns.isNothing(expressionType)) return null
                 return statement
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToForEachFunctionCallIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToForEachFunctionCallIntention.kt
index e0903266e68..94dc6aedb8b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToForEachFunctionCallIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToForEachFunctionCallIntention.kt
@@ -18,29 +18,29 @@ package org.jetbrains.kotlin.idea.intentions
 
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.kotlin.idea.core.CommentSaver
-import org.jetbrains.kotlin.psi.JetBlockExpression
-import org.jetbrains.kotlin.psi.JetForExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtBlockExpression
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.createExpressionByPattern
 import org.jetbrains.kotlin.psi.psiUtil.contentRange
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 
-public class ConvertToForEachFunctionCallIntention : JetSelfTargetingIntention<JetForExpression>(javaClass(), "Replace with a 'forEach' function call") {
-    override fun isApplicableTo(element: JetForExpression, caretOffset: Int): Boolean {
+public class ConvertToForEachFunctionCallIntention : JetSelfTargetingIntention<KtForExpression>(javaClass(), "Replace with a 'forEach' function call") {
+    override fun isApplicableTo(element: KtForExpression, caretOffset: Int): Boolean {
         val rParen = element.getRightParenthesis() ?: return false
         if (caretOffset > rParen.endOffset) return false // available only on the loop header, not in the body
         return element.getLoopRange() != null && element.getLoopParameter() != null && element.getBody() != null
     }
 
-    override fun applyTo(element: JetForExpression, editor: Editor) {
+    override fun applyTo(element: KtForExpression, editor: Editor) {
         val commentSaver = CommentSaver(element)
 
         val body = element.getBody()!!
         val loopParameter = element.getLoopParameter()!!
 
-        val functionBodyArgument: Any = if (body is JetBlockExpression) body.contentRange() else body
+        val functionBodyArgument: Any = if (body is KtBlockExpression) body.contentRange() else body
 
-        val foreachExpression = JetPsiFactory(element).createExpressionByPattern(
+        val foreachExpression = KtPsiFactory(element).createExpressionByPattern(
                 "$0.forEach{$1->$2}", element.getLoopRange()!!, loopParameter, functionBodyArgument)
         val result = element.replace(foreachExpression)
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToStringTemplateIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToStringTemplateIntention.kt
index 0e7fbb54ea6..a9f03da3fe1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToStringTemplateIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToStringTemplateIntention.kt
@@ -23,40 +23,40 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
 
-public class ConvertToStringTemplateInspection : IntentionBasedInspection<JetBinaryExpression>(
+public class ConvertToStringTemplateInspection : IntentionBasedInspection<KtBinaryExpression>(
         ConvertToStringTemplateIntention(),
         { ConvertToStringTemplateIntention().shouldSuggestToConvert(it) }
 )
 
-public class ConvertToStringTemplateIntention : JetSelfTargetingOffsetIndependentIntention<JetBinaryExpression>(javaClass(), "Convert concatenation to template") {
-    override fun isApplicableTo(element: JetBinaryExpression): Boolean {
+public class ConvertToStringTemplateIntention : JetSelfTargetingOffsetIndependentIntention<KtBinaryExpression>(javaClass(), "Convert concatenation to template") {
+    override fun isApplicableTo(element: KtBinaryExpression): Boolean {
         if (!isApplicableToNoParentCheck(element)) return false
 
         val parent = element.getParent()
-        if (parent is JetBinaryExpression && isApplicableToNoParentCheck(parent)) return false
+        if (parent is KtBinaryExpression && isApplicableToNoParentCheck(parent)) return false
 
         return true
     }
 
-    override fun applyTo(element: JetBinaryExpression, editor: Editor) {
+    override fun applyTo(element: KtBinaryExpression, editor: Editor) {
         applyTo(element)
     }
 
-    public fun applyTo(element: JetBinaryExpression): JetStringTemplateExpression {
+    public fun applyTo(element: KtBinaryExpression): KtStringTemplateExpression {
         return element.replaced(buildReplacement(element))
     }
 
-    public fun shouldSuggestToConvert(expression: JetBinaryExpression): Boolean {
+    public fun shouldSuggestToConvert(expression: KtBinaryExpression): Boolean {
         val entries = buildReplacement(expression).entries
-        return entries.none { it is JetBlockStringTemplateEntry } && entries.count { it is JetLiteralStringTemplateEntry } > 1
+        return entries.none { it is KtBlockStringTemplateEntry } && entries.count { it is KtLiteralStringTemplateEntry } > 1
     }
 
-    private fun isApplicableToNoParentCheck(expression: JetBinaryExpression): Boolean {
-        if (expression.getOperationToken() != JetTokens.PLUS) return false
+    private fun isApplicableToNoParentCheck(expression: KtBinaryExpression): Boolean {
+        if (expression.getOperationToken() != KtTokens.PLUS) return false
         if (!KotlinBuiltIns.isString(expression.analyze().getType(expression))) return false
 
         val left = expression.getLeft() ?: return false
@@ -64,36 +64,36 @@ public class ConvertToStringTemplateIntention : JetSelfTargetingOffsetIndependen
         return !PsiUtilCore.hasErrorElementChild(left) && !PsiUtilCore.hasErrorElementChild(right)
     }
 
-    private fun buildReplacement(expression: JetBinaryExpression): JetStringTemplateExpression {
+    private fun buildReplacement(expression: KtBinaryExpression): KtStringTemplateExpression {
         val rightText = buildText(expression.getRight(), false)
-        return fold(expression.getLeft(), rightText, JetPsiFactory(expression))
+        return fold(expression.getLeft(), rightText, KtPsiFactory(expression))
     }
 
-    private fun fold(left: JetExpression?, right: String, factory: JetPsiFactory): JetStringTemplateExpression {
+    private fun fold(left: KtExpression?, right: String, factory: KtPsiFactory): KtStringTemplateExpression {
         val forceBraces = !right.isEmpty() && right.first() != '$' && right.first().isJavaIdentifierPart()
 
-        if (left is JetBinaryExpression && isApplicableToNoParentCheck(left)) {
+        if (left is KtBinaryExpression && isApplicableToNoParentCheck(left)) {
             val leftRight = buildText(left.getRight(), forceBraces)
             return fold(left.getLeft(), leftRight + right, factory)
         }
         else {
             val leftText = buildText(left, forceBraces)
-            return factory.createExpression("\"$leftText$right\"") as JetStringTemplateExpression
+            return factory.createExpression("\"$leftText$right\"") as KtStringTemplateExpression
         }
     }
 
-    private fun buildText(expr: JetExpression?, forceBraces: Boolean): String {
+    private fun buildText(expr: KtExpression?, forceBraces: Boolean): String {
         if (expr == null) return ""
-        val expression = JetPsiUtil.safeDeparenthesize(expr)
+        val expression = KtPsiUtil.safeDeparenthesize(expr)
         val expressionText = expression.getText()
         return when (expression) {
-            is JetConstantExpression -> {
+            is KtConstantExpression -> {
                 val bindingContext = expression.analyze()
                 val constant = ConstantExpressionEvaluator.getConstant(expression, bindingContext)
                 constant?.getValue(bindingContext.getType(expression)!!).toString()
             }
 
-            is JetStringTemplateExpression -> {
+            is KtStringTemplateExpression -> {
                 val base = if (expressionText.startsWith("\"\"\"") && expressionText.endsWith("\"\"\"")) {
                     val unquoted = expressionText.substring(3, expressionText.length() - 3)
                     StringUtil.escapeStringCharacters(unquoted)
@@ -109,7 +109,7 @@ public class ConvertToStringTemplateIntention : JetSelfTargetingOffsetIndependen
                 }
             }
 
-            is JetNameReferenceExpression ->
+            is KtNameReferenceExpression ->
                 "$" + (if (forceBraces) "{$expressionText}" else expressionText)
 
             null -> ""
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/DeprecatedCallableAddReplaceWithIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/DeprecatedCallableAddReplaceWithIntention.kt
index 8309f900814..6086c77480d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/DeprecatedCallableAddReplaceWithIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/DeprecatedCallableAddReplaceWithIntention.kt
@@ -42,26 +42,26 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 import org.jetbrains.kotlin.types.typeUtil.isUnit
 import java.util.*
 
-public class DeprecatedCallableAddReplaceWithInspection : IntentionBasedInspection<JetCallableDeclaration>(DeprecatedCallableAddReplaceWithIntention())
+public class DeprecatedCallableAddReplaceWithInspection : IntentionBasedInspection<KtCallableDeclaration>(DeprecatedCallableAddReplaceWithIntention())
 
-public class DeprecatedCallableAddReplaceWithIntention : JetSelfTargetingRangeIntention<JetCallableDeclaration>(
+public class DeprecatedCallableAddReplaceWithIntention : JetSelfTargetingRangeIntention<KtCallableDeclaration>(
         javaClass(), "Add 'replaceWith' argument to specify replacement pattern", "Add 'replaceWith' argument to 'Deprecated' annotation"
 ) {
     private class ReplaceWith(val expression: String, vararg val imports: String)
 
-    override fun applicabilityRange(element: JetCallableDeclaration): TextRange? {
+    override fun applicabilityRange(element: KtCallableDeclaration): TextRange? {
         val annotationEntry = element.deprecatedAnnotationWithNoReplaceWith() ?: return null
         if (element.suggestReplaceWith() == null) return null
         return annotationEntry.getTextRange()
     }
 
-    override fun applyTo(element: JetCallableDeclaration, editor: Editor) {
+    override fun applyTo(element: KtCallableDeclaration, editor: Editor) {
         val replaceWith = element.suggestReplaceWith()!!
 
         assert('\n' !in replaceWith.expression && '\r' !in replaceWith.expression) { "Formatted expression text should not contain \\n or \\r" }
 
         val annotationEntry = element.deprecatedAnnotationWithNoReplaceWith()!!
-        val psiFactory = JetPsiFactory(element)
+        val psiFactory = KtPsiFactory(element)
 
         var escapedText = replaceWith.expression
                 .replace("\\", "\\\\")
@@ -96,13 +96,13 @@ public class DeprecatedCallableAddReplaceWithIntention : JetSelfTargetingRangeIn
 
         var argument = psiFactory.createArgument(psiFactory.createExpression(argumentText))
         argument = annotationEntry.getValueArgumentList()!!.addArgument(argument)
-        argument = ShortenReferences.DEFAULT.process(argument) as JetValueArgument
+        argument = ShortenReferences.DEFAULT.process(argument) as KtValueArgument
 
         PsiDocumentManager.getInstance(argument.getProject()).doPostponedOperationsAndUnblockDocument(editor.getDocument())
         editor.moveCaret(argument.getTextOffset())
     }
 
-    private fun JetCallableDeclaration.deprecatedAnnotationWithNoReplaceWith(): JetAnnotationEntry? {
+    private fun KtCallableDeclaration.deprecatedAnnotationWithNoReplaceWith(): KtAnnotationEntry? {
         val bindingContext = this.analyze()
 //        val deprecatedConstructor = KotlinBuiltIns.getInstance().getDeprecatedAnnotation().getUnsubstitutedPrimaryConstructor()
         for (entry in getAnnotationEntries()) {
@@ -123,11 +123,11 @@ public class DeprecatedCallableAddReplaceWithIntention : JetSelfTargetingRangeIn
         return null
     }
 
-    private fun JetCallableDeclaration.suggestReplaceWith(): ReplaceWith? {
+    private fun KtCallableDeclaration.suggestReplaceWith(): ReplaceWith? {
         val replacementExpression = when (this) {
-            is JetNamedFunction -> replacementExpressionFromBody()
+            is KtNamedFunction -> replacementExpressionFromBody()
 
-            is JetProperty -> {
+            is KtProperty -> {
                 if (isVar()) return null //TODO
                 getGetter()?.replacementExpressionFromBody()
             }
@@ -136,16 +136,16 @@ public class DeprecatedCallableAddReplaceWithIntention : JetSelfTargetingRangeIn
         } ?: return null
 
         var isGood = true
-        replacementExpression.accept(object: JetVisitorVoid(){
-            override fun visitReturnExpression(expression: JetReturnExpression) {
+        replacementExpression.accept(object: KtVisitorVoid(){
+            override fun visitReturnExpression(expression: KtReturnExpression) {
                 isGood = false
             }
 
-            override fun visitDeclaration(dcl: JetDeclaration) {
+            override fun visitDeclaration(dcl: KtDeclaration) {
                 isGood = false
             }
 
-            override fun visitBlockExpression(expression: JetBlockExpression) {
+            override fun visitBlockExpression(expression: KtBlockExpression) {
                 if (expression.getStatements().size() > 1) {
                     isGood = false
                     return
@@ -153,14 +153,14 @@ public class DeprecatedCallableAddReplaceWithIntention : JetSelfTargetingRangeIn
                 super.visitBlockExpression(expression)
             }
 
-            override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+            override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
                 val target = expression.analyze()[BindingContext.REFERENCE_TARGET, expression] as? DeclarationDescriptorWithVisibility ?: return
                 if (Visibilities.isPrivate((target.getVisibility()))) {
                     isGood = false
                 }
             }
 
-            override fun visitJetElement(element: JetElement) {
+            override fun visitJetElement(element: KtElement) {
                 element.acceptChildren(this)
             }
         })
@@ -170,36 +170,36 @@ public class DeprecatedCallableAddReplaceWithIntention : JetSelfTargetingRangeIn
 
         val text = replacementExpression.getText()
         var expression = try {
-            JetPsiFactory(this).createExpression(text.replace('\n', ' '))
+            KtPsiFactory(this).createExpression(text.replace('\n', ' '))
         }
         catch(e: Throwable) { // does not parse in one line
             return null
         }
-        expression = CodeStyleManager.getInstance(getProject()).reformat(expression, true) as JetExpression
+        expression = CodeStyleManager.getInstance(getProject()).reformat(expression, true) as KtExpression
 
         return ReplaceWith(expression.getText(), *extractImports(replacementExpression).toTypedArray())
     }
 
-    private fun JetDeclarationWithBody.replacementExpressionFromBody(): JetExpression? {
+    private fun KtDeclarationWithBody.replacementExpressionFromBody(): KtExpression? {
         val body = getBodyExpression() ?: return null
         if (!hasBlockBody()) return body
-        val block = body as? JetBlockExpression ?: return null
-        val statement = block.getStatements().singleOrNull() as? JetExpression ?: return null
+        val block = body as? KtBlockExpression ?: return null
+        val statement = block.getStatements().singleOrNull() as? KtExpression ?: return null
         val returnsUnit = (analyze()[BindingContext.DECLARATION_TO_DESCRIPTOR, this] as? FunctionDescriptor)?.getReturnType()?.isUnit() ?: return null
         return when (statement) {
-            is JetReturnExpression -> statement.getReturnedExpression()
+            is KtReturnExpression -> statement.getReturnedExpression()
             else -> if (returnsUnit) statement else null
         }
     }
 
-    private fun extractImports(expression: JetExpression): Collection<String> {
+    private fun extractImports(expression: KtExpression): Collection<String> {
         val file = expression.getContainingJetFile()
         val currentPackageFqName = file.getPackageFqName()
         val importHelper = ImportInsertHelper.getInstance(expression.getProject())
 
         val result = ArrayList<String>()
-        expression.accept(object : JetVisitorVoid(){
-            override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+        expression.accept(object : KtVisitorVoid(){
+            override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
                 val bindingContext = expression.analyze()
                 val target = bindingContext[BindingContext.SHORT_REFERENCE_TO_COMPANION_OBJECT, expression]
                              ?: bindingContext[BindingContext.REFERENCE_TARGET, expression]
@@ -213,7 +213,7 @@ public class DeprecatedCallableAddReplaceWithIntention : JetSelfTargetingRangeIn
                 }
             }
 
-            override fun visitJetElement(element: JetElement) {
+            override fun visitJetElement(element: KtElement) {
                 element.acceptChildren(this)
             }
         })
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/IfNullToElvisIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/IfNullToElvisIntention.kt
index a9685934079..cfe22aa2224 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/IfNullToElvisIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/IfNullToElvisIntention.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.expressionComparedToNull
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.siblings
@@ -34,10 +34,10 @@ import org.jetbrains.kotlin.types.typeUtil.isNothing
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import java.util.*
 
-public class IfNullToElvisInspection : IntentionBasedInspection<JetIfExpression>(IfNullToElvisIntention())
+public class IfNullToElvisInspection : IntentionBasedInspection<KtIfExpression>(IfNullToElvisIntention())
 
-public class IfNullToElvisIntention : JetSelfTargetingRangeIntention<JetIfExpression>(javaClass(), "Replace 'if' with elvis operator"){
-    override fun applicabilityRange(element: JetIfExpression): TextRange? {
+public class IfNullToElvisIntention : JetSelfTargetingRangeIntention<KtIfExpression>(javaClass(), "Replace 'if' with elvis operator"){
+    override fun applicabilityRange(element: KtIfExpression): TextRange? {
         val data = calcData(element) ?: return null
 
         val type = data.ifNullExpression.analyze().getType(data.ifNullExpression) ?: return null
@@ -47,14 +47,14 @@ public class IfNullToElvisIntention : JetSelfTargetingRangeIntention<JetIfExpres
         return TextRange(element.startOffset, rParen.endOffset)
     }
 
-    override fun applyTo(element: JetIfExpression, editor: Editor) {
+    override fun applyTo(element: KtIfExpression, editor: Editor) {
         val newElvis = applyTo(element)
         editor.getCaretModel().moveToOffset(newElvis.getRight()!!.getTextOffset())
     }
 
-    public fun applyTo(element: JetIfExpression): JetBinaryExpression {
+    public fun applyTo(element: KtIfExpression): KtBinaryExpression {
         val (initializer, declaration, ifNullExpr) = calcData(element)!!
-        val factory = JetPsiFactory(element)
+        val factory = KtPsiFactory(element)
 
         val explicitTypeToAdd = if (declaration.isVar() && declaration.getTypeReference() == null)
             initializer.analyze().getType(initializer)
@@ -69,7 +69,7 @@ public class IfNullToElvisIntention : JetSelfTargetingRangeIntention<JetIfExpres
             declaration.add(comment)
         }
 
-        val elvis = factory.createExpressionByPattern("$0 ?: $1", initializer, ifNullExpr) as JetBinaryExpression
+        val elvis = factory.createExpressionByPattern("$0 ?: $1", initializer, ifNullExpr) as KtBinaryExpression
         val newElvis = initializer.replaced(elvis)
         element.delete()
 
@@ -81,27 +81,27 @@ public class IfNullToElvisIntention : JetSelfTargetingRangeIntention<JetIfExpres
     }
 
     private data class Data(
-            val initializer: JetExpression,
-            val declaration: JetVariableDeclaration,
-            val ifNullExpression: JetExpression
+            val initializer: KtExpression,
+            val declaration: KtVariableDeclaration,
+            val ifNullExpression: KtExpression
     )
 
-    private fun calcData(ifExpression: JetIfExpression): Data? {
+    private fun calcData(ifExpression: KtIfExpression): Data? {
         if (ifExpression.getElse() != null) return null
 
-        val binaryExpression = ifExpression.getCondition() as? JetBinaryExpression ?: return null
-        if (binaryExpression.getOperationToken() != JetTokens.EQEQ) return null
-        val value = binaryExpression.expressionComparedToNull() as? JetNameReferenceExpression ?: return null
+        val binaryExpression = ifExpression.getCondition() as? KtBinaryExpression ?: return null
+        if (binaryExpression.getOperationToken() != KtTokens.EQEQ) return null
+        val value = binaryExpression.expressionComparedToNull() as? KtNameReferenceExpression ?: return null
 
-        if (ifExpression.getParent() !is JetBlockExpression) return null
+        if (ifExpression.getParent() !is KtBlockExpression) return null
         val prevStatement = ifExpression.siblings(forward = false, withItself = false)
-                                    .firstIsInstanceOrNull<JetExpression>() ?: return null
-        if (prevStatement !is JetVariableDeclaration) return null
+                                    .firstIsInstanceOrNull<KtExpression>() ?: return null
+        if (prevStatement !is KtVariableDeclaration) return null
         if (prevStatement.getNameAsName() != value.getReferencedNameAsName()) return null
         val initializer = prevStatement.getInitializer() ?: return null
         val then = ifExpression.getThen() ?: return null
 
-        if (then is JetBlockExpression) {
+        if (then is KtBlockExpression) {
             val statement = then.getStatements().singleOrNull() ?: return null
             return Data(initializer, prevStatement, statement)
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/InfixCallToOrdinaryIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/InfixCallToOrdinaryIntention.kt
index 71246bfd53e..67828a2573a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/InfixCallToOrdinaryIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/InfixCallToOrdinaryIntention.kt
@@ -17,28 +17,28 @@
 package org.jetbrains.kotlin.idea.intentions
 
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 
-public class InfixCallToOrdinaryIntention : JetSelfTargetingIntention<JetBinaryExpression>(javaClass(), "Replace infix call with ordinary call") {
-    override fun isApplicableTo(element: JetBinaryExpression, caretOffset: Int): Boolean {
-        if (element.getOperationToken() != JetTokens.IDENTIFIER || element.getLeft() == null || element.getRight() == null) return false
+public class InfixCallToOrdinaryIntention : JetSelfTargetingIntention<KtBinaryExpression>(javaClass(), "Replace infix call with ordinary call") {
+    override fun isApplicableTo(element: KtBinaryExpression, caretOffset: Int): Boolean {
+        if (element.getOperationToken() != KtTokens.IDENTIFIER || element.getLeft() == null || element.getRight() == null) return false
         return element.getOperationReference().getTextRange().containsOffset(caretOffset)
     }
 
-    override fun applyTo(element: JetBinaryExpression, editor: Editor) {
+    override fun applyTo(element: KtBinaryExpression, editor: Editor) {
         convert(element)
     }
 
     companion object {
-        public fun convert(element: JetBinaryExpression): JetExpression {
-            val argument = JetPsiUtil.safeDeparenthesize(element.getRight()!!)
+        public fun convert(element: KtBinaryExpression): KtExpression {
+            val argument = KtPsiUtil.safeDeparenthesize(element.getRight()!!)
             val pattern = "$0.$1" + when (argument) {
-                is JetFunctionLiteralExpression -> " $2:'{}'"
+                is KtFunctionLiteralExpression -> " $2:'{}'"
                 else -> "($2)"
             }
-            val replacement = JetPsiFactory(element).createExpressionByPattern(pattern, element.getLeft()!!, element.getOperationReference().getText(), argument)
-            return element.replace(replacement) as JetExpression
+            val replacement = KtPsiFactory(element).createExpressionByPattern(pattern, element.getLeft()!!, element.getOperationReference().getText(), argument)
+            return element.replace(replacement) as KtExpression
         }
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/InsertCurlyBracesToTemplateIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/InsertCurlyBracesToTemplateIntention.kt
index 607b9219893..0b91b73a747 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/InsertCurlyBracesToTemplateIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/InsertCurlyBracesToTemplateIntention.kt
@@ -18,16 +18,16 @@ package org.jetbrains.kotlin.idea.intentions
 
 import com.intellij.codeInsight.intention.LowPriorityAction
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetSimpleNameStringTemplateEntry
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtSimpleNameStringTemplateEntry
 
-public class InsertCurlyBracesToTemplateIntention : JetSelfTargetingOffsetIndependentIntention<JetSimpleNameStringTemplateEntry> (
+public class InsertCurlyBracesToTemplateIntention : JetSelfTargetingOffsetIndependentIntention<KtSimpleNameStringTemplateEntry> (
         javaClass(), "Insert curly braces around variable"), LowPriorityAction {
 
-    override fun isApplicableTo(element: JetSimpleNameStringTemplateEntry): Boolean = true
+    override fun isApplicableTo(element: KtSimpleNameStringTemplateEntry): Boolean = true
 
-    override fun applyTo(element: JetSimpleNameStringTemplateEntry, editor: Editor) {
+    override fun applyTo(element: KtSimpleNameStringTemplateEntry, editor: Editor) {
         val expression = element.getExpression() ?: return
-        element.replace(JetPsiFactory(element).createBlockStringTemplateEntry(expression))
+        element.replace(KtPsiFactory(element).createBlockStringTemplateEntry(expression))
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/InsertExplicitTypeArgumentsIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/InsertExplicitTypeArgumentsIntention.kt
index 0e2296c19b8..f8ad70c3f37 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/InsertExplicitTypeArgumentsIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/InsertExplicitTypeArgumentsIntention.kt
@@ -22,29 +22,29 @@ import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences
-import org.jetbrains.kotlin.psi.JetCallExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetTypeArgumentList
+import org.jetbrains.kotlin.psi.KtCallExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtTypeArgumentList
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.types.ErrorUtils
 
-public class InsertExplicitTypeArgumentsIntention : JetSelfTargetingRangeIntention<JetCallExpression>(javaClass(), "Add explicit type arguments"), LowPriorityAction {
-    override fun applicabilityRange(element: JetCallExpression): TextRange? {
+public class InsertExplicitTypeArgumentsIntention : JetSelfTargetingRangeIntention<KtCallExpression>(javaClass(), "Add explicit type arguments"), LowPriorityAction {
+    override fun applicabilityRange(element: KtCallExpression): TextRange? {
         return if (isApplicableTo(element, element.analyze())) element.getCalleeExpression()!!.getTextRange() else null
     }
 
-    override fun applyTo(element: JetCallExpression, editor: Editor) {
+    override fun applyTo(element: KtCallExpression, editor: Editor) {
         val argumentList = createTypeArguments(element, element.analyze())!!
 
         val callee = element.getCalleeExpression()!!
-        val newArgumentList = element.addAfter(argumentList, callee) as JetTypeArgumentList
+        val newArgumentList = element.addAfter(argumentList, callee) as KtTypeArgumentList
 
         ShortenReferences.DEFAULT.process(newArgumentList)
     }
 
     companion object {
-        public fun isApplicableTo(element: JetCallExpression, bindingContext: BindingContext): Boolean {
+        public fun isApplicableTo(element: KtCallExpression, bindingContext: BindingContext): Boolean {
             if (!element.getTypeArguments().isEmpty()) return false
             if (element.getCalleeExpression() == null) return false
 
@@ -53,7 +53,7 @@ public class InsertExplicitTypeArgumentsIntention : JetSelfTargetingRangeIntenti
             return typeArgs.isNotEmpty() && typeArgs.values().none { ErrorUtils.containsErrorType(it) }
         }
 
-        public fun createTypeArguments(element: JetCallExpression, bindingContext: BindingContext): JetTypeArgumentList? {
+        public fun createTypeArguments(element: KtCallExpression, bindingContext: BindingContext): KtTypeArgumentList? {
             val resolvedCall = element.getResolvedCall(bindingContext) ?: return null
 
             val args = resolvedCall.getTypeArguments()
@@ -61,7 +61,7 @@ public class InsertExplicitTypeArgumentsIntention : JetSelfTargetingRangeIntenti
 
             val text = types.map { IdeDescriptorRenderers.SOURCE_CODE.renderType(args[it]!!) }.joinToString(", ", "<", ">")
 
-            return JetPsiFactory(element).createTypeArguments(text)
+            return KtPsiFactory(element).createTypeArguments(text)
         }
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/IntroduceBackingPropertyIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/IntroduceBackingPropertyIntention.kt
index 8b76014943d..a2750854432 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/IntroduceBackingPropertyIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/IntroduceBackingPropertyIntention.kt
@@ -28,34 +28,34 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.quickfix.KotlinQuickFixAction
 import org.jetbrains.kotlin.idea.quickfix.JetSingleIntentionActionFactory
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 
-class IntroduceBackingPropertyIntention(): JetSelfTargetingIntention<JetProperty>(javaClass(), "Introduce backing property") {
-    override fun isApplicableTo(element: JetProperty, caretOffset: Int): Boolean {
+class IntroduceBackingPropertyIntention(): JetSelfTargetingIntention<KtProperty>(javaClass(), "Introduce backing property") {
+    override fun isApplicableTo(element: KtProperty, caretOffset: Int): Boolean {
         if (!canIntroduceBackingProperty(element)) return false
         return element.nameIdentifier?.textRange?.containsOffset(caretOffset) == true
     }
 
-    override fun applyTo(element: JetProperty, editor: Editor) {
+    override fun applyTo(element: KtProperty, editor: Editor) {
         introduceBackingProperty(element)
     }
 
     companion object {
-        fun canIntroduceBackingProperty(property: JetProperty): Boolean {
+        fun canIntroduceBackingProperty(property: KtProperty): Boolean {
             val name = property.name ?: return false
 
             val bindingContext = property.getResolutionFacade().analyzeFullyAndGetResult(listOf(property)).bindingContext
             val descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, property) as? PropertyDescriptor ?: return false
             if (bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, descriptor) == false) return false
 
-            val containingClass = property.getStrictParentOfType<JetClassOrObject>() ?: return false
-            return containingClass.declarations.none { it is JetProperty && it.name == "_" + name }
+            val containingClass = property.getStrictParentOfType<KtClassOrObject>() ?: return false
+            return containingClass.declarations.none { it is KtProperty && it.name == "_" + name }
         }
 
-        fun introduceBackingProperty(property: JetProperty) {
+        fun introduceBackingProperty(property: KtProperty) {
             createBackingProperty(property)
 
             if (property.typeReference == null) {
@@ -86,25 +86,25 @@ class IntroduceBackingPropertyIntention(): JetSelfTargetingIntention<JetProperty
             replaceBackingFieldReferences(property)
         }
 
-        private fun createGetter(element: JetProperty) {
+        private fun createGetter(element: KtProperty) {
             val body = "get() = _${element.name}"
-            val newGetter = JetPsiFactory(element).createProperty("val x $body").getter!!
+            val newGetter = KtPsiFactory(element).createProperty("val x $body").getter!!
             element.addAccessor(newGetter)
         }
 
-        private fun createSetter(element: JetProperty) {
+        private fun createSetter(element: KtProperty) {
             val body = "set(value) { _${element.name} = value }"
-            val newSetter = JetPsiFactory(element).createProperty("val x $body").setter!!
+            val newSetter = KtPsiFactory(element).createProperty("val x $body").setter!!
             element.addAccessor(newSetter)
         }
 
-        private fun JetProperty.addAccessor(newAccessor: JetPropertyAccessor) {
-            val semicolon = getNode().findChildByType(JetTokens.SEMICOLON)
+        private fun KtProperty.addAccessor(newAccessor: KtPropertyAccessor) {
+            val semicolon = getNode().findChildByType(KtTokens.SEMICOLON)
             addBefore(newAccessor, semicolon?.psi)
         }
 
-        private fun createBackingProperty(property: JetProperty) {
-            val backingProperty = JetPsiFactory(property).buildDeclaration {
+        private fun createBackingProperty(property: KtProperty) {
+            val backingProperty = KtPsiFactory(property).buildDeclaration {
                 appendFixedText("private ")
                 appendFixedText(property.valOrVarKeyword.text)
                 appendFixedText(" _${property.name}")
@@ -121,47 +121,47 @@ class IntroduceBackingPropertyIntention(): JetSelfTargetingIntention<JetProperty
             property.parent.addBefore(backingProperty, property)
         }
 
-        private fun replaceFieldReferences(element: JetElement, propertyName: String) {
-            element.acceptChildren(object : JetTreeVisitorVoid() {
-                override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+        private fun replaceFieldReferences(element: KtElement, propertyName: String) {
+            element.acceptChildren(object : KtTreeVisitorVoid() {
+                override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
                     val bindingContext = expression.analyze()
                     val target = bindingContext.get(BindingContext.REFERENCE_TARGET, expression)
                     if (target is SyntheticFieldDescriptor) {
-                        expression.replace(JetPsiFactory(element).createSimpleName("_$propertyName"))
+                        expression.replace(KtPsiFactory(element).createSimpleName("_$propertyName"))
                     }
                 }
 
-                override fun visitPropertyAccessor(accessor: JetPropertyAccessor) {
+                override fun visitPropertyAccessor(accessor: KtPropertyAccessor) {
                     // don't go into accessors of properties in local classes because 'field' will mean something different in them
                 }
             })
         }
 
         // TODO: drop this when we get rid of backing field syntax
-        private fun replaceBackingFieldReferences(prop: JetProperty) {
-            val containingClass = prop.getStrictParentOfType<JetClassOrObject>()!!
+        private fun replaceBackingFieldReferences(prop: KtProperty) {
+            val containingClass = prop.getStrictParentOfType<KtClassOrObject>()!!
             ReferencesSearch.search(prop, LocalSearchScope(containingClass)).forEach {
-                val element = it.element as? JetNameReferenceExpression
-                if (element != null && element.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER) {
-                    element.replace(JetPsiFactory(element).createSimpleName("_${prop.name}"))
+                val element = it.element as? KtNameReferenceExpression
+                if (element != null && element.getReferencedNameElementType() == KtTokens.FIELD_IDENTIFIER) {
+                    element.replace(KtPsiFactory(element).createSimpleName("_${prop.name}"))
                 }
             }
         }
     }
 }
 
-class IntroduceBackingPropertyFix(prop: JetProperty): KotlinQuickFixAction<JetProperty>(prop) {
+class IntroduceBackingPropertyFix(prop: KtProperty): KotlinQuickFixAction<KtProperty>(prop) {
     override fun getText(): String = "Introduce backing property"
     override fun getFamilyName(): String  = getText()
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         IntroduceBackingPropertyIntention.introduceBackingProperty(element)
     }
 
     companion object : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
             val resolveResult = diagnostic.psiElement.reference?.resolve()
-            if (resolveResult is JetProperty &&
+            if (resolveResult is KtProperty &&
                 IntroduceBackingPropertyIntention.canIntroduceBackingProperty(resolveResult)) {
                 return IntroduceBackingPropertyFix(resolveResult)
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/InvertIfConditionIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/InvertIfConditionIntention.kt
index d9e67831790..9159ebbe61f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/InvertIfConditionIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/InvertIfConditionIntention.kt
@@ -27,19 +27,19 @@ import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.quickfix.moveCaret
 import org.jetbrains.kotlin.types.typeUtil.isUnit
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.matches
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.*
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstance
 import org.jetbrains.kotlin.utils.addToStdlib.lastIsInstanceOrNull
 
-public class InvertIfConditionIntention : JetSelfTargetingIntention<JetIfExpression>(javaClass(), "Invert 'if' condition") {
-    override fun isApplicableTo(element: JetIfExpression, caretOffset: Int): Boolean {
+public class InvertIfConditionIntention : JetSelfTargetingIntention<KtIfExpression>(javaClass(), "Invert 'if' condition") {
+    override fun isApplicableTo(element: KtIfExpression, caretOffset: Int): Boolean {
         if (!element.getIfKeyword().getTextRange().containsOffset(caretOffset)) return false
         return element.getCondition() != null && element.getThen() != null
     }
 
-    override fun applyTo(element: JetIfExpression, editor: Editor) {
+    override fun applyTo(element: KtIfExpression, editor: Editor) {
         val newCondition = element.getCondition()!!.negate()
 
         val newIf = handleSpecialCases(element, newCondition)
@@ -49,18 +49,18 @@ public class InvertIfConditionIntention : JetSelfTargetingIntention<JetIfExpress
         editor.moveCaret(newIf.getTextOffset())
     }
 
-    private fun handleStandardCase(ifExpression: JetIfExpression, newCondition: JetExpression): JetIfExpression {
-        val psiFactory = JetPsiFactory(ifExpression)
+    private fun handleStandardCase(ifExpression: KtIfExpression, newCondition: KtExpression): KtIfExpression {
+        val psiFactory = KtPsiFactory(ifExpression)
 
         val thenBranch = ifExpression.getThen()!!
         val elseBranch = ifExpression.getElse() ?: psiFactory.createEmptyBody()
 
-        val newThen = if (elseBranch is JetIfExpression)
+        val newThen = if (elseBranch is KtIfExpression)
             psiFactory.createSingleStatementBlock(elseBranch)
         else
             elseBranch
 
-        val newElse = if (thenBranch is JetBlockExpression && thenBranch.getStatements().isEmpty())
+        val newElse = if (thenBranch is KtBlockExpression && thenBranch.getStatements().isEmpty())
             null
         else
             thenBranch
@@ -68,22 +68,22 @@ public class InvertIfConditionIntention : JetSelfTargetingIntention<JetIfExpress
         return ifExpression.replaced(psiFactory.createIf(newCondition, newThen, newElse))
     }
 
-    private fun handleSpecialCases(ifExpression: JetIfExpression, newCondition: JetExpression): JetIfExpression? {
+    private fun handleSpecialCases(ifExpression: KtIfExpression, newCondition: KtExpression): KtIfExpression? {
         val elseBranch = ifExpression.getElse()
         if (elseBranch != null) return null
 
-        val factory = JetPsiFactory(ifExpression)
+        val factory = KtPsiFactory(ifExpression)
 
         val thenBranch = ifExpression.getThen()!!
         val lastThenStatement = thenBranch.lastBlockStatementOrThis()
         if (lastThenStatement.isExitStatement()) {
-            val block = ifExpression.getParent() as? JetBlockExpression
+            val block = ifExpression.getParent() as? KtBlockExpression
             if (block != null) {
                 val rBrace = block.getRBrace()
                 val afterIfInBlock = ifExpression.siblings(withItself = false)
                         .takeWhile { it != rBrace }
                         .toList()
-                val lastStatementInBlock = afterIfInBlock.lastIsInstanceOrNull<JetExpression>()
+                val lastStatementInBlock = afterIfInBlock.lastIsInstanceOrNull<KtExpression>()
                 if (lastStatementInBlock != null) {
                     val exitStatementAfterIf = if (lastStatementInBlock.isExitStatement())
                         lastStatementInBlock
@@ -98,7 +98,7 @@ public class InvertIfConditionIntention : JetSelfTargetingIntention<JetIfExpress
                         // remove statements after if as they are moving under if
                         block.deleteChildRange(first, last)
 
-                        if (lastThenStatement is JetReturnExpression && lastThenStatement.getReturnedExpression() == null) {
+                        if (lastThenStatement is KtReturnExpression && lastThenStatement.getReturnedExpression() == null) {
                             lastThenStatement.delete()
                         }
                         val updatedIf = copyThenBranchAfter(ifExpression)
@@ -114,7 +114,7 @@ public class InvertIfConditionIntention : JetSelfTargetingIntention<JetIfExpress
 
                         //TODO: no block if single?
                         val newIf = factory.createExpressionByPattern("if ($0) { $1 }", newCondition, newIfBodyText)
-                        return updatedIf.replace(newIf) as JetIfExpression
+                        return updatedIf.replace(newIf) as KtIfExpression
                     }
                 }
             }
@@ -125,24 +125,24 @@ public class InvertIfConditionIntention : JetSelfTargetingIntention<JetIfExpress
 
         val updatedIf = copyThenBranchAfter(ifExpression)
         val newIf = factory.createExpressionByPattern("if ($0) $1", newCondition, exitStatement)
-        return updatedIf.replace(newIf) as JetIfExpression
+        return updatedIf.replace(newIf) as KtIfExpression
     }
 
-    private fun copyThenBranchAfter(ifExpression: JetIfExpression): JetIfExpression {
-        val factory = JetPsiFactory(ifExpression)
+    private fun copyThenBranchAfter(ifExpression: KtIfExpression): KtIfExpression {
+        val factory = KtPsiFactory(ifExpression)
         val thenBranch = ifExpression.getThen() ?: return ifExpression
 
         val parent = ifExpression.getParent()
-        if (parent !is JetBlockExpression) {
-            assert(parent is JetContainerNode)
+        if (parent !is KtBlockExpression) {
+            assert(parent is KtContainerNode)
             val block = factory.createEmptyBody()
             block.addAfter(ifExpression, block.getLBrace())
             val newBlock = ifExpression.replaced(block)
-            val newIf = newBlock.getStatements().single() as JetIfExpression
+            val newIf = newBlock.getStatements().single() as KtIfExpression
             return copyThenBranchAfter(newIf)
         }
 
-        if (thenBranch is JetBlockExpression) {
+        if (thenBranch is KtBlockExpression) {
             val range = thenBranch.contentRange()
             if (!range.isEmpty) {
                 parent.addRangeAfter(range.first, range.last, ifExpression)
@@ -156,15 +156,15 @@ public class InvertIfConditionIntention : JetSelfTargetingIntention<JetIfExpress
         return ifExpression
     }
 
-    private fun exitStatementExecutedAfter(expression: JetExpression): JetExpression? {
+    private fun exitStatementExecutedAfter(expression: KtExpression): KtExpression? {
         val parent = expression.getParent()
-        if (parent is JetBlockExpression) {
+        if (parent is KtBlockExpression) {
             val lastStatement = parent.getStatements().last()
             if (expression == lastStatement) {
                 return exitStatementExecutedAfter(parent)
             }
             else {
-                if (lastStatement.isExitStatement() && expression.siblings(withItself = false).firstIsInstance<JetExpression>() == lastStatement) {
+                if (lastStatement.isExitStatement() && expression.siblings(withItself = false).firstIsInstance<KtExpression>() == lastStatement) {
                     return lastStatement
                 }
                 return null
@@ -172,25 +172,25 @@ public class InvertIfConditionIntention : JetSelfTargetingIntention<JetIfExpress
         }
 
         when (parent) {
-            is JetNamedFunction -> {
+            is KtNamedFunction -> {
                 if (parent.getBodyExpression() == expression) {
                     if (!parent.hasBlockBody()) return null
                     val returnType = (parent.resolveToDescriptor() as FunctionDescriptor).getReturnType()
                     if (returnType == null || !returnType.isUnit()) return null
-                    return JetPsiFactory(expression).createExpression("return")
+                    return KtPsiFactory(expression).createExpression("return")
                 }
             }
 
-            is JetContainerNode -> {
+            is KtContainerNode -> {
                 val pparent = parent.getParent()
                 when (pparent) {
-                    is JetLoopExpression -> {
+                    is KtLoopExpression -> {
                         if (expression == pparent.getBody()) {
-                            return JetPsiFactory(expression).createExpression("continue")
+                            return KtPsiFactory(expression).createExpression("continue")
                         }
                     }
 
-                    is JetIfExpression -> {
+                    is KtIfExpression -> {
                         if (expression == pparent.getThen() || expression == pparent.getElse()) {
                             return exitStatementExecutedAfter(pparent)
                         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/IterateExpressionIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/IterateExpressionIntention.kt
index ebf14079e98..538b68ee2a8 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/IterateExpressionIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/IterateExpressionIntention.kt
@@ -32,11 +32,11 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.siblings
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
-public class IterateExpressionIntention : JetSelfTargetingIntention<JetExpression>(javaClass(), "Iterate over collection"), HighPriorityAction {
-    override fun isApplicableTo(element: JetExpression, caretOffset: Int): Boolean {
-        if (element.getParent() !is JetBlockExpression) return false
+public class IterateExpressionIntention : JetSelfTargetingIntention<KtExpression>(javaClass(), "Iterate over collection"), HighPriorityAction {
+    override fun isApplicableTo(element: KtExpression, caretOffset: Int): Boolean {
+        if (element.getParent() !is KtBlockExpression) return false
         val range = element.getTextRange()
         if (caretOffset != range.getStartOffset() && caretOffset != range.getEndOffset()) return false
         val data = data(element) ?: return false
@@ -44,9 +44,9 @@ public class IterateExpressionIntention : JetSelfTargetingIntention<JetExpressio
         return true
     }
 
-    private data class Data(val collectionType: JetType, val elementType: JetType)
+    private data class Data(val collectionType: KtType, val elementType: KtType)
 
-    private fun data(expression: JetExpression): Data? {
+    private fun data(expression: KtExpression): Data? {
         val resolutionFacade = expression.getResolutionFacade()
         val bindingContext = resolutionFacade.analyze(expression, BodyResolveMode.PARTIAL)
         val type = bindingContext.getType(expression) ?: return null
@@ -56,19 +56,19 @@ public class IterateExpressionIntention : JetSelfTargetingIntention<JetExpressio
         return Data(type, elementType)
     }
 
-    override fun applyTo(element: JetExpression, editor: Editor) {
+    override fun applyTo(element: KtExpression, editor: Editor) {
         //TODO: multi-declaration (when?)
 
         val elementType = data(element)!!.elementType
         val nameValidator = NewDeclarationNameValidator(element, element.siblings(), NewDeclarationNameValidator.Target.VARIABLES)
         val names = KotlinNameSuggester.suggestIterationVariableNames(element, elementType, nameValidator, "e")
 
-        var forExpression = JetPsiFactory(element).createExpressionByPattern("for($0 in $1) {\nx\n}", names.first(), element) as JetForExpression
+        var forExpression = KtPsiFactory(element).createExpressionByPattern("for($0 in $1) {\nx\n}", names.first(), element) as KtForExpression
         forExpression = element.replaced(forExpression)
 
         PsiDocumentManager.getInstance(forExpression.getProject()).doPostponedOperationsAndUnblockDocument(editor.getDocument())
 
-        val bodyPlaceholder = (forExpression.getBody() as JetBlockExpression).getStatements().single()
+        val bodyPlaceholder = (forExpression.getBody() as KtBlockExpression).getStatements().single()
 
         val templateBuilder = TemplateBuilderImpl(forExpression)
         templateBuilder.replaceElement(forExpression.getLoopParameter()!!, ChooseStringExpression(names))
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/MoveAssignmentToInitializerIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/MoveAssignmentToInitializerIntention.kt
index bac010475f5..ab3ba397af9 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/MoveAssignmentToInitializerIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/MoveAssignmentToInitializerIntention.kt
@@ -24,39 +24,39 @@ import com.intellij.psi.PsiReferenceService
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.idea.core.canOmitDeclaredType
 import org.jetbrains.kotlin.idea.quickfix.moveCaret
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.*
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 
 public class MoveAssignmentToInitializerIntention :
-        JetSelfTargetingIntention<JetBinaryExpression>(javaClass(), "Move assignment to initializer") {
+        JetSelfTargetingIntention<KtBinaryExpression>(javaClass(), "Move assignment to initializer") {
 
-    override fun isApplicableTo(element: JetBinaryExpression, caretOffset: Int): Boolean {
-        if (element.operationToken != JetTokens.EQ) {
+    override fun isApplicableTo(element: KtBinaryExpression, caretOffset: Int): Boolean {
+        if (element.operationToken != KtTokens.EQ) {
             return false
         }
         val rightExpression = element.right ?: return false
 
         val initializer = PsiTreeUtil.getParentOfType(element,
-                                                      JetClassInitializer::class.java,
-                                                      JetSecondaryConstructor::class.java) ?: return false
+                                                      KtClassInitializer::class.java,
+                                                      KtSecondaryConstructor::class.java) ?: return false
 
         val target = findTargetProperty(element)
         return target != null && target.initializer == null && target.receiverTypeReference == null &&
-               target.getNonStrictParentOfType<JetClassOrObject>() == element.getNonStrictParentOfType<JetClassOrObject>() &&
+               target.getNonStrictParentOfType<KtClassOrObject>() == element.getNonStrictParentOfType<KtClassOrObject>() &&
                hasNoLocalDependencies(rightExpression, initializer)
 
     }
 
-    override fun applyTo(element: JetBinaryExpression, editor: Editor) {
+    override fun applyTo(element: KtBinaryExpression, editor: Editor) {
         val property = findTargetProperty(element) ?: return
         val initializer = element.right ?: return
         val newInitializer = property.setInitializer(initializer)!!
 
-        val initializerBlock = element.getStrictParentOfType<JetClassInitializer>()
+        val initializerBlock = element.getStrictParentOfType<KtClassInitializer>()
         element.delete()
-        if (initializerBlock != null && (initializerBlock.body as? JetBlockExpression)?.isEmpty() == true) {
+        if (initializerBlock != null && (initializerBlock.body as? KtBlockExpression)?.isEmpty() == true) {
             initializerBlock.delete()
         }
 
@@ -73,17 +73,17 @@ public class MoveAssignmentToInitializerIntention :
         }
     }
 
-    private fun findTargetProperty(expr: JetBinaryExpression): JetProperty? {
-        val leftExpression = expr.left as? JetNameReferenceExpression ?: return null
-        return leftExpression.resolveAllReferences().firstIsInstanceOrNull<JetProperty>()
+    private fun findTargetProperty(expr: KtBinaryExpression): KtProperty? {
+        val leftExpression = expr.left as? KtNameReferenceExpression ?: return null
+        return leftExpression.resolveAllReferences().firstIsInstanceOrNull<KtProperty>()
     }
 
-    fun JetBlockExpression.isEmpty(): Boolean {
+    fun KtBlockExpression.isEmpty(): Boolean {
         // a block that only contains comments is not empty
         return contentRange().isEmpty
     }
 
-    private fun hasNoLocalDependencies(element: JetElement, localContext: PsiElement): Boolean {
+    private fun hasNoLocalDependencies(element: KtElement, localContext: PsiElement): Boolean {
         return !element.anyDescendantOfType<PsiElement> { child ->
             child.resolveAllReferences().any { it != null && PsiTreeUtil.isAncestor(localContext, it, false) }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaInsideParenthesesIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaInsideParenthesesIntention.kt
index 64e898e2a3e..4b3de4ecd76 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaInsideParenthesesIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaInsideParenthesesIntention.kt
@@ -21,16 +21,16 @@ import com.intellij.openapi.editor.Editor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
 import org.jetbrains.kotlin.idea.core.moveInsideParentheses
-import org.jetbrains.kotlin.psi.JetFunctionLiteralArgument
+import org.jetbrains.kotlin.psi.KtFunctionLiteralArgument
 import org.jetbrains.kotlin.psi.psiUtil.containsInside
 
-public class MoveLambdaInsideParenthesesIntention : JetSelfTargetingIntention<JetFunctionLiteralArgument>(javaClass(), "Move lambda argument into parentheses"), LowPriorityAction {
-    override fun isApplicableTo(element: JetFunctionLiteralArgument, caretOffset: Int): Boolean {
+public class MoveLambdaInsideParenthesesIntention : JetSelfTargetingIntention<KtFunctionLiteralArgument>(javaClass(), "Move lambda argument into parentheses"), LowPriorityAction {
+    override fun isApplicableTo(element: KtFunctionLiteralArgument, caretOffset: Int): Boolean {
         val body = element.getFunctionLiteral().getBodyExpression() ?: return true
         return !body.getTextRange().containsInside(caretOffset)
     }
 
-    override fun applyTo(element: JetFunctionLiteralArgument, editor: Editor) {
+    override fun applyTo(element: KtFunctionLiteralArgument, editor: Editor) {
         element.moveInsideParentheses(element.analyze())
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaOutsideParenthesesIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaOutsideParenthesesIntention.kt
index 1b1f68a4bc4..667f13fe0af 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaOutsideParenthesesIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaOutsideParenthesesIntention.kt
@@ -21,23 +21,23 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.moveFunctionLiteralOutsideParentheses
-import org.jetbrains.kotlin.psi.JetCallExpression
-import org.jetbrains.kotlin.psi.JetNameReferenceExpression
+import org.jetbrains.kotlin.psi.KtCallExpression
+import org.jetbrains.kotlin.psi.KtNameReferenceExpression
 import org.jetbrains.kotlin.psi.psiUtil.containsInside
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.psi.unpackFunctionLiteral
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 
-public class MoveLambdaOutsideParenthesesIntention : JetSelfTargetingIntention<JetCallExpression>(javaClass(), "Move lambda argument out of parentheses") {
-    override fun isApplicableTo(element: JetCallExpression, caretOffset: Int): Boolean {
+public class MoveLambdaOutsideParenthesesIntention : JetSelfTargetingIntention<KtCallExpression>(javaClass(), "Move lambda argument out of parentheses") {
+    override fun isApplicableTo(element: KtCallExpression, caretOffset: Int): Boolean {
         if (element.getFunctionLiteralArguments().isNotEmpty()) return false
         val argument = element.getValueArguments().lastOrNull() ?: return false
         val expression = argument.getArgumentExpression() ?: return false
         val functionLiteral = expression.unpackFunctionLiteral() ?: return false
 
         val callee = element.getCalleeExpression()
-        if (callee is JetNameReferenceExpression) {
+        if (callee is KtNameReferenceExpression) {
             val bindingContext = element.analyze(BodyResolveMode.PARTIAL)
             val targets = bindingContext[BindingContext.REFERENCE_TARGET, callee]?.let { listOf(it) }
                           ?: bindingContext[BindingContext.AMBIGUOUS_REFERENCE_TARGET, callee]
@@ -57,11 +57,11 @@ public class MoveLambdaOutsideParenthesesIntention : JetSelfTargetingIntention<J
         return !bodyRange.containsInside(caretOffset)
     }
 
-    override fun applyTo(element: JetCallExpression, editor: Editor) {
+    override fun applyTo(element: KtCallExpression, editor: Editor) {
         element.moveFunctionLiteralOutsideParentheses()
     }
 
-    fun applyTo(element: JetCallExpression) {
+    fun applyTo(element: KtCallExpression) {
         element.moveFunctionLiteralOutsideParentheses()
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ReconstructTypeInCastOrIsIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ReconstructTypeInCastOrIsIntention.kt
index 5c925337584..ecbdae49247 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ReconstructTypeInCastOrIsIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ReconstructTypeInCastOrIsIntention.kt
@@ -25,19 +25,19 @@ import org.jetbrains.kotlin.idea.util.ShortenReferences
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
-public class ReconstructTypeInCastOrIsIntention : JetSelfTargetingOffsetIndependentIntention<JetTypeReference>(javaClass(), "Replace by reconstructed type"), LowPriorityAction {
-    override fun isApplicableTo(element: JetTypeReference): Boolean {
+public class ReconstructTypeInCastOrIsIntention : JetSelfTargetingOffsetIndependentIntention<KtTypeReference>(javaClass(), "Replace by reconstructed type"), LowPriorityAction {
+    override fun isApplicableTo(element: KtTypeReference): Boolean {
         // Only user types (like Foo) are interesting
-        val typeElement = element.typeElement as? JetUserType ?: return false
+        val typeElement = element.typeElement as? KtUserType ?: return false
 
         // If there are generic arguments already, there's nothing to reconstruct
         if (typeElement.getTypeArguments().isNotEmpty()) return false
 
         // We must be on the RHS of as/as?/is/!is or inside an is/!is-condition in when()
-        val expression = element.getParentOfType<JetExpression>(true)
-        if (expression !is JetBinaryExpressionWithTypeRHS && element.getParentOfType<JetWhenConditionIsPattern>(true) == null) return false
+        val expression = element.getParentOfType<KtExpression>(true)
+        if (expression !is KtBinaryExpressionWithTypeRHS && element.getParentOfType<KtWhenConditionIsPattern>(true) == null) return false
 
         val type = getReconstructedType(element)
         if (type == null || type.isError()) return false
@@ -51,13 +51,13 @@ public class ReconstructTypeInCastOrIsIntention : JetSelfTargetingOffsetIndepend
         return true
     }
 
-    override fun applyTo(element: JetTypeReference, editor: Editor) {
+    override fun applyTo(element: KtTypeReference, editor: Editor) {
         val type = getReconstructedType(element)!!
-        val newType = JetPsiFactory(element).createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type))
+        val newType = KtPsiFactory(element).createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type))
         ShortenReferences.DEFAULT.process(element.replaced(newType))
     }
 
-    private fun getReconstructedType(typeRef: JetTypeReference): JetType? {
+    private fun getReconstructedType(typeRef: KtTypeReference): KtType? {
         return typeRef.analyze().get(BindingContext.TYPE, typeRef)
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveArgumentNameIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveArgumentNameIntention.kt
index 544eb636f06..5b359d8f8b1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveArgumentNameIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveArgumentNameIntention.kt
@@ -19,26 +19,26 @@ package org.jetbrains.kotlin.idea.intentions
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetValueArgument
-import org.jetbrains.kotlin.psi.JetValueArgumentList
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtValueArgument
+import org.jetbrains.kotlin.psi.KtValueArgumentList
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 
 public class RemoveArgumentNameIntention
-  : JetSelfTargetingRangeIntention<JetValueArgument>(javaClass(), "Remove argument name") {
+  : JetSelfTargetingRangeIntention<KtValueArgument>(javaClass(), "Remove argument name") {
 
-    override fun applicabilityRange(element: JetValueArgument): TextRange? {
+    override fun applicabilityRange(element: KtValueArgument): TextRange? {
         if (!element.isNamed()) return null
 
-        val argumentList = element.getParent() as? JetValueArgumentList ?: return null
+        val argumentList = element.getParent() as? KtValueArgumentList ?: return null
         val arguments = argumentList.getArguments()
         if (arguments.takeWhile { it != element }.any { it.isNamed() }) return null
 
-        val callExpr = argumentList.getParent() as? JetExpression ?: return null
+        val callExpr = argumentList.getParent() as? KtExpression ?: return null
         val resolvedCall = callExpr.getResolvedCall(callExpr.analyze(BodyResolveMode.PARTIAL)) ?: return null
         val argumentMatch = resolvedCall.getArgumentMapping(element) as? ArgumentMatch ?: return null
         if (argumentMatch.valueParameter.getIndex() != arguments.indexOf(element)) return null
@@ -47,8 +47,8 @@ public class RemoveArgumentNameIntention
         return TextRange(element.startOffset, expression.startOffset)
     }
 
-    override fun applyTo(element: JetValueArgument, editor: Editor) {
-        val newArgument = JetPsiFactory(element).createArgument(element.getArgumentExpression()!!, null, element.getSpreadElement() != null)
+    override fun applyTo(element: KtValueArgument, editor: Editor) {
+        val newArgument = KtPsiFactory(element).createArgument(element.getArgumentExpression()!!, null, element.getSpreadElement() != null)
         element.replace(newArgument)
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveBracesIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveBracesIntention.kt
index 53e67a2f5ed..be63b44c8a9 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveBracesIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveBracesIntention.kt
@@ -22,11 +22,11 @@ import com.intellij.psi.PsiWhiteSpace
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 
-public class RemoveBracesIntention : JetSelfTargetingIntention<JetBlockExpression>(javaClass(), "Remove braces") {
-    override fun isApplicableTo(element: JetBlockExpression, caretOffset: Int): Boolean {
+public class RemoveBracesIntention : JetSelfTargetingIntention<KtBlockExpression>(javaClass(), "Remove braces") {
+    override fun isApplicableTo(element: KtBlockExpression, caretOffset: Int): Boolean {
         if (element.getStatements().size() != 1) return false
 
-        val containerNode = element.getParent() as? JetContainerNode ?: return false
+        val containerNode = element.getParent() as? KtContainerNode ?: return false
 
         val lBrace = element.getLBrace() ?: return false
         val rBrace = element.getRBrace() ?: return false
@@ -37,27 +37,27 @@ public class RemoveBracesIntention : JetSelfTargetingIntention<JetBlockExpressio
         return true
     }
 
-    override fun applyTo(element: JetBlockExpression, editor: Editor) {
+    override fun applyTo(element: KtBlockExpression, editor: Editor) {
         val statement = element.getStatements().single()
 
-        val containerNode = element.getParent() as JetContainerNode
-        val construct = containerNode.getParent() as JetExpression
+        val containerNode = element.getParent() as KtContainerNode
+        val construct = containerNode.getParent() as KtExpression
         handleComments(construct, element)
 
         val newElement = element.replace(statement.copy())
 
-        if (construct is JetDoWhileExpression) {
-            newElement.getParent()!!.addAfter(JetPsiFactory(element).createNewLine(), newElement)
+        if (construct is KtDoWhileExpression) {
+            newElement.getParent()!!.addAfter(KtPsiFactory(element).createNewLine(), newElement)
         }
     }
 
-    private fun handleComments(construct: JetExpression, block: JetBlockExpression) {
+    private fun handleComments(construct: KtExpression, block: KtBlockExpression) {
         var sibling = block.getFirstChild()?.getNextSibling()
 
         while (sibling != null) {
             if (sibling is PsiComment) {
                 //cleans up extra whitespace
-                val psiFactory = JetPsiFactory(construct)
+                val psiFactory = KtPsiFactory(construct)
                 if (construct.getPrevSibling() is PsiWhiteSpace) {
                     construct.getPrevSibling()!!.replace(psiFactory.createNewLine())
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveCurlyBracesFromTemplateIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveCurlyBracesFromTemplateIntention.kt
index 3200fb40a5e..692cfbaed11 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveCurlyBracesFromTemplateIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveCurlyBracesFromTemplateIntention.kt
@@ -19,28 +19,28 @@ package org.jetbrains.kotlin.idea.intentions
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
-import org.jetbrains.kotlin.psi.JetBlockStringTemplateEntry
-import org.jetbrains.kotlin.psi.JetNameReferenceExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetStringTemplateEntryWithExpression
+import org.jetbrains.kotlin.psi.KtBlockStringTemplateEntry
+import org.jetbrains.kotlin.psi.KtNameReferenceExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtStringTemplateEntryWithExpression
 import java.util.regex.Pattern
 
-public class RemoveCurlyBracesFromTemplateInspection : IntentionBasedInspection<JetBlockStringTemplateEntry>(RemoveCurlyBracesFromTemplateIntention())
+public class RemoveCurlyBracesFromTemplateInspection : IntentionBasedInspection<KtBlockStringTemplateEntry>(RemoveCurlyBracesFromTemplateIntention())
 
-public class RemoveCurlyBracesFromTemplateIntention : JetSelfTargetingOffsetIndependentIntention<JetBlockStringTemplateEntry>(javaClass(), "Remove curly braces") {
-    override fun isApplicableTo(element: JetBlockStringTemplateEntry): Boolean {
-        if (element.getExpression() !is JetNameReferenceExpression) return false
+public class RemoveCurlyBracesFromTemplateIntention : JetSelfTargetingOffsetIndependentIntention<KtBlockStringTemplateEntry>(javaClass(), "Remove curly braces") {
+    override fun isApplicableTo(element: KtBlockStringTemplateEntry): Boolean {
+        if (element.getExpression() !is KtNameReferenceExpression) return false
         val nextSiblingText = element.getNextSibling()?.getText()
         return nextSiblingText == null || !pattern.matcher(nextSiblingText).matches()
     }
 
-    override fun applyTo(element: JetBlockStringTemplateEntry, editor: Editor) {
+    override fun applyTo(element: KtBlockStringTemplateEntry, editor: Editor) {
         applyTo(element)
     }
 
-    public fun applyTo(element: JetBlockStringTemplateEntry): JetStringTemplateEntryWithExpression {
-        val name = (element.getExpression() as JetNameReferenceExpression).getReferencedName()
-        val newEntry = JetPsiFactory(element).createSimpleNameStringTemplateEntry(name)
+    public fun applyTo(element: KtBlockStringTemplateEntry): KtStringTemplateEntryWithExpression {
+        val name = (element.getExpression() as KtNameReferenceExpression).getReferencedName()
+        val newEntry = KtPsiFactory(element).createSimpleNameStringTemplateEntry(name)
         return element.replaced(newEntry)
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitLambdaParameterTypesIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitLambdaParameterTypesIntention.kt
index ccf44bb5a47..a11a3bc27e4 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitLambdaParameterTypesIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitLambdaParameterTypesIntention.kt
@@ -17,23 +17,23 @@
 package org.jetbrains.kotlin.idea.intentions
 
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.psi.JetFunctionLiteralExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.psi.KtFunctionLiteralExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 
-public class RemoveExplicitLambdaParameterTypesIntention : JetSelfTargetingIntention<JetFunctionLiteralExpression>(javaClass(), "Remove explicit lambda parameter types (may break code)") {
-    override fun isApplicableTo(element: JetFunctionLiteralExpression, caretOffset: Int): Boolean {
+public class RemoveExplicitLambdaParameterTypesIntention : JetSelfTargetingIntention<KtFunctionLiteralExpression>(javaClass(), "Remove explicit lambda parameter types (may break code)") {
+    override fun isApplicableTo(element: KtFunctionLiteralExpression, caretOffset: Int): Boolean {
         if (element.getValueParameters().none { it.getTypeReference() != null }) return false
         val arrow = element.getFunctionLiteral().getArrow() ?: return false
         return caretOffset <= arrow.endOffset
     }
 
-    override fun applyTo(element: JetFunctionLiteralExpression, editor: Editor) {
+    override fun applyTo(element: KtFunctionLiteralExpression, editor: Editor) {
         val oldParameterList = element.getFunctionLiteral().getValueParameterList()!!
 
         val parameterString = oldParameterList.getParameters().map { it.getName() }.joinToString(", ")
-        val newParameterList = JetPsiFactory(element).createFunctionLiteralParameterList(parameterString)
+        val newParameterList = KtPsiFactory(element).createFunctionLiteralParameterList(parameterString)
         oldParameterList.replace(newParameterList)
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitSuperQualifierIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitSuperQualifierIntention.kt
index 53d0a7a9e2c..94b06cb174b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitSuperQualifierIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitSuperQualifierIntention.kt
@@ -23,9 +23,9 @@ import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.analysis.analyzeInContext
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetQualifiedExpression
-import org.jetbrains.kotlin.psi.JetSuperExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtQualifiedExpression
+import org.jetbrains.kotlin.psi.KtSuperExpression
 import org.jetbrains.kotlin.psi.createExpressionByPattern
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForReceiver
@@ -37,13 +37,13 @@ import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.TypeUtils
 
-public class RemoveExplicitSuperQualifierInspection : IntentionBasedInspection<JetSuperExpression>(RemoveExplicitSuperQualifierIntention()), CleanupLocalInspectionTool {
+public class RemoveExplicitSuperQualifierInspection : IntentionBasedInspection<KtSuperExpression>(RemoveExplicitSuperQualifierIntention()), CleanupLocalInspectionTool {
     override val problemHighlightType: ProblemHighlightType
         get() = ProblemHighlightType.LIKE_UNUSED_SYMBOL
 }
 
-public class RemoveExplicitSuperQualifierIntention : JetSelfTargetingRangeIntention<JetSuperExpression>(javaClass(), "Remove explicit supertype qualification") {
-    override fun applicabilityRange(element: JetSuperExpression): TextRange? {
+public class RemoveExplicitSuperQualifierIntention : JetSelfTargetingRangeIntention<KtSuperExpression>(javaClass(), "Remove explicit supertype qualification") {
+    override fun applicabilityRange(element: KtSuperExpression): TextRange? {
         if (element.superTypeQualifier == null) return null
 
         val qualifiedExpression = element.getQualifiedExpressionForReceiver() ?: return null
@@ -55,7 +55,7 @@ public class RemoveExplicitSuperQualifierIntention : JetSelfTargetingRangeIntent
         val dataFlowInfo = bindingContext.getDataFlowInfo(element)
         val expectedType = bindingContext[BindingContext.EXPECTED_EXPRESSION_TYPE, qualifiedExpression] ?: TypeUtils.NO_EXPECTED_TYPE
 
-        val newQualifiedExpression = JetPsiFactory(element).createExpressionByPattern("$0.$1", toNonQualified(element), selector) as JetQualifiedExpression
+        val newQualifiedExpression = KtPsiFactory(element).createExpressionByPattern("$0.$1", toNonQualified(element), selector) as KtQualifiedExpression
         val newBindingContext = newQualifiedExpression.analyzeInContext(resolutionScope, qualifiedExpression, dataFlowInfo = dataFlowInfo, expectedType = expectedType, isStatement = true)
         val newResolvedCall = newQualifiedExpression.selectorExpression.getResolvedCall(newBindingContext) ?: return null
         if (ErrorUtils.isError(newResolvedCall.resultingDescriptor)) return null
@@ -63,16 +63,16 @@ public class RemoveExplicitSuperQualifierIntention : JetSelfTargetingRangeIntent
         return TextRange(element.instanceReference.endOffset, element.labelQualifier?.startOffset ?: element.endOffset)
     }
 
-    override fun applyTo(element: JetSuperExpression, editor: Editor) {
+    override fun applyTo(element: KtSuperExpression, editor: Editor) {
         element.replace(toNonQualified(element))
     }
 
-    private fun toNonQualified(superExpression: JetSuperExpression): JetSuperExpression {
-        val factory = JetPsiFactory(superExpression)
+    private fun toNonQualified(superExpression: KtSuperExpression): KtSuperExpression {
+        val factory = KtPsiFactory(superExpression)
         val labelName = superExpression.getLabelNameAsName()
         return (if (labelName != null)
             factory.createExpressionByPattern("super@$0", labelName)
         else
-            factory.createExpression("super")) as JetSuperExpression
+            factory.createExpression("super")) as KtSuperExpression
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArgumentsIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArgumentsIntention.kt
index 21bf13e5cdc..d6f789d8abd 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArgumentsIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArgumentsIntention.kt
@@ -29,19 +29,19 @@ import org.jetbrains.kotlin.resolve.calls.CallResolver
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.calls.util.DelegatingCall
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 
-public class RemoveExplicitTypeArgumentsInspection : IntentionBasedInspection<JetTypeArgumentList>(RemoveExplicitTypeArgumentsIntention()) {
+public class RemoveExplicitTypeArgumentsInspection : IntentionBasedInspection<KtTypeArgumentList>(RemoveExplicitTypeArgumentsIntention()) {
     override val problemHighlightType: ProblemHighlightType
         get() = ProblemHighlightType.LIKE_UNUSED_SYMBOL
 }
 
-public class RemoveExplicitTypeArgumentsIntention : JetSelfTargetingOffsetIndependentIntention<JetTypeArgumentList>(javaClass(), "Remove explicit type arguments") {
+public class RemoveExplicitTypeArgumentsIntention : JetSelfTargetingOffsetIndependentIntention<KtTypeArgumentList>(javaClass(), "Remove explicit type arguments") {
     companion object {
-        public fun isApplicableTo(element: JetTypeArgumentList, approximateFlexible: Boolean): Boolean {
-            val callExpression = element.getParent() as? JetCallExpression ?: return false
+        public fun isApplicableTo(element: KtTypeArgumentList, approximateFlexible: Boolean): Boolean {
+            val callExpression = element.getParent() as? KtCallExpression ?: return false
             if (callExpression.getTypeArguments().isEmpty()) return false
 
             val resolutionFacade = callExpression.getResolutionFacade()
@@ -57,9 +57,9 @@ public class RemoveExplicitTypeArgumentsIntention : JetSelfTargetingOffsetIndepe
             // therefore we should resolve outer call with erased type arguments for inner call
             val parent = callExpression.getParent()
             val expectedTypeIsExplicitInCode = when (parent) {
-                is JetProperty -> parent.getInitializer() == callExpression && parent.getTypeReference() != null
-                is JetDeclarationWithBody -> parent.getBodyExpression() == callExpression
-                is JetReturnExpression -> true
+                is KtProperty -> parent.getInitializer() == callExpression && parent.getTypeReference() != null
+                is KtDeclarationWithBody -> parent.getBodyExpression() == callExpression
+                is KtReturnExpression -> true
                 else -> false
             }
             val expectedType = if (expectedTypeIsExplicitInCode) {
@@ -79,9 +79,9 @@ public class RemoveExplicitTypeArgumentsIntention : JetSelfTargetingOffsetIndepe
             val args = originalCall.getTypeArguments()
             val newArgs = resolutionResults.getResultingCall().getTypeArguments()
 
-            fun equalTypes(type1: JetType, type2: JetType): Boolean {
+            fun equalTypes(type1: KtType, type2: KtType): Boolean {
                 return if (approximateFlexible) {
-                    JetTypeChecker.DEFAULT.equalTypes(type1, type2)
+                    KotlinTypeChecker.DEFAULT.equalTypes(type1, type2)
                 }
                 else {
                     type1 == type2
@@ -92,16 +92,16 @@ public class RemoveExplicitTypeArgumentsIntention : JetSelfTargetingOffsetIndepe
         }
     }
 
-    override fun isApplicableTo(element: JetTypeArgumentList): Boolean {
+    override fun isApplicableTo(element: KtTypeArgumentList): Boolean {
         return isApplicableTo(element, approximateFlexible = false)
     }
 
     private class CallWithoutTypeArgs(call: Call) : DelegatingCall(call) {
-        override fun getTypeArguments() = emptyList<JetTypeProjection>()
+        override fun getTypeArguments() = emptyList<KtTypeProjection>()
         override fun getTypeArgumentList() = null
     }
 
-    override fun applyTo(element: JetTypeArgumentList, editor: Editor) {
+    override fun applyTo(element: KtTypeArgumentList, editor: Editor) {
         element.delete()
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeIntention.kt
index 588d15b5786..83992c4b35b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeIntention.kt
@@ -19,23 +19,23 @@ package org.jetbrains.kotlin.idea.intentions
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.kotlin.psi.*
 
-public class RemoveExplicitTypeIntention : JetSelfTargetingIntention<JetCallableDeclaration>(javaClass(), "Remove explicit type specification") {
-    override fun isApplicableTo(element: JetCallableDeclaration, caretOffset: Int): Boolean {
-        if (element.getContainingFile() is JetCodeFragment) return false
+public class RemoveExplicitTypeIntention : JetSelfTargetingIntention<KtCallableDeclaration>(javaClass(), "Remove explicit type specification") {
+    override fun isApplicableTo(element: KtCallableDeclaration, caretOffset: Int): Boolean {
+        if (element.getContainingFile() is KtCodeFragment) return false
         if (element.getTypeReference() == null) return false
 
-        val initializer = (element as? JetWithExpressionInitializer)?.getInitializer()
+        val initializer = (element as? KtWithExpressionInitializer)?.getInitializer()
         if (initializer != null && initializer.getTextRange().containsOffset(caretOffset)) return false
 
         return when (element) {
-            is JetProperty -> initializer != null
-            is JetNamedFunction -> !element.hasBlockBody() && initializer != null
-            is JetParameter -> element.isLoopParameter()
+            is KtProperty -> initializer != null
+            is KtNamedFunction -> !element.hasBlockBody() && initializer != null
+            is KtParameter -> element.isLoopParameter()
             else -> false
         }
     }
 
-    override fun applyTo(element: JetCallableDeclaration, editor: Editor) {
+    override fun applyTo(element: KtCallableDeclaration, editor: Editor) {
         element.setTypeReference(null)
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveForLoopIndicesIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveForLoopIndicesIntention.kt
index abf076e9210..a8939563ac6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveForLoopIndicesIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveForLoopIndicesIntention.kt
@@ -23,15 +23,15 @@ import com.intellij.psi.search.searches.ReferencesSearch
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.editor.fixers.range
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
-import org.jetbrains.kotlin.psi.JetDotQualifiedExpression
-import org.jetbrains.kotlin.psi.JetForExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtDotQualifiedExpression
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.createExpressionByPattern
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 
-public class RemoveForLoopIndicesInspection : IntentionBasedInspection<JetForExpression>(
+public class RemoveForLoopIndicesInspection : IntentionBasedInspection<KtForExpression>(
         listOf(IntentionBasedInspection.IntentionData(RemoveForLoopIndicesIntention())),
         "Index is not used in the loop body",
         javaClass()
@@ -40,11 +40,11 @@ public class RemoveForLoopIndicesInspection : IntentionBasedInspection<JetForExp
         get() = ProblemHighlightType.LIKE_UNUSED_SYMBOL
 }
 
-public class RemoveForLoopIndicesIntention : JetSelfTargetingRangeIntention<JetForExpression>(javaClass(), "Remove indices in 'for' loop") {
+public class RemoveForLoopIndicesIntention : JetSelfTargetingRangeIntention<KtForExpression>(javaClass(), "Remove indices in 'for' loop") {
     private val WITH_INDEX_FQ_NAME = "kotlin.withIndex"
 
-    override fun applicabilityRange(element: JetForExpression): TextRange? {
-        val loopRange = element.loopRange as? JetDotQualifiedExpression ?: return null
+    override fun applicabilityRange(element: KtForExpression): TextRange? {
+        val loopRange = element.loopRange as? KtDotQualifiedExpression ?: return null
         val multiParameter = element.multiParameter ?: return null
         if (multiParameter.entries.size() != 2) return null
 
@@ -59,12 +59,12 @@ public class RemoveForLoopIndicesIntention : JetSelfTargetingRangeIntention<JetF
         return indexVar.nameIdentifier?.range
     }
 
-    override fun applyTo(element: JetForExpression, editor: Editor) {
+    override fun applyTo(element: KtForExpression, editor: Editor) {
         val multiParameter = element.multiParameter!!
-        val loopRange = element.loopRange as JetDotQualifiedExpression
+        val loopRange = element.loopRange as KtDotQualifiedExpression
 
         val elementVar = multiParameter.entries[1]
-        val loop = JetPsiFactory(element).createExpressionByPattern("for ($0 in _) {}", elementVar.text) as JetForExpression
+        val loop = KtPsiFactory(element).createExpressionByPattern("for ($0 in _) {}", elementVar.text) as KtForExpression
         multiParameter.replace(loop.loopParameter!!)
 
         loopRange.replace(loopRange.receiverExpression)
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveUnnecessaryParenthesesIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveUnnecessaryParenthesesIntention.kt
index 12e6d5e250e..5c02beb5b18 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveUnnecessaryParenthesesIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveUnnecessaryParenthesesIntention.kt
@@ -17,18 +17,18 @@
 package org.jetbrains.kotlin.idea.intentions
 
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.psi.JetParenthesizedExpression
-import org.jetbrains.kotlin.psi.JetPsiUtil
+import org.jetbrains.kotlin.psi.KtParenthesizedExpression
+import org.jetbrains.kotlin.psi.KtPsiUtil
 import org.jetbrains.kotlin.psi.psiUtil.containsInside
 
-public class RemoveUnnecessaryParenthesesIntention : JetSelfTargetingIntention<JetParenthesizedExpression>(javaClass(), "Remove unnecessary parentheses") {
-    override fun isApplicableTo(element: JetParenthesizedExpression, caretOffset: Int): Boolean {
+public class RemoveUnnecessaryParenthesesIntention : JetSelfTargetingIntention<KtParenthesizedExpression>(javaClass(), "Remove unnecessary parentheses") {
+    override fun isApplicableTo(element: KtParenthesizedExpression, caretOffset: Int): Boolean {
         val expression = element.getExpression() ?: return false
-        if (!JetPsiUtil.areParenthesesUseless(element)) return false
+        if (!KtPsiUtil.areParenthesesUseless(element)) return false
         return !expression.getTextRange().containsInside(caretOffset)
     }
 
-    override fun applyTo(element: JetParenthesizedExpression, editor: Editor) {
+    override fun applyTo(element: KtParenthesizedExpression, editor: Editor) {
         element.replace(element.getExpression()!!)
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceExplicitFunctionLiteralParamWithItIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceExplicitFunctionLiteralParamWithItIntention.kt
index ed3a5840496..5c6c1014793 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceExplicitFunctionLiteralParamWithItIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceExplicitFunctionLiteralParamWithItIntention.kt
@@ -28,8 +28,8 @@ import org.jetbrains.kotlin.descriptors.ParameterDescriptor
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.references.mainReference
-import org.jetbrains.kotlin.psi.JetFunctionLiteral
-import org.jetbrains.kotlin.psi.JetNameReferenceExpression
+import org.jetbrains.kotlin.psi.KtFunctionLiteral
+import org.jetbrains.kotlin.psi.KtNameReferenceExpression
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
@@ -55,16 +55,16 @@ public class ReplaceExplicitFunctionLiteralParamWithItIntention() : PsiElementBa
         ParamRenamingProcessor(editor, functionLiteral, cursorInParameterList).run()
     }
 
-    private fun targetFunctionLiteral(element: PsiElement, caretOffset: Int): JetFunctionLiteral? {
-        val expression = element.getParentOfType<JetNameReferenceExpression>(true)
+    private fun targetFunctionLiteral(element: PsiElement, caretOffset: Int): KtFunctionLiteral? {
+        val expression = element.getParentOfType<KtNameReferenceExpression>(true)
         if (expression != null) {
             val target = expression.mainReference.resolveToDescriptors(expression.analyze(BodyResolveMode.PARTIAL))
                                  .singleOrNull() as? ParameterDescriptor ?: return null
             val functionDescriptor = target.getContainingDeclaration() as? AnonymousFunctionDescriptor ?: return null
-            return DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor) as? JetFunctionLiteral
+            return DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor) as? KtFunctionLiteral
         }
 
-        val functionLiteral = element.getParentOfType<JetFunctionLiteral>(true) ?: return null
+        val functionLiteral = element.getParentOfType<KtFunctionLiteral>(true) ?: return null
         val arrow = functionLiteral.getArrow() ?: return null
         if (caretOffset > arrow.endOffset) return null
         return functionLiteral
@@ -72,7 +72,7 @@ public class ReplaceExplicitFunctionLiteralParamWithItIntention() : PsiElementBa
 
     private class ParamRenamingProcessor(
             val editor: Editor,
-            val functionLiteral: JetFunctionLiteral,
+            val functionLiteral: KtFunctionLiteral,
             val cursorWasInParameterList: Boolean
     ) : RenameProcessor(editor.getProject(),
                         functionLiteral.getValueParameters().single(),
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceItWithExplicitFunctionLiteralParamIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceItWithExplicitFunctionLiteralParamIntention.kt
index 1496f16d016..e3a548ec77b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceItWithExplicitFunctionLiteralParamIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceItWithExplicitFunctionLiteralParamIntention.kt
@@ -21,23 +21,23 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.psi.PsiDocumentManager
 import com.intellij.refactoring.rename.inplace.VariableInplaceRenameHandler
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
-import org.jetbrains.kotlin.idea.references.JetReference
+import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 
-public class ReplaceItWithExplicitFunctionLiteralParamIntention() : JetSelfTargetingOffsetIndependentIntention<JetNameReferenceExpression> (
+public class ReplaceItWithExplicitFunctionLiteralParamIntention() : JetSelfTargetingOffsetIndependentIntention<KtNameReferenceExpression> (
         javaClass(), "Replace 'it' with explicit parameter"
 ), LowPriorityAction {
-    override fun isApplicableTo(element: JetNameReferenceExpression)
+    override fun isApplicableTo(element: KtNameReferenceExpression)
             = isAutoCreatedItUsage(element)
 
-    override fun applyTo(element: JetNameReferenceExpression, editor: Editor) {
+    override fun applyTo(element: KtNameReferenceExpression, editor: Editor) {
         val target = element.mainReference.resolveToDescriptors(element.analyze()).single()
 
-        val functionLiteral = DescriptorToSourceUtils.descriptorToDeclaration(target.getContainingDeclaration()!!) as JetFunctionLiteral
+        val functionLiteral = DescriptorToSourceUtils.descriptorToDeclaration(target.getContainingDeclaration()!!) as KtFunctionLiteral
 
-        val newExpr = JetPsiFactory(element).createExpression("{ it -> }") as JetFunctionLiteralExpression
+        val newExpr = KtPsiFactory(element).createExpression("{ it -> }") as KtFunctionLiteralExpression
         functionLiteral.addRangeAfter(
                 newExpr.getFunctionLiteral().getValueParameterList(),
                 newExpr.getFunctionLiteral().getArrow()!!,
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceWithOperatorAssignmentIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceWithOperatorAssignmentIntention.kt
index fd8883dc1e6..50e7ff1d142 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceWithOperatorAssignmentIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceWithOperatorAssignmentIntention.kt
@@ -23,26 +23,26 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.matches
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetNameReferenceExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtNameReferenceExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.resolve.BindingContext
 
-public class ReplaceWithOperatorAssignmentInspection : IntentionBasedInspection<JetBinaryExpression>(ReplaceWithOperatorAssignmentIntention())
+public class ReplaceWithOperatorAssignmentInspection : IntentionBasedInspection<KtBinaryExpression>(ReplaceWithOperatorAssignmentIntention())
 
-public class ReplaceWithOperatorAssignmentIntention : JetSelfTargetingOffsetIndependentIntention<JetBinaryExpression>(javaClass(), "Replace with operator-assignment") {
+public class ReplaceWithOperatorAssignmentIntention : JetSelfTargetingOffsetIndependentIntention<KtBinaryExpression>(javaClass(), "Replace with operator-assignment") {
 
-    override fun isApplicableTo(element: JetBinaryExpression): Boolean {
-        if (element.getOperationToken() != JetTokens.EQ) return false
-        val left = element.getLeft() as? JetNameReferenceExpression ?: return false
-        val right = element.getRight() as? JetBinaryExpression ?: return false
+    override fun isApplicableTo(element: KtBinaryExpression): Boolean {
+        if (element.getOperationToken() != KtTokens.EQ) return false
+        val left = element.getLeft() as? KtNameReferenceExpression ?: return false
+        val right = element.getRight() as? KtBinaryExpression ?: return false
         if (right.getLeft() == null || right.getRight() == null) return false
 
         return checkExpressionRepeat(left, right)
     }
 
-    private fun checkExpressionRepeat(variableExpression: JetNameReferenceExpression, expression: JetBinaryExpression): Boolean {
+    private fun checkExpressionRepeat(variableExpression: KtNameReferenceExpression, expression: KtBinaryExpression): Boolean {
         val context = expression.analyze()
         val descriptor = context[BindingContext.REFERENCE_TARGET, expression.getOperationReference()]?.getContainingDeclaration()
         val isPrimitiveOperation = descriptor is ClassDescriptor && KotlinBuiltIns.isPrimitiveType(descriptor.getDefaultType())
@@ -61,7 +61,7 @@ public class ReplaceWithOperatorAssignmentIntention : JetSelfTargetingOffsetInde
                 isPrimitiveOperation && isCommutative(operationToken)
             }
 
-            expressionLeft is JetBinaryExpression -> {
+            expressionLeft is KtBinaryExpression -> {
                 val sameCommutativeOperation = expressionLeft.getOperationToken() == operationToken && isCommutative(operationToken)
                 isPrimitiveOperation && sameCommutativeOperation && checkExpressionRepeat(variableExpression, expressionLeft)
             }
@@ -72,23 +72,23 @@ public class ReplaceWithOperatorAssignmentIntention : JetSelfTargetingOffsetInde
         }
     }
 
-    private fun isCommutative(operationToken: IElementType) = operationToken == JetTokens.PLUS || operationToken == JetTokens.MUL
-    private fun isArithmeticOperation(operationToken: IElementType) = operationToken == JetTokens.PLUS ||
-                                                                       operationToken == JetTokens.MINUS ||
-                                                                       operationToken == JetTokens.MUL ||
-                                                                       operationToken == JetTokens.DIV ||
-                                                                       operationToken == JetTokens.PERC
+    private fun isCommutative(operationToken: IElementType) = operationToken == KtTokens.PLUS || operationToken == KtTokens.MUL
+    private fun isArithmeticOperation(operationToken: IElementType) = operationToken == KtTokens.PLUS ||
+                                                                       operationToken == KtTokens.MINUS ||
+                                                                       operationToken == KtTokens.MUL ||
+                                                                       operationToken == KtTokens.DIV ||
+                                                                       operationToken == KtTokens.PERC
 
-    override fun applyTo(element: JetBinaryExpression, editor: Editor) {
+    override fun applyTo(element: KtBinaryExpression, editor: Editor) {
         val replacement = buildOperatorAssignmentText(
-                element.getLeft() as JetNameReferenceExpression,
-                element.getRight() as JetBinaryExpression,
+                element.getLeft() as KtNameReferenceExpression,
+                element.getRight() as KtBinaryExpression,
                 ""
         )
-        element.replace(JetPsiFactory(element).createExpression(replacement))
+        element.replace(KtPsiFactory(element).createExpression(replacement))
     }
 
-    tailrec private fun buildOperatorAssignmentText(variableExpression: JetNameReferenceExpression, expression: JetBinaryExpression, tail: String): String {
+    tailrec private fun buildOperatorAssignmentText(variableExpression: KtNameReferenceExpression, expression: KtBinaryExpression, tail: String): String {
         val operationText = expression.getOperationReference().getText()
         val variableName = variableExpression.getText()
 
@@ -99,8 +99,8 @@ public class ReplaceWithOperatorAssignmentIntention : JetSelfTargetingOffsetInde
 
             variableExpression.matches(expression.getRight()) -> "$variableName $operationText= ${expression.getLeft()!!.getText()}".appendTail()
 
-            expression.getLeft() is JetBinaryExpression ->
-                buildOperatorAssignmentText(variableExpression, expression.getLeft() as JetBinaryExpression, "$operationText ${expression.getRight()!!.getText()}".appendTail())
+            expression.getLeft() is KtBinaryExpression ->
+                buildOperatorAssignmentText(variableExpression, expression.getLeft() as KtBinaryExpression, "$operationText ${expression.getRight()!!.getText()}".appendTail())
 
             else -> tail
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceWithOrdinaryAssignmentIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceWithOrdinaryAssignmentIntention.kt
index ec4033e7943..6858f50c0a2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceWithOrdinaryAssignmentIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceWithOrdinaryAssignmentIntention.kt
@@ -18,24 +18,24 @@ package org.jetbrains.kotlin.idea.intentions
 
 import com.intellij.codeInsight.intention.LowPriorityAction
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetNameReferenceExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtNameReferenceExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.createExpressionByPattern
 
-public class ReplaceWithOrdinaryAssignmentIntention : JetSelfTargetingIntention<JetBinaryExpression>(javaClass(), "Replace with ordinary assignment"), LowPriorityAction {
-    override fun isApplicableTo(element: JetBinaryExpression, caretOffset: Int): Boolean {
-        if (element.getOperationToken() !in JetTokens.AUGMENTED_ASSIGNMENTS) return false
-        if (element.getLeft() !is JetNameReferenceExpression) return false
+public class ReplaceWithOrdinaryAssignmentIntention : JetSelfTargetingIntention<KtBinaryExpression>(javaClass(), "Replace with ordinary assignment"), LowPriorityAction {
+    override fun isApplicableTo(element: KtBinaryExpression, caretOffset: Int): Boolean {
+        if (element.getOperationToken() !in KtTokens.AUGMENTED_ASSIGNMENTS) return false
+        if (element.getLeft() !is KtNameReferenceExpression) return false
         if (element.getRight() == null) return false
         return element.getOperationReference().getTextRange().containsOffset(caretOffset)
     }
 
-    override fun applyTo(element: JetBinaryExpression, editor: Editor) {
+    override fun applyTo(element: KtBinaryExpression, editor: Editor) {
         val left = element.getLeft()!!
         val right = element.getRight()!!
-        val factory = JetPsiFactory(element)
+        val factory = KtPsiFactory(element)
 
         val assignOpText = element.getOperationReference().getText()
         assert(assignOpText.endsWith("="))
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/SimplifyBooleanWithConstantsIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/SimplifyBooleanWithConstantsIntention.kt
index 1fcb4609d61..19ce3affbe2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/SimplifyBooleanWithConstantsIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/SimplifyBooleanWithConstantsIntention.kt
@@ -23,28 +23,28 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.copied
 import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.CompileTimeConstantUtils
 import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
 
-public class SimplifyBooleanWithConstantsInspection : IntentionBasedInspection<JetBinaryExpression>(SimplifyBooleanWithConstantsIntention())
+public class SimplifyBooleanWithConstantsInspection : IntentionBasedInspection<KtBinaryExpression>(SimplifyBooleanWithConstantsIntention())
 
-public class SimplifyBooleanWithConstantsIntention : JetSelfTargetingOffsetIndependentIntention<JetBinaryExpression>(javaClass(), "Simplify boolean expression") {
+public class SimplifyBooleanWithConstantsIntention : JetSelfTargetingOffsetIndependentIntention<KtBinaryExpression>(javaClass(), "Simplify boolean expression") {
 
-    override fun isApplicableTo(element: JetBinaryExpression): Boolean {
-        val topBinary = PsiTreeUtil.getTopmostParentOfType(element, javaClass<JetBinaryExpression>()) ?: element
+    override fun isApplicableTo(element: KtBinaryExpression): Boolean {
+        val topBinary = PsiTreeUtil.getTopmostParentOfType(element, javaClass<KtBinaryExpression>()) ?: element
         return areThereExpressionsToBeSimplified(topBinary)
     }
 
-    private fun areThereExpressionsToBeSimplified(element: JetExpression?) : Boolean {
+    private fun areThereExpressionsToBeSimplified(element: KtExpression?) : Boolean {
         if (element == null) return false
         when (element) {
-            is JetParenthesizedExpression -> return areThereExpressionsToBeSimplified(element.getExpression())
+            is KtParenthesizedExpression -> return areThereExpressionsToBeSimplified(element.getExpression())
 
-            is JetBinaryExpression -> {
+            is KtBinaryExpression -> {
                 val op = element.getOperationToken()
-                if ((op == JetTokens.ANDAND || op == JetTokens.OROR) &&
+                if ((op == KtTokens.ANDAND || op == KtTokens.OROR) &&
                        (areThereExpressionsToBeSimplified(element.getLeft()) ||
                        areThereExpressionsToBeSimplified(element.getRight()))) return true
             }
@@ -52,14 +52,14 @@ public class SimplifyBooleanWithConstantsIntention : JetSelfTargetingOffsetIndep
         return element.canBeReducedToBooleanConstant(null)
     }
 
-    override fun applyTo(element: JetBinaryExpression, editor: Editor) {
-        val topBinary = PsiTreeUtil.getTopmostParentOfType(element, javaClass<JetBinaryExpression>()) ?: element
+    override fun applyTo(element: KtBinaryExpression, editor: Editor) {
+        val topBinary = PsiTreeUtil.getTopmostParentOfType(element, javaClass<KtBinaryExpression>()) ?: element
         val simplified = toSimplifiedExpression(topBinary)
-        topBinary.replace(JetPsiUtil.safeDeparenthesize(simplified))
+        topBinary.replace(KtPsiUtil.safeDeparenthesize(simplified))
     }
 
-    private fun toSimplifiedExpression(expression: JetExpression): JetExpression {
-        val psiFactory = JetPsiFactory(expression)
+    private fun toSimplifiedExpression(expression: KtExpression): KtExpression {
+        val psiFactory = KtPsiFactory(expression)
 
         when  {
             expression.canBeReducedToTrue() -> {
@@ -70,11 +70,11 @@ public class SimplifyBooleanWithConstantsIntention : JetSelfTargetingOffsetIndep
                 return psiFactory.createExpression("false")
             }
 
-            expression is JetParenthesizedExpression -> {
+            expression is KtParenthesizedExpression -> {
                 val expr = expression.getExpression()
                 if (expr != null) {
                     val simplified = toSimplifiedExpression(expr)
-                    return if (simplified is JetBinaryExpression) {
+                    return if (simplified is KtBinaryExpression) {
                         // wrap in new parentheses to keep the user's original format
                         psiFactory.createExpressionByPattern("($0)", simplified)
                     }
@@ -85,11 +85,11 @@ public class SimplifyBooleanWithConstantsIntention : JetSelfTargetingOffsetIndep
                 }
             }
 
-            expression is JetBinaryExpression -> {
+            expression is KtBinaryExpression -> {
                 val left = expression.getLeft()
                 val right = expression.getRight()
                 val op = expression.getOperationToken()
-                if (left != null && right != null && (op == JetTokens.ANDAND || op == JetTokens.OROR)) {
+                if (left != null && right != null && (op == KtTokens.ANDAND || op == KtTokens.OROR)) {
                     val simpleLeft = simplifyExpression(left)
                     val simpleRight = simplifyExpression(right)
                     return when {
@@ -113,23 +113,23 @@ public class SimplifyBooleanWithConstantsIntention : JetSelfTargetingOffsetIndep
         return expression.copied()
     }
 
-    private fun toSimplifiedBooleanBinaryExpressionWithConstantOperand(constantOperand: Boolean, otherOperand: JetExpression, operation: IElementType): JetExpression {
+    private fun toSimplifiedBooleanBinaryExpressionWithConstantOperand(constantOperand: Boolean, otherOperand: KtExpression, operation: IElementType): KtExpression {
         return when {
-            constantOperand && operation == JetTokens.OROR -> JetPsiFactory(otherOperand).createExpression("true")
-            !constantOperand && operation == JetTokens.ANDAND -> JetPsiFactory(otherOperand).createExpression("false")
+            constantOperand && operation == KtTokens.OROR -> KtPsiFactory(otherOperand).createExpression("true")
+            !constantOperand && operation == KtTokens.ANDAND -> KtPsiFactory(otherOperand).createExpression("false")
             else -> toSimplifiedExpression(otherOperand)
         }
     }
 
-    private fun simplifyExpression(expression: JetExpression) = expression.replaced(toSimplifiedExpression(expression))
+    private fun simplifyExpression(expression: KtExpression) = expression.replaced(toSimplifiedExpression(expression))
 
-    private fun JetExpression.canBeReducedToBooleanConstant(constant: Boolean?): Boolean {
+    private fun KtExpression.canBeReducedToBooleanConstant(constant: Boolean?): Boolean {
         val bindingContext = this.analyze()
         val trace = DelegatingBindingTrace(bindingContext, "trace for constant check")
         return CompileTimeConstantUtils.canBeReducedToBooleanConstant(this, trace, constant)
     }
 
-    private fun JetExpression.canBeReducedToTrue() = canBeReducedToBooleanConstant(true)
+    private fun KtExpression.canBeReducedToTrue() = canBeReducedToBooleanConstant(true)
 
-    private fun JetExpression.canBeReducedToFalse() = canBeReducedToBooleanConstant(false)
+    private fun KtExpression.canBeReducedToFalse() = canBeReducedToBooleanConstant(false)
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/SimplifyNegatedBinaryExpressionIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/SimplifyNegatedBinaryExpressionIntention.kt
index 33580083804..8de65fc3dce 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/SimplifyNegatedBinaryExpressionIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/SimplifyNegatedBinaryExpressionIntention.kt
@@ -20,66 +20,66 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.tree.IElementType
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
-import org.jetbrains.kotlin.lexer.JetSingleValueToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtSingleValueToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 
-public class SimplifyNegatedBinaryExpressionInspection : IntentionBasedInspection<JetPrefixExpression>(SimplifyNegatedBinaryExpressionIntention())
+public class SimplifyNegatedBinaryExpressionInspection : IntentionBasedInspection<KtPrefixExpression>(SimplifyNegatedBinaryExpressionIntention())
 
-public class SimplifyNegatedBinaryExpressionIntention : JetSelfTargetingRangeIntention<JetPrefixExpression>(javaClass(), "Simplify negated binary expression") {
+public class SimplifyNegatedBinaryExpressionIntention : JetSelfTargetingRangeIntention<KtPrefixExpression>(javaClass(), "Simplify negated binary expression") {
 
-    private fun IElementType.negate(): JetSingleValueToken? = when (this) {
-        JetTokens.IN_KEYWORD -> JetTokens.NOT_IN
-        JetTokens.NOT_IN -> JetTokens.IN_KEYWORD
+    private fun IElementType.negate(): KtSingleValueToken? = when (this) {
+        KtTokens.IN_KEYWORD -> KtTokens.NOT_IN
+        KtTokens.NOT_IN -> KtTokens.IN_KEYWORD
 
-        JetTokens.IS_KEYWORD -> JetTokens.NOT_IS
-        JetTokens.NOT_IS -> JetTokens.IS_KEYWORD
+        KtTokens.IS_KEYWORD -> KtTokens.NOT_IS
+        KtTokens.NOT_IS -> KtTokens.IS_KEYWORD
 
-        JetTokens.EQEQ -> JetTokens.EXCLEQ
-        JetTokens.EXCLEQ -> JetTokens.EQEQ
+        KtTokens.EQEQ -> KtTokens.EXCLEQ
+        KtTokens.EXCLEQ -> KtTokens.EQEQ
 
-        JetTokens.LT -> JetTokens.GTEQ
-        JetTokens.GTEQ -> JetTokens.LT
+        KtTokens.LT -> KtTokens.GTEQ
+        KtTokens.GTEQ -> KtTokens.LT
 
-        JetTokens.GT -> JetTokens.LTEQ
-        JetTokens.LTEQ -> JetTokens.GT
+        KtTokens.GT -> KtTokens.LTEQ
+        KtTokens.LTEQ -> KtTokens.GT
 
         else -> null
     }
 
-    override fun applicabilityRange(element: JetPrefixExpression): TextRange? {
+    override fun applicabilityRange(element: KtPrefixExpression): TextRange? {
         return if (isApplicableTo(element)) element.getOperationReference().getTextRange() else null
     }
 
-    public fun isApplicableTo(element: JetPrefixExpression): Boolean {
-        if (element.getOperationToken() != JetTokens.EXCL) return false
+    public fun isApplicableTo(element: KtPrefixExpression): Boolean {
+        if (element.getOperationToken() != KtTokens.EXCL) return false
 
-        val expression = JetPsiUtil.deparenthesize(element.getBaseExpression()) as? JetOperationExpression ?: return false
+        val expression = KtPsiUtil.deparenthesize(element.getBaseExpression()) as? KtOperationExpression ?: return false
         when (expression) {
-            is JetIsExpression -> { if (expression.getTypeReference() == null) return false }
-            is JetBinaryExpression -> { if (expression.getLeft() == null || expression.getRight() == null) return false }
+            is KtIsExpression -> { if (expression.getTypeReference() == null) return false }
+            is KtBinaryExpression -> { if (expression.getLeft() == null || expression.getRight() == null) return false }
             else -> return false
         }
 
-        val operation = expression.getOperationReference().getReferencedNameElementType() as? JetSingleValueToken ?: return false
+        val operation = expression.getOperationReference().getReferencedNameElementType() as? KtSingleValueToken ?: return false
         val negatedOperation = operation.negate() ?: return false
 
         setText("Simplify negated '${operation.getValue()}' expression to '${negatedOperation.getValue()}'")
         return true
     }
 
-    override fun applyTo(element: JetPrefixExpression, editor: Editor) {
+    override fun applyTo(element: KtPrefixExpression, editor: Editor) {
         applyTo(element)
     }
 
-    public fun applyTo(element: JetPrefixExpression) {
-        val expression = JetPsiUtil.deparenthesize(element.getBaseExpression())!!
-        val operation = (expression as JetOperationExpression).getOperationReference().getReferencedNameElementType().negate()!!.getValue()
+    public fun applyTo(element: KtPrefixExpression) {
+        val expression = KtPsiUtil.deparenthesize(element.getBaseExpression())!!
+        val operation = (expression as KtOperationExpression).getOperationReference().getReferencedNameElementType().negate()!!.getValue()
 
-        val psiFactory = JetPsiFactory(expression)
+        val psiFactory = KtPsiFactory(expression)
         val newExpression = when (expression) {
-            is JetIsExpression -> psiFactory.createExpressionByPattern("$0 $1 $2", expression.getLeftHandSide(), operation, expression.getTypeReference()!!)
-            is JetBinaryExpression -> psiFactory.createExpressionByPattern("$0 $1 $2", expression.getLeft()!!, operation, expression.getRight()!!)
+            is KtIsExpression -> psiFactory.createExpressionByPattern("$0 $1 $2", expression.getLeftHandSide(), operation, expression.getTypeReference()!!)
+            is KtBinaryExpression -> psiFactory.createExpressionByPattern("$0 $1 $2", expression.getLeft()!!, operation, expression.getRight()!!)
             else -> throw IllegalArgumentException()
         }
         element.replace(newExpression)
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/SpecifyExplicitLambdaSignatureIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/SpecifyExplicitLambdaSignatureIntention.kt
index 063c3b4cb5c..f40942be1cd 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/SpecifyExplicitLambdaSignatureIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/SpecifyExplicitLambdaSignatureIntention.kt
@@ -22,14 +22,14 @@ import com.intellij.psi.PsiWhiteSpace
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences
-import org.jetbrains.kotlin.psi.JetFunctionLiteralExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtFunctionLiteralExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.resolve.BindingContext
 
-public class SpecifyExplicitLambdaSignatureIntention : JetSelfTargetingIntention<JetFunctionLiteralExpression>(javaClass(), "Specify explicit lambda signature"), LowPriorityAction {
+public class SpecifyExplicitLambdaSignatureIntention : JetSelfTargetingIntention<KtFunctionLiteralExpression>(javaClass(), "Specify explicit lambda signature"), LowPriorityAction {
 
-    override fun isApplicableTo(element: JetFunctionLiteralExpression, caretOffset: Int): Boolean {
+    override fun isApplicableTo(element: KtFunctionLiteralExpression, caretOffset: Int): Boolean {
         val arrow = element.getFunctionLiteral().getArrow()
         if (arrow != null) {
             if (caretOffset > arrow.endOffset) return false
@@ -43,8 +43,8 @@ public class SpecifyExplicitLambdaSignatureIntention : JetSelfTargetingIntention
         return functionDescriptor.getValueParameters().none { it.getType().isError() }
     }
 
-    override fun applyTo(element: JetFunctionLiteralExpression, editor: Editor) {
-        val psiFactory = JetPsiFactory(element)
+    override fun applyTo(element: KtFunctionLiteralExpression, editor: Editor) {
+        val psiFactory = KtPsiFactory(element)
         val functionLiteral = element.getFunctionLiteral()
         val functionDescriptor = element.analyze()[BindingContext.FUNCTION, functionLiteral]!!
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/SpecifyTypeExplicitlyIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/SpecifyTypeExplicitlyIntention.kt
index 26c50ef7234..03cf2652fac 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/SpecifyTypeExplicitlyIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/SpecifyTypeExplicitlyIntention.kt
@@ -30,56 +30,56 @@ import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 import java.util.*
 
-public class SpecifyTypeExplicitlyIntention : JetSelfTargetingIntention<JetCallableDeclaration>(javaClass(), "Specify type explicitly"), LowPriorityAction {
-    override fun isApplicableTo(element: JetCallableDeclaration, caretOffset: Int): Boolean {
-        if (element.getContainingFile() is JetCodeFragment) return false
-        if (element is JetFunctionLiteral) return false // TODO: should JetFunctionLiteral be JetCallableDeclaration at all?
-        if (element is JetConstructor<*>) return false
+public class SpecifyTypeExplicitlyIntention : JetSelfTargetingIntention<KtCallableDeclaration>(javaClass(), "Specify type explicitly"), LowPriorityAction {
+    override fun isApplicableTo(element: KtCallableDeclaration, caretOffset: Int): Boolean {
+        if (element.getContainingFile() is KtCodeFragment) return false
+        if (element is KtFunctionLiteral) return false // TODO: should JetFunctionLiteral be JetCallableDeclaration at all?
+        if (element is KtConstructor<*>) return false
         if (element.getTypeReference() != null) return false
 
         if (getTypeForDeclaration(element).isError()) return false
 
-        val initializer = (element as? JetWithExpressionInitializer)?.getInitializer()
+        val initializer = (element as? KtWithExpressionInitializer)?.getInitializer()
         if (initializer != null && initializer.getTextRange().containsOffset(caretOffset)) return false
 
-        if (element is JetNamedFunction && element.hasBlockBody()) return false
+        if (element is KtNamedFunction && element.hasBlockBody()) return false
 
-        setText(if (element is JetFunction) "Specify return type explicitly" else "Specify type explicitly")
+        setText(if (element is KtFunction) "Specify return type explicitly" else "Specify type explicitly")
 
         return true
     }
 
-    override fun applyTo(element: JetCallableDeclaration, editor: Editor) {
+    override fun applyTo(element: KtCallableDeclaration, editor: Editor) {
         val type = getTypeForDeclaration(element)
         addTypeAnnotation(editor, element, type)
     }
 
     companion object {
-        public fun getTypeForDeclaration(declaration: JetCallableDeclaration): JetType {
+        public fun getTypeForDeclaration(declaration: KtCallableDeclaration): KtType {
             val descriptor = declaration.analyze()[BindingContext.DECLARATION_TO_DESCRIPTOR, declaration]
             val type = (descriptor as? CallableDescriptor)?.getReturnType()
             return type ?: ErrorUtils.createErrorType("null type")
         }
 
-        public fun createTypeExpressionForTemplate(exprType: JetType): Expression {
+        public fun createTypeExpressionForTemplate(exprType: KtType): Expression {
             val descriptor = exprType.getConstructor().getDeclarationDescriptor()
             val isAnonymous = descriptor != null && DescriptorUtils.isAnonymousObject(descriptor)
 
             val allSupertypes = TypeUtils.getAllSupertypes(exprType)
-            val types = if (isAnonymous) ArrayList<JetType>() else arrayListOf(exprType)
+            val types = if (isAnonymous) ArrayList<KtType>() else arrayListOf(exprType)
             types.addAll(allSupertypes)
 
-            return object : ChooseValueExpression<JetType>(types, types.first()) {
-                override fun getLookupString(element: JetType) = IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType(element)
-                override fun getResult(element: JetType) = IdeDescriptorRenderers.SOURCE_CODE.renderType(element)
+            return object : ChooseValueExpression<KtType>(types, types.first()) {
+                override fun getLookupString(element: KtType) = IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType(element)
+                override fun getResult(element: KtType) = IdeDescriptorRenderers.SOURCE_CODE.renderType(element)
             }
         }
 
-        public fun addTypeAnnotation(editor: Editor?, declaration: JetCallableDeclaration, exprType: JetType) {
+        public fun addTypeAnnotation(editor: Editor?, declaration: KtCallableDeclaration, exprType: KtType) {
             if (editor != null) {
                 addTypeAnnotationWithTemplate(editor, declaration, exprType)
             }
@@ -88,7 +88,7 @@ public class SpecifyTypeExplicitlyIntention : JetSelfTargetingIntention<JetCalla
             }
         }
 
-        public fun createTypeReferencePostprocessor(declaration: JetCallableDeclaration): TemplateEditingAdapter {
+        public fun createTypeReferencePostprocessor(declaration: KtCallableDeclaration): TemplateEditingAdapter {
             return object : TemplateEditingAdapter() {
                 override fun templateFinished(template: Template?, brokenOff: Boolean) {
                     val typeRef = declaration.getTypeReference()
@@ -99,7 +99,7 @@ public class SpecifyTypeExplicitlyIntention : JetSelfTargetingIntention<JetCalla
             }
         }
 
-        private fun addTypeAnnotationWithTemplate(editor: Editor, declaration: JetCallableDeclaration, exprType: JetType) {
+        private fun addTypeAnnotationWithTemplate(editor: Editor, declaration: KtCallableDeclaration, exprType: KtType) {
             assert(!exprType.isError()) { "Unexpected error type, should have been checked before: " + declaration.getElementTextWithContext() + ", type = " + exprType }
 
             val project = declaration.getProject()
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/SplitIfIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/SplitIfIntention.kt
index 037ca5254c0..c42c9d18d14 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/SplitIfIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/SplitIfIntention.kt
@@ -22,49 +22,49 @@ import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.idea.conversion.copy.range
 import org.jetbrains.kotlin.idea.conversion.copy.start
 import org.jetbrains.kotlin.idea.core.CommentSaver
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.PsiChildRange
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.lastBlockStatementOrThis
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
-public class SplitIfIntention : JetSelfTargetingIntention<JetExpression>(javaClass(), "Split if into 2 if's") {
-    override fun isApplicableTo(element: JetExpression, caretOffset: Int): Boolean {
+public class SplitIfIntention : JetSelfTargetingIntention<KtExpression>(javaClass(), "Split if into 2 if's") {
+    override fun isApplicableTo(element: KtExpression, caretOffset: Int): Boolean {
         return when (element) {
-            is JetOperationReferenceExpression -> isOperatorValid(element)
-            is JetIfExpression -> getFirstValidOperator(element) != null && element.getIfKeyword().getTextRange().containsOffset(caretOffset)
+            is KtOperationReferenceExpression -> isOperatorValid(element)
+            is KtIfExpression -> getFirstValidOperator(element) != null && element.getIfKeyword().getTextRange().containsOffset(caretOffset)
             else -> false
         }
     }
 
-    override fun applyTo(element: JetExpression, editor: Editor) {
+    override fun applyTo(element: KtExpression, editor: Editor) {
         val operator = when (element) {
-            is JetIfExpression -> getFirstValidOperator(element)!!
-            else -> element as JetOperationReferenceExpression
+            is KtIfExpression -> getFirstValidOperator(element)!!
+            else -> element as KtOperationReferenceExpression
         }
 
-        val ifExpression = operator.getNonStrictParentOfType<JetIfExpression>()
+        val ifExpression = operator.getNonStrictParentOfType<KtIfExpression>()
 
         val commentSaver = CommentSaver(ifExpression!!)
 
-        val expression = operator.getParent() as JetBinaryExpression
-        val rightExpression = JetPsiUtil.safeDeparenthesize(getRight(expression, ifExpression.getCondition()!!, commentSaver))
-        val leftExpression = JetPsiUtil.safeDeparenthesize(expression.getLeft()!!)
+        val expression = operator.getParent() as KtBinaryExpression
+        val rightExpression = KtPsiUtil.safeDeparenthesize(getRight(expression, ifExpression.getCondition()!!, commentSaver))
+        val leftExpression = KtPsiUtil.safeDeparenthesize(expression.getLeft()!!)
         val thenBranch = ifExpression.getThen()!!
         val elseBranch = ifExpression.getElse()
 
-        val psiFactory = JetPsiFactory(element)
+        val psiFactory = KtPsiFactory(element)
 
         val innerIf = psiFactory.createIf(rightExpression, thenBranch, elseBranch)
 
         val newIf = when (operator.getReferencedNameElementType()) {
-            JetTokens.ANDAND -> psiFactory.createIf(leftExpression, psiFactory.createSingleStatementBlock(innerIf), elseBranch)
+            KtTokens.ANDAND -> psiFactory.createIf(leftExpression, psiFactory.createSingleStatementBlock(innerIf), elseBranch)
 
-            JetTokens.OROR -> {
+            KtTokens.OROR -> {
                 val container = ifExpression.getParent()
 
-                if (container is JetBlockExpression && elseBranch == null && thenBranch.lastBlockStatementOrThis().isExitStatement()) { // special case
+                if (container is KtBlockExpression && elseBranch == null && thenBranch.lastBlockStatementOrThis().isExitStatement()) { // special case
                     val secondIf = container.addAfter(innerIf, ifExpression)
                     container.addAfter(psiFactory.createNewLine(), ifExpression)
                     val firstIf = ifExpression.replace(psiFactory.createIf(leftExpression, thenBranch))
@@ -83,38 +83,38 @@ public class SplitIfIntention : JetSelfTargetingIntention<JetExpression>(javaCla
         commentSaver.restore(result)
     }
 
-    private fun getRight(element: JetBinaryExpression, condition: JetExpression, commentSaver: CommentSaver): JetExpression {
+    private fun getRight(element: KtBinaryExpression, condition: KtExpression, commentSaver: CommentSaver): KtExpression {
         //gets the textOffset of the right side of the JetBinaryExpression in context to condition
         val conditionRange = condition.range
         val startOffset = element.getRight()!!.startOffset - conditionRange.start
         val endOffset = conditionRange.length
         val rightString = condition.getText().substring(startOffset, endOffset)
 
-        val expression = JetPsiFactory(element).createExpression(rightString)
+        val expression = KtPsiFactory(element).createExpression(rightString)
         commentSaver.elementCreatedByText(expression, condition, TextRange(startOffset, endOffset))
         return expression
     }
 
-    private fun getFirstValidOperator(element: JetIfExpression): JetOperationReferenceExpression? {
+    private fun getFirstValidOperator(element: KtIfExpression): KtOperationReferenceExpression? {
         val condition = element.getCondition() ?: return null
-        return PsiTreeUtil.findChildrenOfType(condition, javaClass<JetOperationReferenceExpression>())
+        return PsiTreeUtil.findChildrenOfType(condition, javaClass<KtOperationReferenceExpression>())
                 .firstOrNull { isOperatorValid(it) }
     }
 
-    private fun isOperatorValid(element: JetOperationReferenceExpression): Boolean {
+    private fun isOperatorValid(element: KtOperationReferenceExpression): Boolean {
         val operator = element.getReferencedNameElementType()
-        if (operator != JetTokens.ANDAND && operator != JetTokens.OROR) return false
+        if (operator != KtTokens.ANDAND && operator != KtTokens.OROR) return false
 
-        var expression = element.getParent() as? JetBinaryExpression ?: return false
+        var expression = element.getParent() as? KtBinaryExpression ?: return false
 
         if (expression.getRight() == null || expression.getLeft() == null) return false
 
         while (true) {
-            expression = expression.getParent() as? JetBinaryExpression ?: break
+            expression = expression.getParent() as? KtBinaryExpression ?: break
             if (expression.getOperationToken() != operator) return false
         }
 
-        val ifExpression = expression.getParent()?.getParent() as? JetIfExpression ?: return false
+        val ifExpression = expression.getParent()?.getParent() as? KtIfExpression ?: return false
 
         if (ifExpression.getCondition() == null) return false
         if (!PsiTreeUtil.isAncestor(ifExpression.getCondition(), element, false)) return false
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/SwapBinaryExpressionIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/SwapBinaryExpressionIntention.kt
index 954d857647c..a34d72e9e51 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/SwapBinaryExpressionIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/SwapBinaryExpressionIntention.kt
@@ -19,15 +19,15 @@ package org.jetbrains.kotlin.idea.intentions
 import com.intellij.codeInsight.intention.LowPriorityAction
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.kotlin.idea.util.JetPsiPrecedences
-import org.jetbrains.kotlin.lexer.JetTokens.*
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.lexer.KtTokens.*
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.createExpressionByPattern
 import org.jetbrains.kotlin.idea.core.copied
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 
-public class SwapBinaryExpressionIntention : JetSelfTargetingIntention<JetBinaryExpression>(javaClass(), "Flip binary expression"), LowPriorityAction {
+public class SwapBinaryExpressionIntention : JetSelfTargetingIntention<KtBinaryExpression>(javaClass(), "Flip binary expression"), LowPriorityAction {
     companion object {
         private val SUPPORTED_OPERATIONS = setOf(PLUS, MUL, OROR, ANDAND, EQEQ, EXCLEQ, EQEQEQ, EXCLEQEQEQ, GT, LT, GTEQ, LTEQ)
 
@@ -35,7 +35,7 @@ public class SwapBinaryExpressionIntention : JetSelfTargetingIntention<JetBinary
                                         setOf("xor", "or", "and", "equals", "identityEquals")
     }
 
-    override fun isApplicableTo(element: JetBinaryExpression, caretOffset: Int): Boolean {
+    override fun isApplicableTo(element: KtBinaryExpression, caretOffset: Int): Boolean {
         val opRef = element.getOperationReference()
         if (!opRef.getTextRange().containsOffset(caretOffset)) return false
 
@@ -53,7 +53,7 @@ public class SwapBinaryExpressionIntention : JetSelfTargetingIntention<JetBinary
         return false
     }
 
-    override fun applyTo(element: JetBinaryExpression, editor: Editor) {
+    override fun applyTo(element: KtBinaryExpression, editor: Editor) {
         // Have to use text here to preserve names like "plus"
         val operator = element.getOperationReference().getText()!!
         val convertedOperator = when (operator) {
@@ -69,19 +69,19 @@ public class SwapBinaryExpressionIntention : JetSelfTargetingIntention<JetBinary
         val leftCopy = left.copied()
         left.replace(rightCopy)
         right.replace(leftCopy)
-        element.replace(JetPsiFactory(element).createExpressionByPattern("$0 $convertedOperator $1" , element.getLeft()!!, element.getRight()!!))
+        element.replace(KtPsiFactory(element).createExpressionByPattern("$0 $convertedOperator $1" , element.getLeft()!!, element.getRight()!!))
     }
 
-    private fun leftSubject(element: JetBinaryExpression): JetExpression? {
-        return firstDescendantOfTighterPrecedence(element.getLeft(), JetPsiPrecedences.getPrecedence(element), JetBinaryExpression::getRight)
+    private fun leftSubject(element: KtBinaryExpression): KtExpression? {
+        return firstDescendantOfTighterPrecedence(element.getLeft(), JetPsiPrecedences.getPrecedence(element), KtBinaryExpression::getRight)
     }
 
-    private fun rightSubject(element: JetBinaryExpression): JetExpression? {
-        return firstDescendantOfTighterPrecedence(element.getRight(), JetPsiPrecedences.getPrecedence(element), JetBinaryExpression::getLeft)
+    private fun rightSubject(element: KtBinaryExpression): KtExpression? {
+        return firstDescendantOfTighterPrecedence(element.getRight(), JetPsiPrecedences.getPrecedence(element), KtBinaryExpression::getLeft)
     }
 
-    private fun firstDescendantOfTighterPrecedence(expression: JetExpression?, precedence: Int, getChild: JetBinaryExpression.() -> JetExpression?): JetExpression? {
-        if (expression is JetBinaryExpression) {
+    private fun firstDescendantOfTighterPrecedence(expression: KtExpression?, precedence: Int, getChild: KtBinaryExpression.() -> KtExpression?): KtExpression? {
+        if (expression is KtBinaryExpression) {
             val expressionPrecedence = JetPsiPrecedences.getPrecedence(expression)
             if (!JetPsiPrecedences.isTighter(expressionPrecedence, precedence)) {
                 return firstDescendantOfTighterPrecedence(expression.getChild(), precedence, getChild)
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ToInfixCallIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ToInfixCallIntention.kt
index c39ff1facd4..2c6d84ab2c4 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ToInfixCallIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ToInfixCallIntention.kt
@@ -23,12 +23,12 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 
-public class ToInfixCallIntention : JetSelfTargetingIntention<JetCallExpression>(javaClass(), "Replace with infix function call") {
-    override fun isApplicableTo(element: JetCallExpression, caretOffset: Int): Boolean {
-        val calleeExpr = element.getCalleeExpression() as? JetNameReferenceExpression ?: return false
+public class ToInfixCallIntention : JetSelfTargetingIntention<KtCallExpression>(javaClass(), "Replace with infix function call") {
+    override fun isApplicableTo(element: KtCallExpression, caretOffset: Int): Boolean {
+        val calleeExpr = element.getCalleeExpression() as? KtNameReferenceExpression ?: return false
         if (!calleeExpr.getTextRange().containsOffset(caretOffset)) return false
 
-        val dotQualified = element.getParent() as? JetDotQualifiedExpression ?: return false
+        val dotQualified = element.getParent() as? KtDotQualifiedExpression ?: return false
 
         if (element.getTypeArgumentList() != null) return false
 
@@ -47,13 +47,13 @@ public class ToInfixCallIntention : JetSelfTargetingIntention<JetCallExpression>
         return true
     }
 
-    override fun applyTo(element: JetCallExpression, editor: Editor) {
-        val dotQualified = element.getParent() as JetDotQualifiedExpression
+    override fun applyTo(element: KtCallExpression, editor: Editor) {
+        val dotQualified = element.getParent() as KtDotQualifiedExpression
         val receiver = dotQualified.getReceiverExpression()
         val argument = element.getValueArguments().single().getArgumentExpression()!!
         val name = element.getCalleeExpression()!!.getText()
 
-        val newCall = JetPsiFactory(element).createExpressionByPattern("$0 $name $1", receiver, argument)
+        val newCall = KtPsiFactory(element).createExpressionByPattern("$0 $name $1", receiver, argument)
         dotQualified.replace(newCall)
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/UsePropertyAccessSyntaxIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/UsePropertyAccessSyntaxIntention.kt
index 840c31fdbc4..572aa2460a6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/UsePropertyAccessSyntaxIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/UsePropertyAccessSyntaxIntention.kt
@@ -48,25 +48,25 @@ import org.jetbrains.kotlin.resolve.calls.model.isReallySuccess
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.calls.util.DelegatingCall
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-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.resolve.scopes.utils.asJetScope
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeUtils
 
-class UsePropertyAccessSyntaxInspection : IntentionBasedInspection<JetCallExpression>(UsePropertyAccessSyntaxIntention()), CleanupLocalInspectionTool
+class UsePropertyAccessSyntaxInspection : IntentionBasedInspection<KtCallExpression>(UsePropertyAccessSyntaxIntention()), CleanupLocalInspectionTool
 
-class UsePropertyAccessSyntaxIntention : JetSelfTargetingOffsetIndependentIntention<JetCallExpression>(javaClass(), "Use property access syntax") {
-    override fun isApplicableTo(element: JetCallExpression): Boolean {
+class UsePropertyAccessSyntaxIntention : JetSelfTargetingOffsetIndependentIntention<KtCallExpression>(javaClass(), "Use property access syntax") {
+    override fun isApplicableTo(element: KtCallExpression): Boolean {
         return detectPropertyNameToUse(element) != null
     }
 
-    override fun applyTo(element: JetCallExpression, editor: Editor) {
+    override fun applyTo(element: KtCallExpression, editor: Editor) {
         applyTo(element, detectPropertyNameToUse(element)!!)
     }
 
-    public fun applyTo(element: JetCallExpression, propertyName: Name): JetExpression {
+    public fun applyTo(element: KtCallExpression, propertyName: Name): KtExpression {
         val arguments = element.getValueArguments()
         return when (arguments.size()) {
             0 -> replaceWithPropertyGet(element, propertyName)
@@ -75,10 +75,10 @@ class UsePropertyAccessSyntaxIntention : JetSelfTargetingOffsetIndependentIntent
         }
     }
 
-    public fun detectPropertyNameToUse(callExpression: JetCallExpression): Name? {
-        if (callExpression.getQualifiedExpressionForSelector()?.getReceiverExpression() is JetSuperExpression) return null // cannot call extensions on "super"
+    public fun detectPropertyNameToUse(callExpression: KtCallExpression): Name? {
+        if (callExpression.getQualifiedExpressionForSelector()?.getReceiverExpression() is KtSuperExpression) return null // cannot call extensions on "super"
 
-        val callee = callExpression.getCalleeExpression() as? JetNameReferenceExpression ?: return null
+        val callee = callExpression.getCalleeExpression() as? KtNameReferenceExpression ?: return null
 
         val resolutionFacade = callExpression.getResolutionFacade()
         val bindingContext = resolutionFacade.analyze(callExpression, BodyResolveMode.PARTIAL)
@@ -98,7 +98,7 @@ class UsePropertyAccessSyntaxIntention : JetSelfTargetingOffsetIndependentIntent
         val isSetUsage = callExpression.valueArguments.size() == 1
         if (isSetUsage && property.type != function.valueParameters.single().type) {
             val qualifiedExpressionCopy = qualifiedExpression.copied()
-            val callExpressionCopy = ((qualifiedExpressionCopy as? JetQualifiedExpression)?.selectorExpression ?: qualifiedExpressionCopy) as JetCallExpression
+            val callExpressionCopy = ((qualifiedExpressionCopy as? KtQualifiedExpression)?.selectorExpression ?: qualifiedExpressionCopy) as KtCallExpression
             val newExpression = applyTo(callExpressionCopy, property.name)
             val bindingTrace = DelegatingBindingTrace(bindingContext, "Temporary trace")
             val newBindingContext = newExpression.analyzeInContext(
@@ -121,15 +121,15 @@ class UsePropertyAccessSyntaxIntention : JetSelfTargetingOffsetIndependentIntent
             bindingContext: BindingContext,
             resolutionScope: LexicalScope,
             dataFlowInfo: DataFlowInfo,
-            expectedType: JetType,
+            expectedType: KtType,
             facade: ResolutionFacade
     ): Boolean {
         val project = resolvedCall.call.callElement.project
         val newCall = object : DelegatingCall(resolvedCall.call) {
-            private val newCallee = JetPsiFactory(project).createExpressionByPattern("$0", property.name)
+            private val newCallee = KtPsiFactory(project).createExpressionByPattern("$0", property.name)
 
             override fun getCalleeExpression() = newCallee
-            override fun getValueArgumentList(): JetValueArgumentList? = null
+            override fun getValueArgumentList(): KtValueArgumentList? = null
             override fun getValueArguments(): List<ValueArgument> = emptyList()
             override fun getFunctionLiteralArguments(): List<FunctionLiteralArgument> = emptyList()
         }
@@ -143,7 +143,7 @@ class UsePropertyAccessSyntaxIntention : JetSelfTargetingOffsetIndependentIntent
         return result.isSuccess && result.resultingDescriptor.original == property
     }
 
-    private fun findSyntheticProperty(function: FunctionDescriptor, resolutionScope: JetScope): SyntheticJavaPropertyDescriptor? {
+    private fun findSyntheticProperty(function: FunctionDescriptor, resolutionScope: KtScope): SyntheticJavaPropertyDescriptor? {
         SyntheticJavaPropertyDescriptor.findByGetterOrSetter(function, resolutionScope)?.let { return it }
 
         for (overridden in function.getOverriddenDescriptors()) {
@@ -153,21 +153,21 @@ class UsePropertyAccessSyntaxIntention : JetSelfTargetingOffsetIndependentIntent
         return null
     }
 
-    private fun replaceWithPropertyGet(callExpression: JetCallExpression, propertyName: Name): JetExpression {
-        val newExpression = JetPsiFactory(callExpression).createExpression(propertyName.render())
+    private fun replaceWithPropertyGet(callExpression: KtCallExpression, propertyName: Name): KtExpression {
+        val newExpression = KtPsiFactory(callExpression).createExpression(propertyName.render())
         return callExpression.replaced(newExpression)
     }
 
     //TODO: what if it was used as expression (of type Unit)?
-    private fun replaceWithPropertySet(callExpression: JetCallExpression, propertyName: Name, argument: JetValueArgument): JetExpression {
+    private fun replaceWithPropertySet(callExpression: KtCallExpression, propertyName: Name, argument: KtValueArgument): KtExpression {
         val qualifiedExpression = callExpression.getQualifiedExpressionForSelector()
         if (qualifiedExpression != null) {
             val pattern = when (qualifiedExpression) {
-                is JetDotQualifiedExpression -> "$0.$1=$2"
-                is JetSafeQualifiedExpression -> "$0?.$1=$2"
+                is KtDotQualifiedExpression -> "$0.$1=$2"
+                is KtSafeQualifiedExpression -> "$0?.$1=$2"
                 else -> error(qualifiedExpression) //TODO: make it sealed?
             }
-            val newExpression = JetPsiFactory(callExpression).createExpressionByPattern(
+            val newExpression = KtPsiFactory(callExpression).createExpressionByPattern(
                     pattern,
                     qualifiedExpression.getReceiverExpression(),
                     propertyName,
@@ -176,7 +176,7 @@ class UsePropertyAccessSyntaxIntention : JetSelfTargetingOffsetIndependentIntent
             return qualifiedExpression.replaced(newExpression)
         }
         else {
-            val newExpression = JetPsiFactory(callExpression).createExpressionByPattern("$0=$1", propertyName, argument.getArgumentExpression()!!)
+            val newExpression = KtPsiFactory(callExpression).createExpressionByPattern("$0=$1", propertyName, argument.getArgumentExpression()!!)
             return callExpression.replaced(newExpression)
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/Utils.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/Utils.kt
index 2250c66de45..823b75c2d64 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/Utils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/Utils.kt
@@ -17,58 +17,58 @@
 package org.jetbrains.kotlin.idea.intentions
 
 import com.intellij.psi.tree.IElementType
-import org.jetbrains.kotlin.JetNodeTypes
+import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.typeRefHelpers.setReceiverTypeReference
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
-fun JetCallableDeclaration.setType(type: JetType, shortenReferences: Boolean = true) {
+fun KtCallableDeclaration.setType(type: KtType, shortenReferences: Boolean = true) {
     if (type.isError()) return
     setType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type), shortenReferences)
 }
 
-fun JetCallableDeclaration.setType(typeString: String, shortenReferences: Boolean = true) {
-    val typeReference = JetPsiFactory(project).createType(typeString)
+fun KtCallableDeclaration.setType(typeString: String, shortenReferences: Boolean = true) {
+    val typeReference = KtPsiFactory(project).createType(typeString)
     setTypeReference(typeReference)
     if (shortenReferences) {
         ShortenReferences.DEFAULT.process(getTypeReference()!!)
     }
 }
 
-fun JetCallableDeclaration.setReceiverType(type: JetType) {
+fun KtCallableDeclaration.setReceiverType(type: KtType) {
     if (type.isError()) return
-    val typeReference = JetPsiFactory(getProject()).createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type))
+    val typeReference = KtPsiFactory(getProject()).createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type))
     setReceiverTypeReference(typeReference)
     ShortenReferences.DEFAULT.process(getReceiverTypeReference()!!)
 }
 
-fun JetContainerNode.description(): String? {
+fun KtContainerNode.description(): String? {
     when (getNode().getElementType()) {
-        JetNodeTypes.THEN -> return "if"
-        JetNodeTypes.ELSE -> return "else"
-        JetNodeTypes.BODY -> {
+        KtNodeTypes.THEN -> return "if"
+        KtNodeTypes.ELSE -> return "else"
+        KtNodeTypes.BODY -> {
             when (getParent()) {
-                is JetWhileExpression -> return "while"
-                is JetDoWhileExpression -> return "do...while"
-                is JetForExpression -> return "for"
+                is KtWhileExpression -> return "while"
+                is KtDoWhileExpression -> return "do...while"
+                is KtForExpression -> return "for"
             }
         }
     }
     return null
 }
 
-fun isAutoCreatedItUsage(expression: JetNameReferenceExpression): Boolean {
+fun isAutoCreatedItUsage(expression: KtNameReferenceExpression): Boolean {
     if (expression.getReferencedName() != "it") return false
     val context = expression.analyze(BodyResolveMode.PARTIAL)
     val target = expression.mainReference.resolveToDescriptors(context).singleOrNull() as? ValueParameterDescriptor? ?: return false
@@ -76,17 +76,17 @@ fun isAutoCreatedItUsage(expression: JetNameReferenceExpression): Boolean {
 }
 
 // returns assignment which replaces initializer
-fun splitPropertyDeclaration(property: JetProperty): JetBinaryExpression {
+fun splitPropertyDeclaration(property: KtProperty): KtBinaryExpression {
     val parent = property.getParent()!!
 
     val initializer = property.getInitializer()!!
 
     val explicitTypeToSet = if (property.getTypeReference() != null) null else initializer.analyze().getType(initializer)
 
-    val psiFactory = JetPsiFactory(property)
+    val psiFactory = KtPsiFactory(property)
     var assignment = psiFactory.createExpressionByPattern("$0 = $1", property.getNameAsName()!!, initializer)
 
-    assignment = parent.addAfter(assignment, property) as JetBinaryExpression
+    assignment = parent.addAfter(assignment, property) as KtBinaryExpression
     parent.addAfter(psiFactory.createNewLine(), property)
 
     property.setInitializer(null)
@@ -98,50 +98,50 @@ fun splitPropertyDeclaration(property: JetProperty): JetBinaryExpression {
     return assignment
 }
 
-val JetQualifiedExpression.callExpression: JetCallExpression?
-    get() = getSelectorExpression() as? JetCallExpression
+val KtQualifiedExpression.callExpression: KtCallExpression?
+    get() = getSelectorExpression() as? KtCallExpression
 
-val JetQualifiedExpression.calleeName: String?
-    get() = (callExpression?.getCalleeExpression() as? JetNameReferenceExpression)?.getText()
+val KtQualifiedExpression.calleeName: String?
+    get() = (callExpression?.getCalleeExpression() as? KtNameReferenceExpression)?.getText()
 
-fun JetQualifiedExpression.toResolvedCall(): ResolvedCall<out CallableDescriptor>? {
+fun KtQualifiedExpression.toResolvedCall(): ResolvedCall<out CallableDescriptor>? {
     val callExpression = callExpression ?: return null
     return callExpression.getResolvedCall(callExpression.analyze()) ?: return null
 }
 
-fun JetExpression.isExitStatement(): Boolean {
+fun KtExpression.isExitStatement(): Boolean {
     when (this) {
-        is JetContinueExpression, is JetBreakExpression, is JetThrowExpression, is JetReturnExpression -> return true
+        is KtContinueExpression, is KtBreakExpression, is KtThrowExpression, is KtReturnExpression -> return true
         else -> return false
     }
 }
 
 // returns false for call of super, static method or method from package
-fun JetQualifiedExpression.isReceiverExpressionWithValue(): Boolean {
+fun KtQualifiedExpression.isReceiverExpressionWithValue(): Boolean {
     val receiver = getReceiverExpression()
-    if (receiver is JetSuperExpression) return false
+    if (receiver is KtSuperExpression) return false
     return analyze().getType(receiver) != null
 }
 
-public fun JetExpression.negate(): JetExpression {
+public fun KtExpression.negate(): KtExpression {
     val specialNegation = specialNegation()
     if (specialNegation != null) return specialNegation
-    return JetPsiFactory(this).createExpressionByPattern("!$0", this)
+    return KtPsiFactory(this).createExpressionByPattern("!$0", this)
 }
 
-private fun JetExpression.specialNegation(): JetExpression? {
-    val factory = JetPsiFactory(this)
+private fun KtExpression.specialNegation(): KtExpression? {
+    val factory = KtPsiFactory(this)
     when (this) {
-        is JetPrefixExpression -> {
+        is KtPrefixExpression -> {
             if (getOperationReference().getReferencedName() == "!") {
                 val baseExpression = getBaseExpression()
                 if (baseExpression != null) {
-                    return JetPsiUtil.safeDeparenthesize(baseExpression)
+                    return KtPsiUtil.safeDeparenthesize(baseExpression)
                 }
             }
         }
 
-        is JetBinaryExpression -> {
+        is KtBinaryExpression -> {
             val operator = getOperationToken()
             if (operator !in NEGATABLE_OPERATORS) return null
             val left = getLeft() ?: return null
@@ -149,7 +149,7 @@ private fun JetExpression.specialNegation(): JetExpression? {
             return factory.createExpressionByPattern("$0 $1 $2", left, getNegatedOperatorText(operator), right)
         }
 
-        is JetConstantExpression -> {
+        is KtConstantExpression -> {
             return when (getText()) {
                 "true" -> factory.createExpression("false")
                 "false" -> factory.createExpression("true")
@@ -160,24 +160,24 @@ private fun JetExpression.specialNegation(): JetExpression? {
     return null
 }
 
-private val NEGATABLE_OPERATORS = setOf(JetTokens.EQEQ, JetTokens.EXCLEQ, JetTokens.EQEQEQ,
-                                        JetTokens.EXCLEQEQEQ, JetTokens.IS_KEYWORD, JetTokens.NOT_IS, JetTokens.IN_KEYWORD,
-                                        JetTokens.NOT_IN, JetTokens.LT, JetTokens.LTEQ, JetTokens.GT, JetTokens.GTEQ)
+private val NEGATABLE_OPERATORS = setOf(KtTokens.EQEQ, KtTokens.EXCLEQ, KtTokens.EQEQEQ,
+                                        KtTokens.EXCLEQEQEQ, KtTokens.IS_KEYWORD, KtTokens.NOT_IS, KtTokens.IN_KEYWORD,
+                                        KtTokens.NOT_IN, KtTokens.LT, KtTokens.LTEQ, KtTokens.GT, KtTokens.GTEQ)
 
 private fun getNegatedOperatorText(token: IElementType): String {
     return when(token) {
-        JetTokens.EQEQ -> JetTokens.EXCLEQ.getValue()
-        JetTokens.EXCLEQ -> JetTokens.EQEQ.getValue()
-        JetTokens.EQEQEQ -> JetTokens.EXCLEQEQEQ.getValue()
-        JetTokens.EXCLEQEQEQ -> JetTokens.EQEQEQ.getValue()
-        JetTokens.IS_KEYWORD -> JetTokens.NOT_IS.getValue()
-        JetTokens.NOT_IS -> JetTokens.IS_KEYWORD.getValue()
-        JetTokens.IN_KEYWORD -> JetTokens.NOT_IN.getValue()
-        JetTokens.NOT_IN -> JetTokens.IN_KEYWORD.getValue()
-        JetTokens.LT -> JetTokens.GTEQ.getValue()
-        JetTokens.LTEQ -> JetTokens.GT.getValue()
-        JetTokens.GT -> JetTokens.LTEQ.getValue()
-        JetTokens.GTEQ -> JetTokens.LT.getValue()
+        KtTokens.EQEQ -> KtTokens.EXCLEQ.getValue()
+        KtTokens.EXCLEQ -> KtTokens.EQEQ.getValue()
+        KtTokens.EQEQEQ -> KtTokens.EXCLEQEQEQ.getValue()
+        KtTokens.EXCLEQEQEQ -> KtTokens.EQEQEQ.getValue()
+        KtTokens.IS_KEYWORD -> KtTokens.NOT_IS.getValue()
+        KtTokens.NOT_IS -> KtTokens.IS_KEYWORD.getValue()
+        KtTokens.IN_KEYWORD -> KtTokens.NOT_IN.getValue()
+        KtTokens.NOT_IN -> KtTokens.IN_KEYWORD.getValue()
+        KtTokens.LT -> KtTokens.GTEQ.getValue()
+        KtTokens.LTEQ -> KtTokens.GT.getValue()
+        KtTokens.GT -> KtTokens.LTEQ.getValue()
+        KtTokens.GTEQ -> KtTokens.LT.getValue()
         else -> throw IllegalArgumentException("The token $token does not have a negated equivalent.")
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/BranchedFoldingUtils.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/BranchedFoldingUtils.kt
index 2ae0b9e1756..eed4fbe7c46 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/BranchedFoldingUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/BranchedFoldingUtils.kt
@@ -16,34 +16,34 @@
 
 package org.jetbrains.kotlin.idea.intentions.branchedTransformations
 
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.lastBlockStatementOrThis
 import org.jetbrains.kotlin.utils.addToStdlib.check
 
 object BranchedFoldingUtils {
-    public fun getFoldableBranchedAssignment(branch: JetExpression?): JetBinaryExpression? {
-        fun checkAssignment(expression: JetBinaryExpression): Boolean {
-            if (expression.getOperationToken() !in JetTokens.ALL_ASSIGNMENTS) return false
+    public fun getFoldableBranchedAssignment(branch: KtExpression?): KtBinaryExpression? {
+        fun checkAssignment(expression: KtBinaryExpression): Boolean {
+            if (expression.getOperationToken() !in KtTokens.ALL_ASSIGNMENTS) return false
 
-            val left = expression.getLeft() as? JetNameReferenceExpression ?: return false
+            val left = expression.getLeft() as? KtNameReferenceExpression ?: return false
             if (expression.getRight() == null) return false
 
             val parent = expression.getParent()
-            if (parent is JetBlockExpression) {
-                return !JetPsiUtil.checkVariableDeclarationInBlock(parent, left.getText())
+            if (parent is KtBlockExpression) {
+                return !KtPsiUtil.checkVariableDeclarationInBlock(parent, left.getText())
             }
 
             return true
         }
-        return (branch?.lastBlockStatementOrThis() as? JetBinaryExpression)?.check(::checkAssignment)
+        return (branch?.lastBlockStatementOrThis() as? KtBinaryExpression)?.check(::checkAssignment)
     }
 
-    public fun getFoldableBranchedReturn(branch: JetExpression?): JetReturnExpression? {
-        return (branch?.lastBlockStatementOrThis() as? JetReturnExpression)?.check { it.getReturnedExpression() != null }
+    public fun getFoldableBranchedReturn(branch: KtExpression?): KtReturnExpression? {
+        return (branch?.lastBlockStatementOrThis() as? KtReturnExpression)?.check { it.getReturnedExpression() != null }
     }
 
-    public fun checkAssignmentsMatch(a1: JetBinaryExpression, a2: JetBinaryExpression): Boolean {
+    public fun checkAssignmentsMatch(a1: KtBinaryExpression, a2: KtBinaryExpression): Boolean {
         return a1.getLeft()?.getText() == a2.getLeft()?.getText() && a1.getOperationToken() == a2.getOperationToken()
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/BranchedUnfoldingUtils.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/BranchedUnfoldingUtils.kt
index 69f64ad379b..60be924806a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/BranchedUnfoldingUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/BranchedUnfoldingUtils.kt
@@ -22,17 +22,17 @@ import org.jetbrains.kotlin.idea.core.copied
 import org.jetbrains.kotlin.psi.psiUtil.lastBlockStatementOrThis
 
 public object BranchedUnfoldingUtils {
-    public fun unfoldAssignmentToIf(assignment: JetBinaryExpression, editor: Editor) {
+    public fun unfoldAssignmentToIf(assignment: KtBinaryExpression, editor: Editor) {
         val op = assignment.getOperationReference().getText()
         val left = assignment.getLeft()!!
-        val ifExpression = assignment.getRight() as JetIfExpression
+        val ifExpression = assignment.getRight() as KtIfExpression
 
         val newIfExpression = ifExpression.copied()
 
         val thenExpr = newIfExpression.getThen()!!.lastBlockStatementOrThis()
         val elseExpr = newIfExpression.getElse()!!.lastBlockStatementOrThis()
 
-        val psiFactory = JetPsiFactory(assignment)
+        val psiFactory = KtPsiFactory(assignment)
         thenExpr.replace(psiFactory.createExpressionByPattern("$0 $1 $2", left, op, thenExpr))
         elseExpr.replace(psiFactory.createExpressionByPattern("$0 $1 $2", left, op, elseExpr))
 
@@ -41,16 +41,16 @@ public object BranchedUnfoldingUtils {
         editor.getCaretModel().moveToOffset(resultIf.getTextOffset())
     }
 
-    public fun unfoldAssignmentToWhen(assignment: JetBinaryExpression, editor: Editor) {
+    public fun unfoldAssignmentToWhen(assignment: KtBinaryExpression, editor: Editor) {
         val op = assignment.getOperationReference().getText()
         val left = assignment.getLeft()!!
-        val whenExpression = assignment.getRight() as JetWhenExpression
+        val whenExpression = assignment.getRight() as KtWhenExpression
 
         val newWhenExpression = whenExpression.copied()
 
         for (entry in newWhenExpression.getEntries()) {
             val expr = entry.getExpression()!!.lastBlockStatementOrThis()
-            expr.replace(JetPsiFactory(assignment).createExpressionByPattern("$0 $1 $2", left, op, expr))
+            expr.replace(KtPsiFactory(assignment).createExpressionByPattern("$0 $1 $2", left, op, expr))
         }
 
         val resultWhen = assignment.replace(newWhenExpression)
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/IfThenUtils.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/IfThenUtils.kt
index 57dedcb6e5a..efec15cd2ae 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/IfThenUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/IfThenUtils.kt
@@ -19,14 +19,14 @@ package org.jetbrains.kotlin.idea.intentions.branchedTransformations
 import com.intellij.openapi.editor.Editor
 import com.intellij.psi.search.LocalSearchScope
 import com.intellij.psi.search.searches.ReferencesSearch
-import org.jetbrains.kotlin.JetNodeTypes
+import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.refactoring.inline.KotlinInlineValHandler
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable.KotlinIntroduceVariableHandler
 import org.jetbrains.kotlin.idea.references.mainReference
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingContextUtils
@@ -37,9 +37,9 @@ import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 val NULL_PTR_EXCEPTION_FQ = "java.lang.NullPointerException"
 val KOTLIN_NULL_PTR_EXCEPTION_FQ = "kotlin.KotlinNullPointerException"
 
-fun JetBinaryExpression.expressionComparedToNull(): JetExpression? {
+fun KtBinaryExpression.expressionComparedToNull(): KtExpression? {
     val operationToken = this.getOperationToken()
-    if (operationToken != JetTokens.EQEQ && operationToken != JetTokens.EXCLEQ) return null
+    if (operationToken != KtTokens.EQEQ && operationToken != KtTokens.EXCLEQ) return null
 
     val right = this.getRight() ?: return null
     val left = this.getLeft() ?: return null
@@ -50,25 +50,25 @@ fun JetBinaryExpression.expressionComparedToNull(): JetExpression? {
     return if (leftIsNull) right else left
 }
 
-fun JetExpression.unwrapBlockOrParenthesis(): JetExpression {
-    val innerExpression = JetPsiUtil.safeDeparenthesize(this)
-    if (innerExpression is JetBlockExpression) {
+fun KtExpression.unwrapBlockOrParenthesis(): KtExpression {
+    val innerExpression = KtPsiUtil.safeDeparenthesize(this)
+    if (innerExpression is KtBlockExpression) {
         val statement = innerExpression.getStatements().singleOrNull() ?: return this
-        return JetPsiUtil.safeDeparenthesize(statement)
+        return KtPsiUtil.safeDeparenthesize(statement)
     }
     return innerExpression
 }
 
-fun JetExpression?.isNullExpression(): Boolean = this?.unwrapBlockOrParenthesis()?.getNode()?.getElementType() == JetNodeTypes.NULL
+fun KtExpression?.isNullExpression(): Boolean = this?.unwrapBlockOrParenthesis()?.getNode()?.getElementType() == KtNodeTypes.NULL
 
-fun JetExpression?.isNullExpressionOrEmptyBlock(): Boolean = this.isNullExpression() || this is JetBlockExpression && this.getStatements().isEmpty()
+fun KtExpression?.isNullExpressionOrEmptyBlock(): Boolean = this.isNullExpression() || this is KtBlockExpression && this.getStatements().isEmpty()
 
-fun JetThrowExpression.throwsNullPointerExceptionWithNoArguments(): Boolean {
+fun KtThrowExpression.throwsNullPointerExceptionWithNoArguments(): Boolean {
     val thrownExpression = this.getThrownExpression()
-    if (thrownExpression !is JetCallExpression) return false
+    if (thrownExpression !is KtCallExpression) return false
 
     val context = this.analyze(BodyResolveMode.PARTIAL)
-    val nameExpression = thrownExpression.calleeExpression as? JetNameReferenceExpression ?: return false
+    val nameExpression = thrownExpression.calleeExpression as? KtNameReferenceExpression ?: return false
     val descriptor = context[BindingContext.REFERENCE_TARGET, nameExpression]
     val declDescriptor = descriptor?.getContainingDeclaration() ?: return false
 
@@ -76,27 +76,27 @@ fun JetThrowExpression.throwsNullPointerExceptionWithNoArguments(): Boolean {
     return (exceptionName == NULL_PTR_EXCEPTION_FQ || exceptionName == KOTLIN_NULL_PTR_EXCEPTION_FQ) && thrownExpression.getValueArguments().isEmpty()
 }
 
-fun JetExpression.evaluatesTo(other: JetExpression): Boolean {
+fun KtExpression.evaluatesTo(other: KtExpression): Boolean {
     return this.unwrapBlockOrParenthesis().getText() == other.getText()
 }
 
-fun JetExpression.convertToIfNotNullExpression(conditionLhs: JetExpression, thenClause: JetExpression, elseClause: JetExpression?): JetIfExpression {
-    val condition = JetPsiFactory(this).createExpressionByPattern("$0 != null", conditionLhs)
+fun KtExpression.convertToIfNotNullExpression(conditionLhs: KtExpression, thenClause: KtExpression, elseClause: KtExpression?): KtIfExpression {
+    val condition = KtPsiFactory(this).createExpressionByPattern("$0 != null", conditionLhs)
     return this.convertToIfStatement(condition, thenClause, elseClause)
 }
 
-fun JetExpression.convertToIfNullExpression(conditionLhs: JetExpression, thenClause: JetExpression): JetIfExpression {
-    val condition = JetPsiFactory(this).createExpressionByPattern("$0 == null", conditionLhs)
+fun KtExpression.convertToIfNullExpression(conditionLhs: KtExpression, thenClause: KtExpression): KtIfExpression {
+    val condition = KtPsiFactory(this).createExpressionByPattern("$0 == null", conditionLhs)
     return this.convertToIfStatement(condition, thenClause)
 }
 
-fun JetExpression.convertToIfStatement(condition: JetExpression, thenClause: JetExpression, elseClause: JetExpression? = null): JetIfExpression {
-    return replaced(JetPsiFactory(this).createIf(condition, thenClause, elseClause))
+fun KtExpression.convertToIfStatement(condition: KtExpression, thenClause: KtExpression, elseClause: KtExpression? = null): KtIfExpression {
+    return replaced(KtPsiFactory(this).createIf(condition, thenClause, elseClause))
 }
 
-fun JetIfExpression.introduceValueForCondition(occurrenceInThenClause: JetExpression, editor: Editor) {
+fun KtIfExpression.introduceValueForCondition(occurrenceInThenClause: KtExpression, editor: Editor) {
     val project = this.getProject()
-    val occurrenceInConditional = (this.getCondition() as JetBinaryExpression).getLeft()!!
+    val occurrenceInConditional = (this.getCondition() as KtBinaryExpression).getLeft()!!
     KotlinIntroduceVariableHandler.doRefactoring(project,
                                                  editor,
                                                  occurrenceInConditional,
@@ -104,10 +104,10 @@ fun JetIfExpression.introduceValueForCondition(occurrenceInThenClause: JetExpres
                                                  null)
 }
 
-fun JetNameReferenceExpression.inlineIfDeclaredLocallyAndOnlyUsedOnceWithPrompt(editor: Editor) {
-    val declaration = this.mainReference.resolve() as? JetProperty ?: return
+fun KtNameReferenceExpression.inlineIfDeclaredLocallyAndOnlyUsedOnceWithPrompt(editor: Editor) {
+    val declaration = this.mainReference.resolve() as? KtProperty ?: return
 
-    val enclosingElement = JetPsiUtil.getEnclosingElementForLocalDeclaration(declaration)
+    val enclosingElement = KtPsiUtil.getEnclosingElementForLocalDeclaration(declaration)
     val isLocal = enclosingElement != null
     if (!isLocal) return
 
@@ -119,19 +119,19 @@ fun JetNameReferenceExpression.inlineIfDeclaredLocallyAndOnlyUsedOnceWithPrompt(
     }
 }
 
-fun JetSafeQualifiedExpression.inlineReceiverIfApplicableWithPrompt(editor: Editor) {
-    (this.getReceiverExpression() as? JetNameReferenceExpression)?.inlineIfDeclaredLocallyAndOnlyUsedOnceWithPrompt(editor)
+fun KtSafeQualifiedExpression.inlineReceiverIfApplicableWithPrompt(editor: Editor) {
+    (this.getReceiverExpression() as? KtNameReferenceExpression)?.inlineIfDeclaredLocallyAndOnlyUsedOnceWithPrompt(editor)
 }
 
-fun JetBinaryExpression.inlineLeftSideIfApplicableWithPrompt(editor: Editor) {
-    (this.getLeft() as? JetNameReferenceExpression)?.inlineIfDeclaredLocallyAndOnlyUsedOnceWithPrompt(editor)
+fun KtBinaryExpression.inlineLeftSideIfApplicableWithPrompt(editor: Editor) {
+    (this.getLeft() as? KtNameReferenceExpression)?.inlineIfDeclaredLocallyAndOnlyUsedOnceWithPrompt(editor)
 }
 
-fun JetPostfixExpression.inlineBaseExpressionIfApplicableWithPrompt(editor: Editor) {
-    (this.getBaseExpression() as? JetNameReferenceExpression)?.inlineIfDeclaredLocallyAndOnlyUsedOnceWithPrompt(editor)
+fun KtPostfixExpression.inlineBaseExpressionIfApplicableWithPrompt(editor: Editor) {
+    (this.getBaseExpression() as? KtNameReferenceExpression)?.inlineIfDeclaredLocallyAndOnlyUsedOnceWithPrompt(editor)
 }
 
-fun JetExpression.isStableVariable(): Boolean {
+fun KtExpression.isStableVariable(): Boolean {
     val context = this.analyze()
     val descriptor = BindingContextUtils.extractVariableDescriptorIfAny(context, this, false)
     return descriptor is VariableDescriptor &&
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/branchedTransformationUtils.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/branchedTransformationUtils.kt
index 93aa5d2dd19..afb1522f260 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/branchedTransformationUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/branchedTransformationUtils.kt
@@ -18,23 +18,23 @@ package org.jetbrains.kotlin.idea.intentions.branchedTransformations
 
 import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.matches
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 
-fun JetWhenCondition.toExpression(subject: JetExpression?): JetExpression {
-    val factory = JetPsiFactory(this)
+fun KtWhenCondition.toExpression(subject: KtExpression?): KtExpression {
+    val factory = KtPsiFactory(this)
     when (this) {
-        is JetWhenConditionIsPattern -> {
+        is KtWhenConditionIsPattern -> {
             val op = if (isNegated()) "!is" else "is"
             return factory.createExpressionByPattern("$0 $op $1", subject ?: "_", getTypeReference() ?: "")
         }
 
-        is JetWhenConditionInRange -> {
+        is KtWhenConditionInRange -> {
             val op = getOperationReference().getText()
             return factory.createExpressionByPattern("$0 $op $1", subject ?: "_", getRangeExpression() ?: "")
         }
 
-        is JetWhenConditionWithExpression -> {
+        is KtWhenConditionWithExpression -> {
             return if (subject != null) {
                 factory.createExpressionByPattern("$0 == $1", subject, getExpression() ?: "")
             }
@@ -47,18 +47,18 @@ fun JetWhenCondition.toExpression(subject: JetExpression?): JetExpression {
     }
 }
 
-public fun JetWhenExpression.getSubjectToIntroduce(): JetExpression?  {
+public fun KtWhenExpression.getSubjectToIntroduce(): KtExpression?  {
     if (getSubjectExpression() != null) return null
 
-    var lastCandidate: JetExpression? = null
+    var lastCandidate: KtExpression? = null
     for (entry in getEntries()) {
         val conditions = entry.getConditions()
         if (!entry.isElse() && conditions.isEmpty()) return null
 
         for (condition in conditions) {
-            if (condition !is JetWhenConditionWithExpression) return null
+            if (condition !is KtWhenConditionWithExpression) return null
 
-            val candidate = condition.getExpression()?.getWhenConditionSubjectCandidate() as? JetNameReferenceExpression ?: return null
+            val candidate = condition.getExpression()?.getWhenConditionSubjectCandidate() as? KtNameReferenceExpression ?: return null
 
             if (lastCandidate == null) {
                 lastCandidate = candidate
@@ -73,16 +73,16 @@ public fun JetWhenExpression.getSubjectToIntroduce(): JetExpression?  {
     return lastCandidate
 }
 
-private fun JetExpression?.getWhenConditionSubjectCandidate(): JetExpression? {
+private fun KtExpression?.getWhenConditionSubjectCandidate(): KtExpression? {
     return when(this) {
-        is JetIsExpression -> getLeftHandSide()
+        is KtIsExpression -> getLeftHandSide()
 
-        is JetBinaryExpression -> {
+        is KtBinaryExpression -> {
             val lhs = getLeft()
             val op = getOperationToken()
             when (op) {
-                JetTokens.IN_KEYWORD, JetTokens.NOT_IN -> lhs
-                JetTokens.EQEQ -> lhs as? JetNameReferenceExpression ?: getRight()
+                KtTokens.IN_KEYWORD, KtTokens.NOT_IN -> lhs
+                KtTokens.EQEQ -> lhs as? KtNameReferenceExpression ?: getRight()
                 else -> null
             }
 
@@ -92,10 +92,10 @@ private fun JetExpression?.getWhenConditionSubjectCandidate(): JetExpression? {
     }
 }
 
-public fun JetWhenExpression.introduceSubject(): JetWhenExpression {
+public fun KtWhenExpression.introduceSubject(): KtWhenExpression {
     val subject = getSubjectToIntroduce()!!
 
-    val whenExpression = JetPsiFactory(this).buildExpression {
+    val whenExpression = KtPsiFactory(this).buildExpression {
         appendFixedText("when(").appendExpression(subject).appendFixedText("){\n")
 
         for (entry in getEntries()) {
@@ -108,9 +108,9 @@ public fun JetWhenExpression.introduceSubject(): JetWhenExpression {
                 for ((i, condition) in entry.getConditions().withIndex()) {
                     if (i > 0) appendFixedText(",")
 
-                    val conditionExpression = (condition as JetWhenConditionWithExpression).getExpression()
+                    val conditionExpression = (condition as KtWhenConditionWithExpression).getExpression()
                     when (conditionExpression)  {
-                        is JetIsExpression -> {
+                        is KtIsExpression -> {
                             if (conditionExpression.isNegated()) {
                                 appendFixedText("!")
                             }
@@ -118,14 +118,14 @@ public fun JetWhenExpression.introduceSubject(): JetWhenExpression {
                             appendNonFormattedText(conditionExpression.getTypeReference()?.getText() ?: "")
                         }
 
-                        is JetBinaryExpression -> {
+                        is KtBinaryExpression -> {
                             val lhs = conditionExpression.getLeft()
                             val rhs = conditionExpression.getRight()
                             val op = conditionExpression.getOperationToken()
                             when (op) {
-                                JetTokens.IN_KEYWORD -> appendFixedText("in ").appendExpression(rhs)
-                                JetTokens.NOT_IN -> appendFixedText("!in ").appendExpression(rhs)
-                                JetTokens.EQEQ -> appendExpression(if (subject.matches(lhs)) rhs else lhs)
+                                KtTokens.IN_KEYWORD -> appendFixedText("in ").appendExpression(rhs)
+                                KtTokens.NOT_IN -> appendFixedText("!in ").appendExpression(rhs)
+                                KtTokens.EQEQ -> appendExpression(if (subject.matches(lhs)) rhs else lhs)
                                 else -> throw IllegalStateException()
                             }
                         }
@@ -141,7 +141,7 @@ public fun JetWhenExpression.introduceSubject(): JetWhenExpression {
         }
 
         appendFixedText("}")
-    } as JetWhenExpression
+    } as KtWhenExpression
 
     return replaced(whenExpression)
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/DoubleBangToIfThenIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/DoubleBangToIfThenIntention.kt
index e4838abf944..280b95746ea 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/DoubleBangToIfThenIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/DoubleBangToIfThenIntention.kt
@@ -32,26 +32,26 @@ import org.jetbrains.kotlin.idea.intentions.branchedTransformations.convertToIfN
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.convertToIfNullExpression
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.introduceValueForCondition
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.isStableVariable
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetPostfixExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetPsiUtil
-import org.jetbrains.kotlin.psi.JetThrowExpression
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtPostfixExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtPsiUtil
+import org.jetbrains.kotlin.psi.KtThrowExpression
 import org.jetbrains.kotlin.resolve.bindingContextUtil.isUsedAsStatement
 
-public class DoubleBangToIfThenIntention : JetSelfTargetingRangeIntention<JetPostfixExpression>(javaClass(), "Replace '!!' expression with 'if' expression"), LowPriorityAction {
-    override fun applicabilityRange(element: JetPostfixExpression): TextRange? {
-        return if (element.getOperationToken() == JetTokens.EXCLEXCL && element.getBaseExpression() != null)
+public class DoubleBangToIfThenIntention : JetSelfTargetingRangeIntention<KtPostfixExpression>(javaClass(), "Replace '!!' expression with 'if' expression"), LowPriorityAction {
+    override fun applicabilityRange(element: KtPostfixExpression): TextRange? {
+        return if (element.getOperationToken() == KtTokens.EXCLEXCL && element.getBaseExpression() != null)
             element.getOperationReference().getTextRange()
         else
             null
     }
 
-    override fun applyTo(element: JetPostfixExpression, editor: Editor) {
-        val base = JetPsiUtil.safeDeparenthesize(element.getBaseExpression()!!)
+    override fun applyTo(element: KtPostfixExpression, editor: Editor) {
+        val base = KtPsiUtil.safeDeparenthesize(element.getBaseExpression()!!)
         val expressionText = formatForUseInExceptionArgument(base.getText()!!)
 
-        val defaultException = JetPsiFactory(element).createExpression("throw NullPointerException()")
+        val defaultException = KtPsiFactory(element).createExpression("throw NullPointerException()")
 
         val isStatement = element.isUsedAsStatement(element.analyze())
         val isStable = base.isStableVariable()
@@ -62,7 +62,7 @@ public class DoubleBangToIfThenIntention : JetSelfTargetingRangeIntention<JetPos
             element.convertToIfNotNullExpression(base, base, defaultException)
 
         val thrownExpression =
-                ((if (isStatement) ifStatement.getThen() else ifStatement.getElse()) as JetThrowExpression).getThrownExpression()!!
+                ((if (isStatement) ifStatement.getThen() else ifStatement.getElse()) as KtThrowExpression).getThrownExpression()!!
 
         val message = escapeJava("Expression '$expressionText' must not be null")
         val nullPtrExceptionText = "NullPointerException(\"$message\")"
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/EliminateWhenSubjectIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/EliminateWhenSubjectIntention.kt
index 73679f5d888..dbb6b1f2bc1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/EliminateWhenSubjectIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/EliminateWhenSubjectIntention.kt
@@ -20,23 +20,23 @@ import com.intellij.codeInsight.intention.LowPriorityAction
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.toExpression
-import org.jetbrains.kotlin.psi.JetNameReferenceExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetWhenExpression
+import org.jetbrains.kotlin.psi.KtNameReferenceExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtWhenExpression
 import org.jetbrains.kotlin.psi.buildExpression
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
-public class EliminateWhenSubjectIntention : JetSelfTargetingIntention<JetWhenExpression>(javaClass(), "Eliminate argument of 'when'"), LowPriorityAction {
-    override fun isApplicableTo(element: JetWhenExpression, caretOffset: Int): Boolean {
-        if (element.getSubjectExpression() !is JetNameReferenceExpression) return false
+public class EliminateWhenSubjectIntention : JetSelfTargetingIntention<KtWhenExpression>(javaClass(), "Eliminate argument of 'when'"), LowPriorityAction {
+    override fun isApplicableTo(element: KtWhenExpression, caretOffset: Int): Boolean {
+        if (element.getSubjectExpression() !is KtNameReferenceExpression) return false
         val lBrace = element.getOpenBrace() ?: return false
         return caretOffset <= lBrace.startOffset
     }
 
-    override fun applyTo(element: JetWhenExpression, editor: Editor) {
+    override fun applyTo(element: KtWhenExpression, editor: Editor) {
         val subject = element.getSubjectExpression()!!
 
-        val whenExpression = JetPsiFactory(element).buildExpression {
+        val whenExpression = KtPsiFactory(element).buildExpression {
             appendFixedText("when {\n")
 
             for (entry in element.getEntries()) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/ElvisToIfThenIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/ElvisToIfThenIntention.kt
index f6b2c09343b..5def61f7843 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/ElvisToIfThenIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/ElvisToIfThenIntention.kt
@@ -23,21 +23,21 @@ import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.convertToIfNotNullExpression
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.introduceValueForCondition
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.isStableVariable
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetPsiUtil
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtPsiUtil
 
-public class ElvisToIfThenIntention : JetSelfTargetingRangeIntention<JetBinaryExpression>(javaClass(), "Replace elvis expression with 'if' expression"), LowPriorityAction {
-    override fun applicabilityRange(element: JetBinaryExpression): TextRange? {
-        return if (element.getOperationToken() == JetTokens.ELVIS && element.getLeft() != null && element.getRight() != null)
+public class ElvisToIfThenIntention : JetSelfTargetingRangeIntention<KtBinaryExpression>(javaClass(), "Replace elvis expression with 'if' expression"), LowPriorityAction {
+    override fun applicabilityRange(element: KtBinaryExpression): TextRange? {
+        return if (element.getOperationToken() == KtTokens.ELVIS && element.getLeft() != null && element.getRight() != null)
             element.getOperationReference().getTextRange()
         else
             null
     }
 
-    override fun applyTo(element: JetBinaryExpression, editor: Editor) {
-        val left = JetPsiUtil.safeDeparenthesize(element.getLeft()!!)
-        val right = JetPsiUtil.safeDeparenthesize(element.getRight()!!)
+    override fun applyTo(element: KtBinaryExpression, editor: Editor) {
+        val left = KtPsiUtil.safeDeparenthesize(element.getLeft()!!)
+        val right = KtPsiUtil.safeDeparenthesize(element.getRight()!!)
 
         val leftIsStable = left.isStableVariable()
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FlattenWhenIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FlattenWhenIntention.kt
index 5e950e4f4f0..39c6a2ceda5 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FlattenWhenIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FlattenWhenIntention.kt
@@ -25,31 +25,31 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
-public class FlattenWhenIntention : JetSelfTargetingIntention<JetWhenExpression>(javaClass(), "Flatten 'when' expression") {
-    override fun isApplicableTo(element: JetWhenExpression, caretOffset: Int): Boolean {
+public class FlattenWhenIntention : JetSelfTargetingIntention<KtWhenExpression>(javaClass(), "Flatten 'when' expression") {
+    override fun isApplicableTo(element: KtWhenExpression, caretOffset: Int): Boolean {
         val subject = element.getSubjectExpression()
-        if (subject != null && subject !is JetNameReferenceExpression) return false
+        if (subject != null && subject !is KtNameReferenceExpression) return false
 
-        if (!JetPsiUtil.checkWhenExpressionHasSingleElse(element)) return false
+        if (!KtPsiUtil.checkWhenExpressionHasSingleElse(element)) return false
 
         val elseEntry = element.getEntries().singleOrNull { it.isElse() } ?: return false
 
-        val innerWhen = elseEntry.getExpression() as? JetWhenExpression ?: return false
+        val innerWhen = elseEntry.getExpression() as? KtWhenExpression ?: return false
 
         if (!subject.matches(innerWhen.getSubjectExpression())) return false
-        if (!JetPsiUtil.checkWhenExpressionHasSingleElse(innerWhen)) return false
+        if (!KtPsiUtil.checkWhenExpressionHasSingleElse(innerWhen)) return false
 
         return elseEntry.startOffset <= caretOffset && caretOffset <= innerWhen.getWhenKeyword().endOffset
     }
 
-    override fun applyTo(element: JetWhenExpression, editor: Editor) {
+    override fun applyTo(element: KtWhenExpression, editor: Editor) {
         val subjectExpression = element.getSubjectExpression()
-        val nestedWhen = element.getElseExpression() as JetWhenExpression
+        val nestedWhen = element.getElseExpression() as KtWhenExpression
 
         val outerEntries = element.getEntries()
         val innerEntries = nestedWhen.getEntries()
 
-        val whenExpression = JetPsiFactory(element).buildExpression {
+        val whenExpression = KtPsiFactory(element).buildExpression {
             appendFixedText("when")
             if (subjectExpression != null) {
                 appendFixedText("(").appendExpression(subjectExpression).appendFixedText(")")
@@ -67,7 +67,7 @@ public class FlattenWhenIntention : JetSelfTargetingIntention<JetWhenExpression>
             }
 
             appendFixedText("}")
-        } as JetWhenExpression
+        } as KtWhenExpression
 
         val newWhen = element.replaced(whenExpression)
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldIfToAssignmentIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldIfToAssignmentIntention.kt
index 342bb517555..b78aa0c76be 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldIfToAssignmentIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldIfToAssignmentIntention.kt
@@ -20,19 +20,19 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.BranchedFoldingUtils
-import org.jetbrains.kotlin.psi.JetIfExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtIfExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.createExpressionByPattern
 
-public class FoldIfToAssignmentIntention : JetSelfTargetingRangeIntention<JetIfExpression>(javaClass(), "Replace 'if' expression with assignment") {
-    override fun applicabilityRange(element: JetIfExpression): TextRange? {
+public class FoldIfToAssignmentIntention : JetSelfTargetingRangeIntention<KtIfExpression>(javaClass(), "Replace 'if' expression with assignment") {
+    override fun applicabilityRange(element: KtIfExpression): TextRange? {
         val thenAssignment = BranchedFoldingUtils.getFoldableBranchedAssignment(element.getThen()) ?: return null
         val elseAssignment = BranchedFoldingUtils.getFoldableBranchedAssignment(element.getElse()) ?: return null
         if (!BranchedFoldingUtils.checkAssignmentsMatch(thenAssignment, elseAssignment)) return null
         return element.getIfKeyword().getTextRange()
     }
 
-    override fun applyTo(element: JetIfExpression, editor: Editor) {
+    override fun applyTo(element: KtIfExpression, editor: Editor) {
         var thenAssignment = BranchedFoldingUtils.getFoldableBranchedAssignment(element.getThen()!!)!!
         val elseAssignment = BranchedFoldingUtils.getFoldableBranchedAssignment(element.getElse()!!)!!
 
@@ -42,6 +42,6 @@ public class FoldIfToAssignmentIntention : JetSelfTargetingRangeIntention<JetIfE
         thenAssignment.replace(thenAssignment.getRight()!!)
         elseAssignment.replace(elseAssignment.getRight()!!)
 
-        element.replace(JetPsiFactory(element).createExpressionByPattern("$0 $1 $2", leftText, op, element))
+        element.replace(KtPsiFactory(element).createExpressionByPattern("$0 $1 $2", leftText, op, element))
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldIfToReturnAsymmetricallyIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldIfToReturnAsymmetricallyIntention.kt
index e696b5d6291..9a6d0758eb6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldIfToReturnAsymmetricallyIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldIfToReturnAsymmetricallyIntention.kt
@@ -22,23 +22,23 @@ import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.BranchedFoldingUtils
 import org.jetbrains.kotlin.psi.*
 
-public class FoldIfToReturnAsymmetricallyIntention : JetSelfTargetingRangeIntention<JetIfExpression>(javaClass(), "Replace 'if' expression with return") {
-    override fun applicabilityRange(element: JetIfExpression): TextRange? {
+public class FoldIfToReturnAsymmetricallyIntention : JetSelfTargetingRangeIntention<KtIfExpression>(javaClass(), "Replace 'if' expression with return") {
+    override fun applicabilityRange(element: KtIfExpression): TextRange? {
         if (BranchedFoldingUtils.getFoldableBranchedReturn(element.getThen()) == null || element.getElse() != null) {
             return null
         }
 
-        val nextElement = JetPsiUtil.skipTrailingWhitespacesAndComments(element) as? JetReturnExpression
+        val nextElement = KtPsiUtil.skipTrailingWhitespacesAndComments(element) as? KtReturnExpression
         if (nextElement?.getReturnedExpression() == null) return null
         return element.getIfKeyword().getTextRange()
     }
 
-    override fun applyTo(element: JetIfExpression, editor: Editor) {
+    override fun applyTo(element: KtIfExpression, editor: Editor) {
         val condition = element.getCondition()!!
         val thenBranch = element.getThen()!!
-        val elseBranch = JetPsiUtil.skipTrailingWhitespacesAndComments(element) as JetReturnExpression
+        val elseBranch = KtPsiUtil.skipTrailingWhitespacesAndComments(element) as KtReturnExpression
 
-        val psiFactory = JetPsiFactory(element)
+        val psiFactory = KtPsiFactory(element)
         var newIfExpression = psiFactory.createIf(condition, thenBranch, elseBranch)
 
         val thenReturn = BranchedFoldingUtils.getFoldableBranchedReturn(newIfExpression.getThen()!!)!!
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldIfToReturnIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldIfToReturnIntention.kt
index d9594faa1f0..37938bcdefd 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldIfToReturnIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldIfToReturnIntention.kt
@@ -20,24 +20,24 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.BranchedFoldingUtils
-import org.jetbrains.kotlin.psi.JetIfExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtIfExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.createExpressionByPattern
 
-public class FoldIfToReturnIntention : JetSelfTargetingRangeIntention<JetIfExpression>(javaClass(), "Replace 'if' expression with return") {
-    override fun applicabilityRange(element: JetIfExpression): TextRange? {
+public class FoldIfToReturnIntention : JetSelfTargetingRangeIntention<KtIfExpression>(javaClass(), "Replace 'if' expression with return") {
+    override fun applicabilityRange(element: KtIfExpression): TextRange? {
         if (BranchedFoldingUtils.getFoldableBranchedReturn(element.getThen()) == null) return null
         if (BranchedFoldingUtils.getFoldableBranchedReturn(element.getElse()) == null) return null
         return element.getIfKeyword().getTextRange()
     }
 
-    override fun applyTo(element: JetIfExpression, editor: Editor) {
+    override fun applyTo(element: KtIfExpression, editor: Editor) {
         val thenReturn = BranchedFoldingUtils.getFoldableBranchedReturn(element.getThen()!!)!!
         val elseReturn = BranchedFoldingUtils.getFoldableBranchedReturn(element.getElse()!!)!!
 
         thenReturn.replace(thenReturn.getReturnedExpression()!!)
         elseReturn.replace(elseReturn.getReturnedExpression()!!)
 
-        element.replace(JetPsiFactory(element).createExpressionByPattern("return $0", element))
+        element.replace(KtPsiFactory(element).createExpressionByPattern("return $0", element))
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldWhenToAssignmentIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldWhenToAssignmentIntention.kt
index 15b5b8269aa..38521f695e5 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldWhenToAssignmentIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldWhenToAssignmentIntention.kt
@@ -23,15 +23,15 @@ import org.jetbrains.kotlin.idea.intentions.branchedTransformations.BranchedFold
 import org.jetbrains.kotlin.psi.*
 import java.util.*
 
-public class FoldWhenToAssignmentIntention : JetSelfTargetingRangeIntention<JetWhenExpression>(javaClass(), "Replace 'when' expression with assignment") {
-    override fun applicabilityRange(element: JetWhenExpression): TextRange? {
-        if (!JetPsiUtil.checkWhenExpressionHasSingleElse(element)) return null
+public class FoldWhenToAssignmentIntention : JetSelfTargetingRangeIntention<KtWhenExpression>(javaClass(), "Replace 'when' expression with assignment") {
+    override fun applicabilityRange(element: KtWhenExpression): TextRange? {
+        if (!KtPsiUtil.checkWhenExpressionHasSingleElse(element)) return null
 
         val entries = element.getEntries()
 
         if (entries.isEmpty()) return null
 
-        val assignments = ArrayList<JetBinaryExpression>()
+        val assignments = ArrayList<KtBinaryExpression>()
         for (entry in entries) {
             val assignment = BranchedFoldingUtils.getFoldableBranchedAssignment(entry.getExpression()) ?: return null
             assignments.add(assignment)
@@ -47,16 +47,16 @@ public class FoldWhenToAssignmentIntention : JetSelfTargetingRangeIntention<JetW
         return element.getWhenKeyword().getTextRange()
     }
 
-    override fun applyTo(element: JetWhenExpression, editor: Editor) {
+    override fun applyTo(element: KtWhenExpression, editor: Editor) {
         assert(!element.getEntries().isEmpty())
 
         val firstAssignment = BranchedFoldingUtils.getFoldableBranchedAssignment(element.getEntries().get(0).getExpression()!!)!!
 
         val op = firstAssignment.getOperationReference().getText()
-        val lhs = firstAssignment.getLeft() as JetNameReferenceExpression
+        val lhs = firstAssignment.getLeft() as KtNameReferenceExpression
 
-        val assignment = JetPsiFactory(element).createExpressionByPattern("$0 $1 $2", lhs, op, element)
-        val newWhenExpression = (assignment as JetBinaryExpression).getRight() as JetWhenExpression
+        val assignment = KtPsiFactory(element).createExpressionByPattern("$0 $1 $2", lhs, op, element)
+        val newWhenExpression = (assignment as KtBinaryExpression).getRight() as KtWhenExpression
 
         for (entry in newWhenExpression.getEntries()) {
             val currAssignment = BranchedFoldingUtils.getFoldableBranchedAssignment(entry.getExpression()!!)!!
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldWhenToReturnIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldWhenToReturnIntention.kt
index 0d69d24769d..341bb8e63d1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldWhenToReturnIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/FoldWhenToReturnIntention.kt
@@ -22,9 +22,9 @@ import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.BranchedFoldingUtils
 import org.jetbrains.kotlin.psi.*
 
-public class FoldWhenToReturnIntention : JetSelfTargetingRangeIntention<JetWhenExpression>(javaClass(), "Replace 'when' expression with return") {
-    override fun applicabilityRange(element: JetWhenExpression): TextRange? {
-        if (!JetPsiUtil.checkWhenExpressionHasSingleElse(element)) return null
+public class FoldWhenToReturnIntention : JetSelfTargetingRangeIntention<KtWhenExpression>(javaClass(), "Replace 'when' expression with return") {
+    override fun applicabilityRange(element: KtWhenExpression): TextRange? {
+        if (!KtPsiUtil.checkWhenExpressionHasSingleElse(element)) return null
 
         val entries = element.getEntries()
 
@@ -37,11 +37,11 @@ public class FoldWhenToReturnIntention : JetSelfTargetingRangeIntention<JetWhenE
         return element.getWhenKeyword().getTextRange()
     }
 
-    override fun applyTo(element: JetWhenExpression, editor: Editor) {
+    override fun applyTo(element: KtWhenExpression, editor: Editor) {
         assert(!element.getEntries().isEmpty())
 
-        val newReturnExpression = JetPsiFactory(element).createExpressionByPattern("return $0", element) as JetReturnExpression
-        val newWhenExpression = newReturnExpression.getReturnedExpression() as JetWhenExpression
+        val newReturnExpression = KtPsiFactory(element).createExpressionByPattern("return $0", element) as KtReturnExpression
+        val newWhenExpression = newReturnExpression.getReturnedExpression() as KtWhenExpression
 
         for (entry in newWhenExpression.getEntries()) {
             val currReturn = BranchedFoldingUtils.getFoldableBranchedReturn(entry.getExpression()!!)!!
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfThenToDoubleBangIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfThenToDoubleBangIntention.kt
index c19bf14d252..40619303a14 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfThenToDoubleBangIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfThenToDoubleBangIntention.kt
@@ -21,15 +21,15 @@ import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.*
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.resolve.bindingContextUtil.isUsedAsStatement
 
-public class IfThenToDoubleBangIntention : JetSelfTargetingRangeIntention<JetIfExpression>(javaClass(), "Replace 'if' expression with '!!' expression") {
-    override fun applicabilityRange(element: JetIfExpression): TextRange? {
-        val condition = element.getCondition() as? JetBinaryExpression ?: return null
+public class IfThenToDoubleBangIntention : JetSelfTargetingRangeIntention<KtIfExpression>(javaClass(), "Replace 'if' expression with '!!' expression") {
+    override fun applicabilityRange(element: KtIfExpression): TextRange? {
+        val condition = element.getCondition() as? KtBinaryExpression ?: return null
         val thenClause = element.getThen() ?: return null
         val elseClause = element.getElse()
 
@@ -37,17 +37,17 @@ public class IfThenToDoubleBangIntention : JetSelfTargetingRangeIntention<JetIfE
 
         val token = condition.getOperationToken()
 
-        val throwExpression: JetThrowExpression
-        val matchingClause: JetExpression?
+        val throwExpression: KtThrowExpression
+        val matchingClause: KtExpression?
         when (token) {
-            JetTokens.EQEQ -> {
-                throwExpression = thenClause.unwrapBlockOrParenthesis() as? JetThrowExpression ?: return null
+            KtTokens.EQEQ -> {
+                throwExpression = thenClause.unwrapBlockOrParenthesis() as? KtThrowExpression ?: return null
                 matchingClause = elseClause
             }
 
-            JetTokens.EXCLEQ -> {
+            KtTokens.EXCLEQ -> {
                 matchingClause = thenClause
-                throwExpression = elseClause?.unwrapBlockOrParenthesis() as? JetThrowExpression ?: return null
+                throwExpression = elseClause?.unwrapBlockOrParenthesis() as? KtThrowExpression ?: return null
             }
 
             else -> throw IllegalStateException()
@@ -66,10 +66,10 @@ public class IfThenToDoubleBangIntention : JetSelfTargetingRangeIntention<JetIfE
         return TextRange(element.startOffset, rParen.endOffset)
     }
 
-    override fun applyTo(element: JetIfExpression, editor: Editor) {
-        val condition = element.getCondition() as JetBinaryExpression
+    override fun applyTo(element: KtIfExpression, editor: Editor) {
+        val condition = element.getCondition() as KtBinaryExpression
         val expression = condition.expressionComparedToNull()!!
-        val result = element.replace(JetPsiFactory(element).createExpressionByPattern("$0!!", expression)) as JetPostfixExpression
+        val result = element.replace(KtPsiFactory(element).createExpressionByPattern("$0!!", expression)) as KtPostfixExpression
 
         result.inlineBaseExpressionIfApplicableWithPrompt(editor)
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfThenToElvisIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfThenToElvisIntention.kt
index 73a8458bd58..f032f0d1df5 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfThenToElvisIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfThenToElvisIntention.kt
@@ -17,20 +17,20 @@
 package org.jetbrains.kotlin.idea.intentions.branchedTransformations.intentions
 
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.JetNodeTypes
+import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingOffsetIndependentIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.*
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.idea.core.replaced
 
-public class IfThenToElvisInspection : IntentionBasedInspection<JetIfExpression>(IfThenToElvisIntention())
+public class IfThenToElvisInspection : IntentionBasedInspection<KtIfExpression>(IfThenToElvisIntention())
 
-public class IfThenToElvisIntention : JetSelfTargetingOffsetIndependentIntention<JetIfExpression>(javaClass(), "Replace 'if' expression with elvis expression") {
+public class IfThenToElvisIntention : JetSelfTargetingOffsetIndependentIntention<KtIfExpression>(javaClass(), "Replace 'if' expression with elvis expression") {
 
-    override fun isApplicableTo(element: JetIfExpression): Boolean {
-        val condition = element.getCondition() as? JetBinaryExpression ?: return false
+    override fun isApplicableTo(element: KtIfExpression): Boolean {
+        val condition = element.getCondition() as? KtBinaryExpression ?: return false
         val thenClause = element.getThen() ?: return false
         val elseClause = element.getElse() ?: return false
 
@@ -38,31 +38,31 @@ public class IfThenToElvisIntention : JetSelfTargetingOffsetIndependentIntention
         if (!expression.isStableVariable()) return false
 
         return when (condition.getOperationToken()) {
-            JetTokens.EQEQ ->
+            KtTokens.EQEQ ->
                 thenClause.isNotNullExpression() && elseClause.evaluatesTo(expression) &&
-                !(thenClause is JetThrowExpression && thenClause.throwsNullPointerExceptionWithNoArguments())
+                !(thenClause is KtThrowExpression && thenClause.throwsNullPointerExceptionWithNoArguments())
 
 
-            JetTokens.EXCLEQ ->
+            KtTokens.EXCLEQ ->
                 elseClause.isNotNullExpression() && thenClause.evaluatesTo(expression) &&
-                !(elseClause is JetThrowExpression && elseClause.throwsNullPointerExceptionWithNoArguments())
+                !(elseClause is KtThrowExpression && elseClause.throwsNullPointerExceptionWithNoArguments())
 
             else -> false
         }
     }
 
-    private fun JetExpression.isNotNullExpression(): Boolean {
+    private fun KtExpression.isNotNullExpression(): Boolean {
         val innerExpression = this.unwrapBlockOrParenthesis()
-        return innerExpression !is JetBlockExpression && innerExpression.getNode().getElementType() != JetNodeTypes.NULL
+        return innerExpression !is KtBlockExpression && innerExpression.getNode().getElementType() != KtNodeTypes.NULL
     }
 
-    override fun applyTo(element: JetIfExpression, editor: Editor) {
+    override fun applyTo(element: KtIfExpression, editor: Editor) {
         val elvis = applyTo(element)
         elvis.inlineLeftSideIfApplicableWithPrompt(editor)
     }
 
-    public fun applyTo(element: JetIfExpression): JetBinaryExpression {
-        val condition = element.getCondition() as JetBinaryExpression
+    public fun applyTo(element: KtIfExpression): KtBinaryExpression {
+        val condition = element.getCondition() as KtBinaryExpression
 
         val thenClause = element.getThen()!!
         val elseClause = element.getElse()!!
@@ -71,12 +71,12 @@ public class IfThenToElvisIntention : JetSelfTargetingOffsetIndependentIntention
 
         val (left, right) =
                 when(condition.getOperationToken()) {
-                    JetTokens.EQEQ -> Pair(elseExpression, thenExpression)
-                    JetTokens.EXCLEQ -> Pair(thenExpression, elseExpression)
+                    KtTokens.EQEQ -> Pair(elseExpression, thenExpression)
+                    KtTokens.EXCLEQ -> Pair(thenExpression, elseExpression)
                     else -> throw IllegalArgumentException()
                 }
 
-        val newExpr = element.replaced(JetPsiFactory(element).createExpressionByPattern("$0 ?: $1", left, right))
-        return JetPsiUtil.deparenthesize(newExpr) as JetBinaryExpression
+        val newExpr = element.replaced(KtPsiFactory(element).createExpressionByPattern("$0 ?: $1", left, right))
+        return KtPsiUtil.deparenthesize(newExpr) as KtBinaryExpression
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfThenToSafeAccessIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfThenToSafeAccessIntention.kt
index 570a7fc7c52..3f81eb2ebb8 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfThenToSafeAccessIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfThenToSafeAccessIntention.kt
@@ -20,16 +20,16 @@ import com.intellij.openapi.editor.Editor
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingOffsetIndependentIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.*
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.idea.core.replaced
 
-public class IfThenToSafeAccessInspection : IntentionBasedInspection<JetIfExpression>(IfThenToSafeAccessIntention())
+public class IfThenToSafeAccessInspection : IntentionBasedInspection<KtIfExpression>(IfThenToSafeAccessIntention())
 
-public class IfThenToSafeAccessIntention : JetSelfTargetingOffsetIndependentIntention<JetIfExpression>(javaClass(), "Replace 'if' expression with safe access expression") {
+public class IfThenToSafeAccessIntention : JetSelfTargetingOffsetIndependentIntention<KtIfExpression>(javaClass(), "Replace 'if' expression with safe access expression") {
 
-    override fun isApplicableTo(element: JetIfExpression): Boolean {
-        val condition = element.getCondition() as? JetBinaryExpression ?: return false
+    override fun isApplicableTo(element: KtIfExpression): Boolean {
+        val condition = element.getCondition() as? KtBinaryExpression ?: return false
         val thenClause = element.getThen()
         val elseClause = element.getElse()
 
@@ -37,11 +37,11 @@ public class IfThenToSafeAccessIntention : JetSelfTargetingOffsetIndependentInte
         if (!receiverExpression.isStableVariable()) return false
 
         return when (condition.getOperationToken()) {
-            JetTokens.EQEQ ->
+            KtTokens.EQEQ ->
                 thenClause?.isNullExpressionOrEmptyBlock() ?: true &&
                 elseClause != null && clauseContainsAppropriateDotQualifiedExpression(elseClause, receiverExpression)
 
-            JetTokens.EXCLEQ ->
+            KtTokens.EXCLEQ ->
                 elseClause?.isNullExpressionOrEmptyBlock() ?: true &&
                 thenClause != null && clauseContainsAppropriateDotQualifiedExpression(thenClause, receiverExpression)
 
@@ -50,33 +50,33 @@ public class IfThenToSafeAccessIntention : JetSelfTargetingOffsetIndependentInte
         }
     }
 
-    override fun applyTo(element: JetIfExpression, editor: Editor) {
+    override fun applyTo(element: KtIfExpression, editor: Editor) {
         val safeAccessExpr = applyTo(element)
         safeAccessExpr.inlineReceiverIfApplicableWithPrompt(editor)
     }
 
-    public fun applyTo(element: JetIfExpression): JetSafeQualifiedExpression {
-        val condition = element.getCondition() as JetBinaryExpression
+    public fun applyTo(element: KtIfExpression): KtSafeQualifiedExpression {
+        val condition = element.getCondition() as KtBinaryExpression
         val receiverExpression = condition.expressionComparedToNull()!!
 
         val selectorExpression =
                 when(condition.getOperationToken()) {
-                    JetTokens.EQEQ -> findSelectorExpressionInClause(element.getElse()!!, receiverExpression)!!
+                    KtTokens.EQEQ -> findSelectorExpressionInClause(element.getElse()!!, receiverExpression)!!
 
-                    JetTokens.EXCLEQ -> findSelectorExpressionInClause(element.getThen()!!, receiverExpression)!!
+                    KtTokens.EXCLEQ -> findSelectorExpressionInClause(element.getThen()!!, receiverExpression)!!
 
                     else -> throw IllegalArgumentException()
                 }
 
-        val newExpr = JetPsiFactory(element).createExpressionByPattern("$0?.$1", receiverExpression, selectorExpression) as JetSafeQualifiedExpression
+        val newExpr = KtPsiFactory(element).createExpressionByPattern("$0?.$1", receiverExpression, selectorExpression) as KtSafeQualifiedExpression
         return element.replaced(newExpr)
     }
 
-    private fun clauseContainsAppropriateDotQualifiedExpression(clause: JetExpression, receiverExpression: JetExpression)
+    private fun clauseContainsAppropriateDotQualifiedExpression(clause: KtExpression, receiverExpression: KtExpression)
             = findSelectorExpressionInClause(clause, receiverExpression) != null
 
-    private fun findSelectorExpressionInClause(clause: JetExpression, receiverExpression: JetExpression): JetExpression? {
-        val expression = clause.unwrapBlockOrParenthesis() as? JetDotQualifiedExpression ?: return null
+    private fun findSelectorExpressionInClause(clause: KtExpression, receiverExpression: KtExpression): KtExpression? {
+        val expression = clause.unwrapBlockOrParenthesis() as? KtDotQualifiedExpression ?: return null
 
         if (expression.getReceiverExpression().getText() != receiverExpression.getText()) return null
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfToWhenIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfToWhenIntention.kt
index 3900ce6942c..5a17098d6f0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfToWhenIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IfToWhenIntention.kt
@@ -21,24 +21,24 @@ import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.getSubjectToIntroduce
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.introduceSubject
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import java.util.ArrayList
 
-public class IfToWhenIntention : JetSelfTargetingRangeIntention<JetIfExpression>(javaClass(), "Replace 'if' with 'when'") {
-    override fun applicabilityRange(element: JetIfExpression): TextRange? {
+public class IfToWhenIntention : JetSelfTargetingRangeIntention<KtIfExpression>(javaClass(), "Replace 'if' with 'when'") {
+    override fun applicabilityRange(element: KtIfExpression): TextRange? {
         if (element.getThen() == null) return null
         return element.getIfKeyword().getTextRange()
     }
 
-    override fun applyTo(element: JetIfExpression, editor: Editor) {
-        var whenExpression = JetPsiFactory(element).buildExpression {
+    override fun applyTo(element: KtIfExpression, editor: Editor) {
+        var whenExpression = KtPsiFactory(element).buildExpression {
             appendFixedText("when {\n")
 
             var ifExpression = element
             while (true) {
                 val condition = ifExpression.getCondition()
-                val orBranches = ArrayList<JetExpression>()
+                val orBranches = ArrayList<KtExpression>()
                 if (condition != null) {
                     orBranches.addOrBranches(condition)
                 }
@@ -54,7 +54,7 @@ public class IfToWhenIntention : JetSelfTargetingRangeIntention<JetIfExpression>
                 appendFixedText("\n")
 
                 val elseBranch = ifExpression.getElse() ?: break
-                if (elseBranch is JetIfExpression) {
+                if (elseBranch is KtIfExpression) {
                     ifExpression = elseBranch
                 }
                 else {
@@ -66,7 +66,7 @@ public class IfToWhenIntention : JetSelfTargetingRangeIntention<JetIfExpression>
             }
 
             appendFixedText("}")
-        } as JetWhenExpression
+        } as KtWhenExpression
 
 
         if (whenExpression.getSubjectToIntroduce() != null) {
@@ -76,8 +76,8 @@ public class IfToWhenIntention : JetSelfTargetingRangeIntention<JetIfExpression>
         element.replace(whenExpression)
     }
 
-    private fun MutableList<JetExpression>.addOrBranches(expression: JetExpression): List<JetExpression> {
-        if (expression is JetBinaryExpression && expression.getOperationToken() == JetTokens.OROR) {
+    private fun MutableList<KtExpression>.addOrBranches(expression: KtExpression): List<KtExpression> {
+        if (expression is KtBinaryExpression && expression.getOperationToken() == KtTokens.OROR) {
             val left = expression.getLeft()
             val right = expression.getRight()
             if (left != null && right != null) {
@@ -87,7 +87,7 @@ public class IfToWhenIntention : JetSelfTargetingRangeIntention<JetIfExpression>
             }
         }
 
-        add(JetPsiUtil.safeDeparenthesize(expression))
+        add(KtPsiUtil.safeDeparenthesize(expression))
         return this
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IntroduceWhenSubjectIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IntroduceWhenSubjectIntention.kt
index 6744f821b93..bfde9de5c4d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IntroduceWhenSubjectIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/IntroduceWhenSubjectIntention.kt
@@ -22,18 +22,18 @@ import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.getSubjectToIntroduce
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.introduceSubject
-import org.jetbrains.kotlin.psi.JetWhenExpression
+import org.jetbrains.kotlin.psi.KtWhenExpression
 
-public class IntroduceWhenSubjectInspection : IntentionBasedInspection<JetWhenExpression>(IntroduceWhenSubjectIntention())
+public class IntroduceWhenSubjectInspection : IntentionBasedInspection<KtWhenExpression>(IntroduceWhenSubjectIntention())
 
-public class IntroduceWhenSubjectIntention : JetSelfTargetingRangeIntention<JetWhenExpression>(javaClass(), "Introduce argument to 'when'") {
-    override fun applicabilityRange(element: JetWhenExpression): TextRange? {
+public class IntroduceWhenSubjectIntention : JetSelfTargetingRangeIntention<KtWhenExpression>(javaClass(), "Introduce argument to 'when'") {
+    override fun applicabilityRange(element: KtWhenExpression): TextRange? {
         val subject = element.getSubjectToIntroduce() ?: return null
         setText("Introduce '${subject.getText()}' as argument to 'when'")
         return element.getWhenKeyword().getTextRange()
     }
 
-    override fun applyTo(element: JetWhenExpression, editor: Editor) {
+    override fun applyTo(element: KtWhenExpression, editor: Editor) {
         element.introduceSubject()
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/MergeWhenIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/MergeWhenIntention.kt
index 37d02ede140..7e9111dcc4b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/MergeWhenIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/MergeWhenIntention.kt
@@ -29,9 +29,9 @@ import org.jetbrains.kotlin.idea.util.psi.patternMatching.toRange
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.*
 
-public class MergeWhenIntention : JetSelfTargetingRangeIntention<JetWhenExpression>(javaClass(), "Merge with next 'when'", "Merge 'when' expressions") {
-    override fun applicabilityRange(element: JetWhenExpression): TextRange? {
-        val next = PsiTreeUtil.skipSiblingsForward(element, javaClass<PsiWhiteSpace>()) as? JetWhenExpression ?: return null
+public class MergeWhenIntention : JetSelfTargetingRangeIntention<KtWhenExpression>(javaClass(), "Merge with next 'when'", "Merge 'when' expressions") {
+    override fun applicabilityRange(element: KtWhenExpression): TextRange? {
+        val next = PsiTreeUtil.skipSiblingsForward(element, javaClass<PsiWhiteSpace>()) as? KtWhenExpression ?: return null
 
         val subject1 = element.getSubjectExpression()
         val subject2 = next.getSubjectExpression()
@@ -48,28 +48,28 @@ public class MergeWhenIntention : JetSelfTargetingRangeIntention<JetWhenExpressi
         return element.getWhenKeyword().getTextRange()
     }
 
-    private fun conditionsMatch(e1: JetWhenEntry, e2: JetWhenEntry): Boolean =
+    private fun conditionsMatch(e1: KtWhenEntry, e2: KtWhenEntry): Boolean =
             e1.getConditions().toList().toRange().matches(e2.getConditions().toList().toRange())
 
-    private fun checkBodies(e1: JetWhenEntry, e2: JetWhenEntry): Boolean {
+    private fun checkBodies(e1: KtWhenEntry, e2: KtWhenEntry): Boolean {
         val names1 = e1.declarationNames()
         val names2 = e2.declarationNames()
         if (names1.any { it in names2 }) return false
 
         return when (e1.getExpression()?.lastBlockStatementOrThis()) {
-            is JetReturnExpression, is JetThrowExpression, is JetBreakExpression, is JetContinueExpression -> false
+            is KtReturnExpression, is KtThrowExpression, is KtBreakExpression, is KtContinueExpression -> false
             else -> true
         }
     }
 
-    private fun JetWhenEntry.declarationNames(): Set<String> =
+    private fun KtWhenEntry.declarationNames(): Set<String> =
             getExpression()?.blockExpressionsOrSingle()
-                    ?.filter { it is JetNamedDeclaration }
+                    ?.filter { it is KtNamedDeclaration }
                     ?.map { it.getName() }
                     ?.filterNotNull()?.toSet() ?: emptySet()
 
-    override fun applyTo(element: JetWhenExpression, editor: Editor) {
-        val nextWhen = PsiTreeUtil.skipSiblingsForward(element, javaClass<PsiWhiteSpace>()) as JetWhenExpression
+    override fun applyTo(element: KtWhenExpression, editor: Editor) {
+        val nextWhen = PsiTreeUtil.skipSiblingsForward(element, javaClass<PsiWhiteSpace>()) as KtWhenExpression
         for ((entry1, entry2) in element.getEntries().zip(nextWhen.getEntries())) {
             entry1.getExpression().mergeWith(entry2.getExpression())
         }
@@ -77,14 +77,14 @@ public class MergeWhenIntention : JetSelfTargetingRangeIntention<JetWhenExpressi
         element.getParent().deleteChildRange(element.getNextSibling(), nextWhen)
     }
 
-    private fun JetExpression?.mergeWith(that: JetExpression?): JetExpression? = when {
+    private fun KtExpression?.mergeWith(that: KtExpression?): KtExpression? = when {
         this == null -> that
 
         that == null -> this
 
         else -> {
-            val psiFactory = JetPsiFactory(this)
-            val block = if (this is JetBlockExpression)
+            val psiFactory = KtPsiFactory(this)
+            val block = if (this is KtBlockExpression)
                 this
             else
                 replaced(psiFactory.createSingleStatementBlock(this))
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/SafeAccessToIfThenIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/SafeAccessToIfThenIntention.kt
index 4ca847f4341..a85ed522ad9 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/SafeAccessToIfThenIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/SafeAccessToIfThenIntention.kt
@@ -27,26 +27,26 @@ import org.jetbrains.kotlin.idea.intentions.branchedTransformations.isStableVari
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.bindingContextUtil.isUsedAsStatement
 
-public class SafeAccessToIfThenIntention : JetSelfTargetingRangeIntention<JetSafeQualifiedExpression>(javaClass(), "Replace safe access expression with 'if' expression"), LowPriorityAction {
-    override fun applicabilityRange(element: JetSafeQualifiedExpression): TextRange? {
+public class SafeAccessToIfThenIntention : JetSelfTargetingRangeIntention<KtSafeQualifiedExpression>(javaClass(), "Replace safe access expression with 'if' expression"), LowPriorityAction {
+    override fun applicabilityRange(element: KtSafeQualifiedExpression): TextRange? {
         if (element.getSelectorExpression() == null) return null
         return element.getOperationTokenNode().getTextRange()
     }
 
-    override fun applyTo(element: JetSafeQualifiedExpression, editor: Editor) {
-        val receiver = JetPsiUtil.safeDeparenthesize(element.getReceiverExpression())
+    override fun applyTo(element: KtSafeQualifiedExpression, editor: Editor) {
+        val receiver = KtPsiUtil.safeDeparenthesize(element.getReceiverExpression())
         val selector = element.getSelectorExpression()!!
 
         val receiverIsStable = receiver.isStableVariable()
 
-        val psiFactory = JetPsiFactory(element)
+        val psiFactory = KtPsiFactory(element)
         val dotQualified = psiFactory.createExpressionByPattern("$0.$1", receiver, selector)
 
         val elseClause = if (element.isUsedAsStatement(element.analyze())) null else psiFactory.createExpression("null")
         val ifExpression = element.convertToIfNotNullExpression(receiver, dotQualified, elseClause)
 
         if (!receiverIsStable) {
-            val valueToExtract = (ifExpression.getThen() as JetDotQualifiedExpression).getReceiverExpression()
+            val valueToExtract = (ifExpression.getThen() as KtDotQualifiedExpression).getReceiverExpression()
             ifExpression.introduceValueForCondition(valueToExtract, editor)
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldAssignmentToIfIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldAssignmentToIfIntention.kt
index daa77aff46e..08d08ed0171 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldAssignmentToIfIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldAssignmentToIfIntention.kt
@@ -21,21 +21,21 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.BranchedUnfoldingUtils
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetIfExpression
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtIfExpression
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
-public class UnfoldAssignmentToIfIntention : JetSelfTargetingRangeIntention<JetBinaryExpression>(javaClass(), "Replace assignment with 'if' expression"), LowPriorityAction {
-    override fun applicabilityRange(element: JetBinaryExpression): TextRange? {
-        if (element.getOperationToken() !in JetTokens.ALL_ASSIGNMENTS) return null
+public class UnfoldAssignmentToIfIntention : JetSelfTargetingRangeIntention<KtBinaryExpression>(javaClass(), "Replace assignment with 'if' expression"), LowPriorityAction {
+    override fun applicabilityRange(element: KtBinaryExpression): TextRange? {
+        if (element.getOperationToken() !in KtTokens.ALL_ASSIGNMENTS) return null
         if (element.getLeft() == null) return null
-        val right = element.getRight() as? JetIfExpression ?: return null
+        val right = element.getRight() as? KtIfExpression ?: return null
         return TextRange(element.startOffset, right.getIfKeyword().endOffset)
     }
 
-    override fun applyTo(element: JetBinaryExpression, editor: Editor) {
+    override fun applyTo(element: KtBinaryExpression, editor: Editor) {
         BranchedUnfoldingUtils.unfoldAssignmentToIf(element, editor)
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldAssignmentToWhenIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldAssignmentToWhenIntention.kt
index 6caff2503c5..b983e6a90b3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldAssignmentToWhenIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldAssignmentToWhenIntention.kt
@@ -21,24 +21,24 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.BranchedUnfoldingUtils
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetPsiUtil
-import org.jetbrains.kotlin.psi.JetWhenExpression
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtPsiUtil
+import org.jetbrains.kotlin.psi.KtWhenExpression
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
-public class UnfoldAssignmentToWhenIntention : JetSelfTargetingRangeIntention<JetBinaryExpression>(javaClass(), "Replace assignment with 'when' expression" ), LowPriorityAction {
-    override fun applicabilityRange(element: JetBinaryExpression): TextRange? {
-        if (element.getOperationToken() !in JetTokens.ALL_ASSIGNMENTS) return null
+public class UnfoldAssignmentToWhenIntention : JetSelfTargetingRangeIntention<KtBinaryExpression>(javaClass(), "Replace assignment with 'when' expression" ), LowPriorityAction {
+    override fun applicabilityRange(element: KtBinaryExpression): TextRange? {
+        if (element.getOperationToken() !in KtTokens.ALL_ASSIGNMENTS) return null
         if (element.getLeft() == null) return null
-        val right = element.getRight() as? JetWhenExpression ?: return null
-        if (!JetPsiUtil.checkWhenExpressionHasSingleElse(right)) return null
+        val right = element.getRight() as? KtWhenExpression ?: return null
+        if (!KtPsiUtil.checkWhenExpressionHasSingleElse(right)) return null
         if (right.getEntries().any { it.getExpression() == null }) return null
         return TextRange(element.startOffset, right.getWhenKeyword().endOffset)
     }
 
-    override fun applyTo(element: JetBinaryExpression, editor: Editor) {
+    override fun applyTo(element: KtBinaryExpression, editor: Editor) {
         BranchedUnfoldingUtils.unfoldAssignmentToWhen(element, editor)
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldPropertyToIfIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldPropertyToIfIntention.kt
index 70f57ee6d03..9bb1f6d2585 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldPropertyToIfIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldPropertyToIfIntention.kt
@@ -22,19 +22,19 @@ import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.BranchedUnfoldingUtils
 import org.jetbrains.kotlin.idea.intentions.splitPropertyDeclaration
-import org.jetbrains.kotlin.psi.JetIfExpression
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtIfExpression
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
-public class UnfoldPropertyToIfIntention : JetSelfTargetingRangeIntention<JetProperty>(javaClass(), "Replace property initializer with 'if' expression"), LowPriorityAction {
-    override fun applicabilityRange(element: JetProperty): TextRange? {
+public class UnfoldPropertyToIfIntention : JetSelfTargetingRangeIntention<KtProperty>(javaClass(), "Replace property initializer with 'if' expression"), LowPriorityAction {
+    override fun applicabilityRange(element: KtProperty): TextRange? {
         if (!element.isLocal()) return null
-        val initializer = element.getInitializer() as? JetIfExpression ?: return null
+        val initializer = element.getInitializer() as? KtIfExpression ?: return null
         return TextRange(element.startOffset, initializer.getIfKeyword().endOffset)
     }
 
-    override fun applyTo(element: JetProperty, editor: Editor) {
+    override fun applyTo(element: KtProperty, editor: Editor) {
         val assignment = splitPropertyDeclaration(element)
         BranchedUnfoldingUtils.unfoldAssignmentToIf(assignment, editor)
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldPropertyToWhenIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldPropertyToWhenIntention.kt
index a93c5e81ca2..c57f5260be4 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldPropertyToWhenIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldPropertyToWhenIntention.kt
@@ -22,22 +22,22 @@ import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.BranchedUnfoldingUtils
 import org.jetbrains.kotlin.idea.intentions.splitPropertyDeclaration
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetPsiUtil
-import org.jetbrains.kotlin.psi.JetWhenExpression
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtPsiUtil
+import org.jetbrains.kotlin.psi.KtWhenExpression
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
-public class UnfoldPropertyToWhenIntention : JetSelfTargetingRangeIntention<JetProperty>(javaClass(), "Replace property initializer with 'when' expression"), LowPriorityAction {
-    override fun applicabilityRange(element: JetProperty): TextRange? {
+public class UnfoldPropertyToWhenIntention : JetSelfTargetingRangeIntention<KtProperty>(javaClass(), "Replace property initializer with 'when' expression"), LowPriorityAction {
+    override fun applicabilityRange(element: KtProperty): TextRange? {
         if (!element.isLocal()) return null
-        val initializer = element.getInitializer() as? JetWhenExpression ?: return null
-        if (!JetPsiUtil.checkWhenExpressionHasSingleElse(initializer)) return null
+        val initializer = element.getInitializer() as? KtWhenExpression ?: return null
+        if (!KtPsiUtil.checkWhenExpressionHasSingleElse(initializer)) return null
         if (initializer.getEntries().any { it.getExpression() == null }) return null
         return TextRange(element.startOffset, initializer.getWhenKeyword().endOffset)
     }
 
-    override fun applyTo(element: JetProperty, editor: Editor) {
+    override fun applyTo(element: KtProperty, editor: Editor) {
         val assignment = splitPropertyDeclaration(element)
         BranchedUnfoldingUtils.unfoldAssignmentToWhen(assignment, editor)
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldReturnToIfIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldReturnToIfIntention.kt
index 64c1c8d3a5b..d7e05c0e165 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldReturnToIfIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldReturnToIfIntention.kt
@@ -21,27 +21,27 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.core.copied
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
-import org.jetbrains.kotlin.psi.JetIfExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetReturnExpression
+import org.jetbrains.kotlin.psi.KtIfExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtReturnExpression
 import org.jetbrains.kotlin.psi.createExpressionByPattern
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.lastBlockStatementOrThis
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
-public class UnfoldReturnToIfIntention : JetSelfTargetingRangeIntention<JetReturnExpression>(javaClass(), "Replace return with 'if' expression"), LowPriorityAction {
-    override fun applicabilityRange(element: JetReturnExpression): TextRange? {
-        val ifExpression = element.getReturnedExpression() as? JetIfExpression ?: return null
+public class UnfoldReturnToIfIntention : JetSelfTargetingRangeIntention<KtReturnExpression>(javaClass(), "Replace return with 'if' expression"), LowPriorityAction {
+    override fun applicabilityRange(element: KtReturnExpression): TextRange? {
+        val ifExpression = element.getReturnedExpression() as? KtIfExpression ?: return null
         return TextRange(element.startOffset, ifExpression.getIfKeyword().endOffset)
     }
 
-    override fun applyTo(element: JetReturnExpression, editor: Editor) {
-        val ifExpression = element.getReturnedExpression() as JetIfExpression
+    override fun applyTo(element: KtReturnExpression, editor: Editor) {
+        val ifExpression = element.getReturnedExpression() as KtIfExpression
         val newIfExpression = ifExpression.copied()
         val thenExpr = newIfExpression.getThen()!!.lastBlockStatementOrThis()
         val elseExpr = newIfExpression.getElse()!!.lastBlockStatementOrThis()
 
-        val psiFactory = JetPsiFactory(element)
+        val psiFactory = KtPsiFactory(element)
         thenExpr.replace(psiFactory.createExpressionByPattern("return $0", thenExpr))
         elseExpr.replace(psiFactory.createExpressionByPattern("return $0", elseExpr))
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldReturnToWhenIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldReturnToWhenIntention.kt
index d7d5f50f7dd..beac0a1a543 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldReturnToWhenIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldReturnToWhenIntention.kt
@@ -26,21 +26,21 @@ import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.lastBlockStatementOrThis
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
-public class UnfoldReturnToWhenIntention : JetSelfTargetingRangeIntention<JetReturnExpression>(javaClass(), "Replace return with 'when' expression"), LowPriorityAction {
-    override fun applicabilityRange(element: JetReturnExpression): TextRange? {
-        val whenExpr = element.getReturnedExpression() as? JetWhenExpression ?: return null
-        if (!JetPsiUtil.checkWhenExpressionHasSingleElse(whenExpr)) return null
+public class UnfoldReturnToWhenIntention : JetSelfTargetingRangeIntention<KtReturnExpression>(javaClass(), "Replace return with 'when' expression"), LowPriorityAction {
+    override fun applicabilityRange(element: KtReturnExpression): TextRange? {
+        val whenExpr = element.getReturnedExpression() as? KtWhenExpression ?: return null
+        if (!KtPsiUtil.checkWhenExpressionHasSingleElse(whenExpr)) return null
         if (whenExpr.getEntries().any { it.getExpression() == null }) return null
         return TextRange(element.startOffset, whenExpr.getWhenKeyword().endOffset)
     }
 
-    override fun applyTo(element: JetReturnExpression, editor: Editor) {
-        val whenExpression = element.getReturnedExpression() as JetWhenExpression
+    override fun applyTo(element: KtReturnExpression, editor: Editor) {
+        val whenExpression = element.getReturnedExpression() as KtWhenExpression
         val newWhenExpression = whenExpression.copied()
 
         for (entry in newWhenExpression.getEntries()) {
             val expr = entry.getExpression()!!.lastBlockStatementOrThis()
-            expr.replace(JetPsiFactory(element).createExpressionByPattern("return $0", expr))
+            expr.replace(KtPsiFactory(element).createExpressionByPattern("return $0", expr))
         }
 
         element.replace(newWhenExpression)
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/WhenToIfIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/WhenToIfIntention.kt
index c3ddbd4464a..b6ed8fbede6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/WhenToIfIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/WhenToIfIntention.kt
@@ -23,8 +23,8 @@ import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.toExpression
 import org.jetbrains.kotlin.psi.*
 
-public class WhenToIfIntention : JetSelfTargetingRangeIntention<JetWhenExpression>(javaClass(), "Replace 'when' with 'if'"), LowPriorityAction {
-    override fun applicabilityRange(element: JetWhenExpression): TextRange? {
+public class WhenToIfIntention : JetSelfTargetingRangeIntention<KtWhenExpression>(javaClass(), "Replace 'when' with 'if'"), LowPriorityAction {
+    override fun applicabilityRange(element: KtWhenExpression): TextRange? {
         val entries = element.getEntries()
         if (entries.isEmpty()) return null
         val lastEntry = entries.last()
@@ -32,8 +32,8 @@ public class WhenToIfIntention : JetSelfTargetingRangeIntention<JetWhenExpressio
         return element.getWhenKeyword().getTextRange()
     }
 
-    override fun applyTo(element: JetWhenExpression, editor: Editor) {
-        val factory = JetPsiFactory(element)
+    override fun applyTo(element: KtWhenExpression, editor: Editor) {
+        val factory = KtPsiFactory(element)
         val ifExpression = factory.buildExpression {
             val entries = element.getEntries()
             for ((i, entry) in entries.withIndex()) {
@@ -60,7 +60,7 @@ public class WhenToIfIntention : JetSelfTargetingRangeIntention<JetWhenExpressio
         element.replace(ifExpression)
     }
 
-    private fun JetPsiFactory.combineWhenConditions(conditions: Array<JetWhenCondition>, subject: JetExpression?): JetExpression? {
+    private fun KtPsiFactory.combineWhenConditions(conditions: Array<KtWhenCondition>, subject: KtExpression?): KtExpression? {
         when (conditions.size()) {
             0 -> return null
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceCallWithBinaryOperatorIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceCallWithBinaryOperatorIntention.kt
index 7726dd1a46d..3aef7dd9a91 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceCallWithBinaryOperatorIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceCallWithBinaryOperatorIntention.kt
@@ -21,15 +21,15 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.intentions.*
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetDotQualifiedExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtDotQualifiedExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.createExpressionByPattern
 import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch
 import org.jetbrains.kotlin.resolve.calls.model.isReallySuccess
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 
-public class ReplaceCallWithBinaryOperatorIntention : JetSelfTargetingRangeIntention<JetDotQualifiedExpression>(javaClass(), "Replace call with binary operator"), HighPriorityAction {
-    override fun applicabilityRange(element: JetDotQualifiedExpression): TextRange? {
+public class ReplaceCallWithBinaryOperatorIntention : JetSelfTargetingRangeIntention<KtDotQualifiedExpression>(javaClass(), "Replace call with binary operator"), HighPriorityAction {
+    override fun applicabilityRange(element: KtDotQualifiedExpression): TextRange? {
         val operation = operation(element.calleeName) ?: return null
 
         val resolvedCall = element.toResolvedCall() ?: return null
@@ -44,12 +44,12 @@ public class ReplaceCallWithBinaryOperatorIntention : JetSelfTargetingRangeInten
         return element.callExpression!!.getCalleeExpression()!!.getTextRange()
     }
 
-    override fun applyTo(element: JetDotQualifiedExpression, editor: Editor) {
+    override fun applyTo(element: KtDotQualifiedExpression, editor: Editor) {
         val operation = operation(element.calleeName)!!
         val argument = element.callExpression!!.getValueArguments().single().getArgumentExpression()!!
         val receiver = element.getReceiverExpression()
 
-        element.replace(JetPsiFactory(element).createExpressionByPattern("$0 $operation $1", receiver, argument))
+        element.replace(KtPsiFactory(element).createExpressionByPattern("$0 $operation $1", receiver, argument))
     }
 
     private fun operation(functionName: String?): String? {
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceCallWithUnaryOperatorIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceCallWithUnaryOperatorIntention.kt
index 641f38cc5e7..7dfbae4174a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceCallWithUnaryOperatorIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceCallWithUnaryOperatorIntention.kt
@@ -24,13 +24,13 @@ import org.jetbrains.kotlin.idea.intentions.callExpression
 import org.jetbrains.kotlin.idea.intentions.calleeName
 import org.jetbrains.kotlin.idea.intentions.isReceiverExpressionWithValue
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetDotQualifiedExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtDotQualifiedExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.createExpressionByPattern
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 
-public class ReplaceCallWithUnaryOperatorIntention : JetSelfTargetingRangeIntention<JetDotQualifiedExpression>(javaClass(), "Replace call with unary operator"), HighPriorityAction {
-    override fun applicabilityRange(element: JetDotQualifiedExpression): TextRange? {
+public class ReplaceCallWithUnaryOperatorIntention : JetSelfTargetingRangeIntention<KtDotQualifiedExpression>(javaClass(), "Replace call with unary operator"), HighPriorityAction {
+    override fun applicabilityRange(element: KtDotQualifiedExpression): TextRange? {
         val operation = operation(element.calleeName) ?: return null
 
         val call = element.callExpression ?: return null
@@ -43,10 +43,10 @@ public class ReplaceCallWithUnaryOperatorIntention : JetSelfTargetingRangeIntent
         return call.getCalleeExpression()!!.getTextRange()
     }
 
-    override fun applyTo(element: JetDotQualifiedExpression, editor: Editor) {
+    override fun applyTo(element: KtDotQualifiedExpression, editor: Editor) {
         val operation = operation(element.calleeName)!!
         val receiver = element.getReceiverExpression()
-        element.replace(JetPsiFactory(element).createExpressionByPattern("$0$1", operation, receiver))
+        element.replace(KtPsiFactory(element).createExpressionByPattern("$0$1", operation, receiver))
     }
 
     private fun operation(functionName: String?) : String? {
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceContainsIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceContainsIntention.kt
index 1f7c6f4b06a..e6d24f9309b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceContainsIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceContainsIntention.kt
@@ -20,15 +20,15 @@ import com.intellij.codeInsight.intention.HighPriorityAction
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.intentions.*
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch
 import org.jetbrains.kotlin.resolve.calls.model.isReallySuccess
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
-public class ReplaceContainsIntention : JetSelfTargetingRangeIntention<JetDotQualifiedExpression>(javaClass(), "Replace 'contains' call with 'in' operator"), HighPriorityAction {
-    override fun applicabilityRange(element: JetDotQualifiedExpression): TextRange? {
+public class ReplaceContainsIntention : JetSelfTargetingRangeIntention<KtDotQualifiedExpression>(javaClass(), "Replace 'contains' call with 'in' operator"), HighPriorityAction {
+    override fun applicabilityRange(element: KtDotQualifiedExpression): TextRange? {
         if (element.calleeName != OperatorNameConventions.CONTAINS.asString()) return null
 
         val resolvedCall = element.toResolvedCall() ?: return null
@@ -45,14 +45,14 @@ public class ReplaceContainsIntention : JetSelfTargetingRangeIntention<JetDotQua
         return element.callExpression!!.getCalleeExpression()!!.getTextRange()
     }
 
-    override fun applyTo(element: JetDotQualifiedExpression, editor: Editor) {
+    override fun applyTo(element: KtDotQualifiedExpression, editor: Editor) {
         val argument = element.callExpression!!.getValueArguments().single().getArgumentExpression()!!
         val receiver = element.getReceiverExpression()
 
-        val psiFactory = JetPsiFactory(element)
+        val psiFactory = KtPsiFactory(element)
 
-        val prefixExpression = element.getParent() as? JetPrefixExpression
-        val expression = if (prefixExpression != null && prefixExpression.getOperationToken() == JetTokens.EXCL) {
+        val prefixExpression = element.getParent() as? KtPrefixExpression
+        val expression = if (prefixExpression != null && prefixExpression.getOperationToken() == KtTokens.EXCL) {
             prefixExpression.replace(psiFactory.createExpressionByPattern("$0 !in $1", argument, receiver))
         }
         else {
@@ -60,11 +60,11 @@ public class ReplaceContainsIntention : JetSelfTargetingRangeIntention<JetDotQua
         }
 
         // Append semicolon to previous statement if needed
-        if (argument is JetFunctionLiteralExpression) {
-            val previousElement = JetPsiUtil.skipSiblingsBackwardByPredicate(expression) {
-                it.getNode().getElementType() in JetTokens.WHITE_SPACE_OR_COMMENT_BIT_SET
+        if (argument is KtFunctionLiteralExpression) {
+            val previousElement = KtPsiUtil.skipSiblingsBackwardByPredicate(expression) {
+                it.getNode().getElementType() in KtTokens.WHITE_SPACE_OR_COMMENT_BIT_SET
             }
-            if (previousElement != null && previousElement is JetExpression) {
+            if (previousElement != null && previousElement is KtExpression) {
                 previousElement.getParent()!!.addAfter(psiFactory.createSemicolon(), previousElement)
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceGetIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceGetIntention.kt
index fc650402d39..61880c43701 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceGetIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceGetIntention.kt
@@ -26,17 +26,17 @@ import org.jetbrains.kotlin.idea.intentions.callExpression
 import org.jetbrains.kotlin.idea.intentions.isReceiverExpressionWithValue
 import org.jetbrains.kotlin.idea.intentions.toResolvedCall
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
-import org.jetbrains.kotlin.psi.JetDotQualifiedExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtDotQualifiedExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.buildExpression
 import org.jetbrains.kotlin.resolve.calls.model.isReallySuccess
 
-public class ExplicitGetInspection : IntentionBasedInspection<JetDotQualifiedExpression>(
+public class ExplicitGetInspection : IntentionBasedInspection<KtDotQualifiedExpression>(
         ReplaceGetIntention(), ExplicitGetInspection.additionalChecker
 
 ) {
     companion object {
-        val additionalChecker = { expression: JetDotQualifiedExpression ->
+        val additionalChecker = { expression: KtDotQualifiedExpression ->
             (expression.toResolvedCall()!!.resultingDescriptor as FunctionDescriptor).isExplicitOperator()
         }
     }
@@ -49,8 +49,8 @@ private fun FunctionDescriptor.isExplicitOperator(): Boolean {
         overriddenDescriptors.any { it.isExplicitOperator() }
 }
 
-public class ReplaceGetIntention : JetSelfTargetingRangeIntention<JetDotQualifiedExpression>(javaClass(), "Replace 'get' call with index operator"), HighPriorityAction {
-    override fun applicabilityRange(element: JetDotQualifiedExpression): TextRange? {
+public class ReplaceGetIntention : JetSelfTargetingRangeIntention<KtDotQualifiedExpression>(javaClass(), "Replace 'get' call with index operator"), HighPriorityAction {
+    override fun applicabilityRange(element: KtDotQualifiedExpression): TextRange? {
         val resolvedCall = element.toResolvedCall() ?: return null
         if (!resolvedCall.isReallySuccess()) return null
         val target = resolvedCall.resultingDescriptor as? FunctionDescriptor ?: return null
@@ -68,12 +68,12 @@ public class ReplaceGetIntention : JetSelfTargetingRangeIntention<JetDotQualifie
         return call.getCalleeExpression()!!.getTextRange()
     }
 
-    override fun applyTo(element: JetDotQualifiedExpression, editor: Editor) {
+    override fun applyTo(element: KtDotQualifiedExpression, editor: Editor) {
         applyTo(element)
     }
 
-    fun applyTo(element: JetDotQualifiedExpression) {
-        val expression = JetPsiFactory(element).buildExpression {
+    fun applyTo(element: KtDotQualifiedExpression) {
+        val expression = KtPsiFactory(element).buildExpression {
             appendExpression(element.getReceiverExpression())
 
             appendFixedText("[")
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceInvokeIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceInvokeIntention.kt
index ce1c0917162..916c0711e8e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceInvokeIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceInvokeIntention.kt
@@ -22,19 +22,19 @@ import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.callExpression
 import org.jetbrains.kotlin.idea.intentions.calleeName
-import org.jetbrains.kotlin.psi.JetCallExpression
-import org.jetbrains.kotlin.psi.JetDotQualifiedExpression
+import org.jetbrains.kotlin.psi.KtCallExpression
+import org.jetbrains.kotlin.psi.KtDotQualifiedExpression
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
-public class ReplaceInvokeIntention : JetSelfTargetingRangeIntention<JetDotQualifiedExpression>(javaClass(), "Replace 'invoke' with direct call"), HighPriorityAction {
-    override fun applicabilityRange(element: JetDotQualifiedExpression): TextRange? {
+public class ReplaceInvokeIntention : JetSelfTargetingRangeIntention<KtDotQualifiedExpression>(javaClass(), "Replace 'invoke' with direct call"), HighPriorityAction {
+    override fun applicabilityRange(element: KtDotQualifiedExpression): TextRange? {
         if (element.calleeName != OperatorNameConventions.INVOKE.asString()) return null
         return element.callExpression!!.getCalleeExpression()!!.getTextRange()
     }
 
-    override fun applyTo(element: JetDotQualifiedExpression, editor: Editor) {
+    override fun applyTo(element: KtDotQualifiedExpression, editor: Editor) {
         val receiver = element.getReceiverExpression()
-        val callExpression = element.callExpression!!.copy() as JetCallExpression
+        val callExpression = element.callExpression!!.copy() as KtCallExpression
         callExpression.getCalleeExpression()!!.replace(receiver)
         element.replace(callExpression)
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/declarations/ConvertMemberToExtensionIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/declarations/ConvertMemberToExtensionIntention.kt
index 83f1f4ab6ef..f3dac4dfa47 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/declarations/ConvertMemberToExtensionIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/declarations/ConvertMemberToExtensionIntention.kt
@@ -26,37 +26,37 @@ import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.setReceiverType
 import org.jetbrains.kotlin.idea.quickfix.moveCaret
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 
-public class ConvertMemberToExtensionIntention : JetSelfTargetingRangeIntention<JetCallableDeclaration>(javaClass(), "Convert member to extension"), LowPriorityAction {
-    override fun applicabilityRange(element: JetCallableDeclaration): TextRange? {
-        val classBody = element.getParent() as? JetClassBody ?: return null
-        if (classBody.getParent() !is JetClass) return null
+public class ConvertMemberToExtensionIntention : JetSelfTargetingRangeIntention<KtCallableDeclaration>(javaClass(), "Convert member to extension"), LowPriorityAction {
+    override fun applicabilityRange(element: KtCallableDeclaration): TextRange? {
+        val classBody = element.getParent() as? KtClassBody ?: return null
+        if (classBody.getParent() !is KtClass) return null
         if (element.getReceiverTypeReference() != null) return null
-        if (element.hasModifier(JetTokens.OVERRIDE_KEYWORD)) return null
+        if (element.hasModifier(KtTokens.OVERRIDE_KEYWORD)) return null
         when (element) {
-            is JetProperty -> if (element.hasInitializer()) return null
-            is JetSecondaryConstructor -> return null
+            is KtProperty -> if (element.hasInitializer()) return null
+            is KtSecondaryConstructor -> return null
         }
         return (element.getNameIdentifier() ?: return null).getTextRange()
     }
 
     //TODO: local class
 
-    override fun applyTo(element: JetCallableDeclaration, editor: Editor) {
+    override fun applyTo(element: KtCallableDeclaration, editor: Editor) {
         val descriptor = element.resolveToDescriptor()
         val containingClass = descriptor.getContainingDeclaration() as ClassDescriptor
 
         val file = element.getContainingJetFile()
-        val outermostParent = JetPsiUtil.getOutermostParent(element, file, false)
+        val outermostParent = KtPsiUtil.getOutermostParent(element, file, false)
 
         val typeParameterList = newTypeParameterList(element)
 
         val project = element.getProject()
-        val psiFactory = JetPsiFactory(element)
+        val psiFactory = KtPsiFactory(element)
 
-        val extension = file.addAfter(element, outermostParent) as JetCallableDeclaration
+        val extension = file.addAfter(element, outermostParent) as KtCallableDeclaration
         file.addAfter(psiFactory.createNewLine(), outermostParent)
         file.addAfter(psiFactory.createNewLine(), outermostParent)
         element.delete()
@@ -73,20 +73,20 @@ public class ConvertMemberToExtensionIntention : JetSelfTargetingRangeIntention<
             }
         }
 
-        extension.getModifierList()?.getModifier(JetTokens.PROTECTED_KEYWORD)?.delete()
-        extension.getModifierList()?.getModifier(JetTokens.ABSTRACT_KEYWORD)?.delete()
+        extension.getModifierList()?.getModifier(KtTokens.PROTECTED_KEYWORD)?.delete()
+        extension.getModifierList()?.getModifier(KtTokens.ABSTRACT_KEYWORD)?.delete()
 
-        var bodyToSelect: JetExpression? = null
+        var bodyToSelect: KtExpression? = null
 
-        fun selectBody(declaration: JetDeclarationWithBody) {
+        fun selectBody(declaration: KtDeclarationWithBody) {
             if (bodyToSelect == null) {
                 val body = declaration.getBodyExpression()
-                bodyToSelect = if (body is JetBlockExpression) body.getStatements().single() else body
+                bodyToSelect = if (body is KtBlockExpression) body.getStatements().single() else body
             }
         }
 
         when (extension) {
-            is JetFunction -> {
+            is KtFunction -> {
                 if (!extension.hasBody()) {
                     //TODO: methods in PSI for setBody
                     extension.add(psiFactory.createBlock(THROW_UNSUPPORTED_OPERATION_EXCEPTION))
@@ -94,31 +94,31 @@ public class ConvertMemberToExtensionIntention : JetSelfTargetingRangeIntention<
                 }
             }
 
-            is JetProperty -> {
-                val templateProperty = psiFactory.createDeclaration<JetProperty>("var v: Any\nget()=$THROW_UNSUPPORTED_OPERATION_EXCEPTION\nset(value){$THROW_UNSUPPORTED_OPERATION_EXCEPTION}")
+            is KtProperty -> {
+                val templateProperty = psiFactory.createDeclaration<KtProperty>("var v: Any\nget()=$THROW_UNSUPPORTED_OPERATION_EXCEPTION\nset(value){$THROW_UNSUPPORTED_OPERATION_EXCEPTION}")
                 val templateGetter = templateProperty.getGetter()!!
                 val templateSetter = templateProperty.getSetter()!!
 
                 var getter = extension.getGetter()
                 if (getter == null) {
-                    getter = extension.addAfter(templateGetter, extension.getTypeReference()) as JetPropertyAccessor
+                    getter = extension.addAfter(templateGetter, extension.getTypeReference()) as KtPropertyAccessor
                     extension.addBefore(psiFactory.createNewLine(), getter)
                     selectBody(getter)
                 }
                 else if (!getter.hasBody()) {
-                    getter = getter.replace(templateGetter) as JetPropertyAccessor
+                    getter = getter.replace(templateGetter) as KtPropertyAccessor
                     selectBody(getter)
                 }
 
                 if (extension.isVar()) {
                     var setter = extension.getSetter()
                     if (setter == null) {
-                        setter = extension.addAfter(templateSetter, getter) as JetPropertyAccessor
+                        setter = extension.addAfter(templateSetter, getter) as KtPropertyAccessor
                         extension.addBefore(psiFactory.createNewLine(), setter)
                         selectBody(setter)
                     }
                     else if (!setter.hasBody()) {
-                        setter = setter.replace(templateSetter) as JetPropertyAccessor
+                        setter = setter.replace(templateSetter) as KtPropertyAccessor
                         selectBody(setter)
                     }
                 }
@@ -140,12 +140,12 @@ public class ConvertMemberToExtensionIntention : JetSelfTargetingRangeIntention<
     //TODO: reuse TEMPLATE_FROM_USAGE_FUNCTION_BODY
     private val THROW_UNSUPPORTED_OPERATION_EXCEPTION = "throw UnsupportedOperationException()"
 
-    private fun newTypeParameterList(member: JetCallableDeclaration): JetTypeParameterList? {
-        val classElement = member.getParent().getParent() as JetClass
+    private fun newTypeParameterList(member: KtCallableDeclaration): KtTypeParameterList? {
+        val classElement = member.getParent().getParent() as KtClass
         val classParams = classElement.getTypeParameters()
         if (classParams.isEmpty()) return null
         val allTypeParameters = classParams + member.getTypeParameters()
         val text = allTypeParameters.map { it.getText() }.joinToString(",", "<", ">")
-        return JetPsiFactory(member).createDeclaration<JetFunction>("fun $text foo()").getTypeParameterList()
+        return KtPsiFactory(member).createDeclaration<KtFunction>("fun $text foo()").getTypeParameterList()
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/declarations/SplitPropertyDeclarationIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/declarations/SplitPropertyDeclarationIntention.kt
index 2645b229584..88938b08365 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/declarations/SplitPropertyDeclarationIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/declarations/SplitPropertyDeclarationIntention.kt
@@ -21,17 +21,17 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.intentions.splitPropertyDeclaration
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
-public class SplitPropertyDeclarationIntention : JetSelfTargetingRangeIntention<JetProperty>(javaClass(), "Split property declaration"), LowPriorityAction {
-    override fun applicabilityRange(element: JetProperty): TextRange? {
+public class SplitPropertyDeclarationIntention : JetSelfTargetingRangeIntention<KtProperty>(javaClass(), "Split property declaration"), LowPriorityAction {
+    override fun applicabilityRange(element: KtProperty): TextRange? {
         if (!element.isLocal()) return null
         val initializer = element.getInitializer() ?: return null
         return TextRange(element.startOffset, initializer.startOffset)
     }
 
-    override fun applyTo(element: JetProperty, editor: Editor) {
+    override fun applyTo(element: KtProperty, editor: Editor) {
         splitPropertyDeclaration(element)
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/internal/KotlinBytecodeToolWindow.java b/idea/src/org/jetbrains/kotlin/idea/internal/KotlinBytecodeToolWindow.java
index c20e4750ec7..0cd83aeb1ee 100644
--- a/idea/src/org/jetbrains/kotlin/idea/internal/KotlinBytecodeToolWindow.java
+++ b/idea/src/org/jetbrains/kotlin/idea/internal/KotlinBytecodeToolWindow.java
@@ -47,9 +47,9 @@ import org.jetbrains.kotlin.idea.util.DebuggerUtils;
 import org.jetbrains.kotlin.idea.util.InfinitePeriodicalTask;
 import org.jetbrains.kotlin.idea.util.LongRunningReadTask;
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetScript;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtScript;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.utils.StringsKt;
 
@@ -81,7 +81,7 @@ public class KotlinBytecodeToolWindow extends JPanel implements Disposable {
                 return null;
             }
 
-            JetFile file = location.getJetFile();
+            KtFile file = location.getJetFile();
             if (file == null || !ProjectRootsUtil.isInProjectSource(file)) {
                 return null;
             }
@@ -105,7 +105,7 @@ public class KotlinBytecodeToolWindow extends JPanel implements Disposable {
         @NotNull
         @Override
         protected String processRequest(@NotNull Location location) {
-            JetFile jetFile = location.getJetFile();
+            KtFile jetFile = location.getJetFile();
             assert jetFile != null;
 
             return getBytecodeForFile(jetFile, enableInline.isSelected(), enableAssertions.isSelected(), enableOptimization.isSelected());
@@ -189,7 +189,7 @@ public class KotlinBytecodeToolWindow extends JPanel implements Disposable {
     // public for tests
     @NotNull
     public static String getBytecodeForFile(
-            final JetFile jetFile,
+            final KtFile jetFile,
             boolean enableInline,
             boolean enableAssertions,
             boolean enableOptimization
@@ -201,32 +201,32 @@ public class KotlinBytecodeToolWindow extends JPanel implements Disposable {
 
             BindingContext bindingContextForFile = resolutionFacade.analyzeFullyAndGetResult(Collections.singletonList(jetFile)).getBindingContext();
 
-            kotlin.Pair<BindingContext, List<JetFile>> result = DebuggerUtils.analyzeInlinedFunctions(
+            kotlin.Pair<BindingContext, List<KtFile>> result = DebuggerUtils.analyzeInlinedFunctions(
                     resolutionFacade, bindingContextForFile, jetFile, !enableInline
             );
 
             BindingContext bindingContext = result.getFirst();
-            List<JetFile> toProcess = result.getSecond();
+            List<KtFile> toProcess = result.getSecond();
 
             GenerationState.GenerateClassFilter generateClassFilter = new GenerationState.GenerateClassFilter() {
 
                 @Override
-                public boolean shouldGeneratePackagePart(JetFile file) {
+                public boolean shouldGeneratePackagePart(KtFile file) {
                     return file == jetFile;
                 }
 
                 @Override
-                public boolean shouldAnnotateClass(JetClassOrObject classOrObject) {
+                public boolean shouldAnnotateClass(KtClassOrObject classOrObject) {
                     return true;
                 }
 
                 @Override
-                public boolean shouldGenerateClass(JetClassOrObject classOrObject) {
+                public boolean shouldGenerateClass(KtClassOrObject classOrObject) {
                     return classOrObject.getContainingJetFile() == jetFile;
                 }
 
                 @Override
-                public boolean shouldGenerateScript(JetScript script) {
+                public boolean shouldGenerateScript(KtScript script) {
                     return script.getContainingJetFile() == jetFile;
                 }
             };
diff --git a/idea/src/org/jetbrains/kotlin/idea/internal/Location.java b/idea/src/org/jetbrains/kotlin/idea/internal/Location.java
index d83ed8324c5..ff484533bee 100644
--- a/idea/src/org/jetbrains/kotlin/idea/internal/Location.java
+++ b/idea/src/org/jetbrains/kotlin/idea/internal/Location.java
@@ -23,14 +23,14 @@ import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiManager;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 
 public class Location {
     @Nullable
     final Editor editor;
 
     @Nullable
-    final JetFile jetFile;
+    final KtFile jetFile;
 
     final long modificationStamp;
 
@@ -51,7 +51,7 @@ public class Location {
             }
             else {
                 PsiFile psiFile = PsiManager.getInstance(project).findFile(vFile);
-                jetFile = psiFile instanceof JetFile ? (JetFile) psiFile : null;
+                jetFile = psiFile instanceof KtFile ? (KtFile) psiFile : null;
             }
         }
         else {
@@ -67,7 +67,7 @@ public class Location {
     }
 
     @Nullable
-    public JetFile getJetFile() {
+    public KtFile getJetFile() {
         return jetFile;
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/j2k/IdeaResolverForConverter.kt b/idea/src/org/jetbrains/kotlin/idea/j2k/IdeaResolverForConverter.kt
index 42e531ce0f7..8ac923875a0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/j2k/IdeaResolverForConverter.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/j2k/IdeaResolverForConverter.kt
@@ -17,9 +17,9 @@
 package org.jetbrains.kotlin.idea.j2k
 
 import org.jetbrains.kotlin.j2k.ResolverForConverter
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 
 public object IdeaResolverForConverter : ResolverForConverter {
-    override fun resolveToDescriptor(declaration: JetDeclaration) = declaration.resolveToDescriptor()
+    override fun resolveToDescriptor(declaration: KtDeclaration) = declaration.resolveToDescriptor()
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessings.kt b/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessings.kt
index 981d2e1cadf..1ec6b521dc1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessings.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessings.kt
@@ -31,14 +31,14 @@ import org.jetbrains.kotlin.idea.intentions.conventionNameCalls.ReplaceGetIntent
 import org.jetbrains.kotlin.idea.quickfix.RemoveModifierFix
 import org.jetbrains.kotlin.idea.quickfix.RemoveRightPartOfBinaryExpressionFix
 import org.jetbrains.kotlin.idea.references.mainReference
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.visibilityModifierType
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import java.util.*
 
 interface J2kPostProcessing {
-    fun createAction(element: JetElement, diagnostics: Diagnostics): (() -> Unit)?
+    fun createAction(element: KtElement, diagnostics: Diagnostics): (() -> Unit)?
 }
 
 object J2KPostProcessingRegistrar {
@@ -63,44 +63,44 @@ object J2KPostProcessingRegistrar {
         registerIntentionBasedProcessing(ReplaceGetIntention(), additionalChecker = ExplicitGetInspection.additionalChecker) { applyTo(it) }
         registerIntentionBasedProcessing(AddOperatorModifierIntention()) { applyTo(it) }
 
-        registerDiagnosticBasedProcessing<JetBinaryExpressionWithTypeRHS>(Errors.USELESS_CAST) { element, diagnostic ->
+        registerDiagnosticBasedProcessing<KtBinaryExpressionWithTypeRHS>(Errors.USELESS_CAST) { element, diagnostic ->
             val expression = RemoveRightPartOfBinaryExpressionFix(element, "").invoke()
 
-            val variable = expression.parent as? JetProperty
+            val variable = expression.parent as? KtProperty
             if (variable != null && expression == variable.initializer && variable.isLocal) {
                 val refs = ReferencesSearch.search(variable, LocalSearchScope(variable.containingFile)).findAll()
                 for (ref in refs) {
-                    val usage = ref.element as? JetSimpleNameExpression ?: continue
+                    val usage = ref.element as? KtSimpleNameExpression ?: continue
                     usage.replace(expression)
                 }
                 variable.delete()
             }
         }
 
-        registerDiagnosticBasedProcessing<JetTypeProjection>(Errors.REDUNDANT_PROJECTION) { element, diagnostic ->
+        registerDiagnosticBasedProcessing<KtTypeProjection>(Errors.REDUNDANT_PROJECTION) { element, diagnostic ->
             val fix = RemoveModifierFix.createRemoveProjectionFactory(true).createActions(diagnostic).single() as RemoveModifierFix
             fix.invoke()
         }
 
-        registerDiagnosticBasedProcessing<JetSimpleNameExpression>(Errors.UNNECESSARY_NOT_NULL_ASSERTION) { element, diagnostic ->
-            val exclExclExpr = element.parent as JetUnaryExpression
+        registerDiagnosticBasedProcessing<KtSimpleNameExpression>(Errors.UNNECESSARY_NOT_NULL_ASSERTION) { element, diagnostic ->
+            val exclExclExpr = element.parent as KtUnaryExpression
             exclExclExpr.replace(exclExclExpr.baseExpression!!)
         }
 
         registerDiagnosticBasedProcessingFactory(
                 Errors.VAL_REASSIGNMENT,
-                fun (element: JetSimpleNameExpression, diagnostic: Diagnostic): (() -> Unit)? {
-                    val property = element.mainReference.resolve() as? JetProperty ?: return null
+                fun (element: KtSimpleNameExpression, diagnostic: Diagnostic): (() -> Unit)? {
+                    val property = element.mainReference.resolve() as? KtProperty ?: return null
                     return {
                         if (!property.isVar) {
-                            property.valOrVarKeyword.replace(JetPsiFactory(element.project).createVarKeyword())
+                            property.valOrVarKeyword.replace(KtPsiFactory(element.project).createVarKeyword())
                         }
                     }
                 }
         )
     }
 
-    private inline fun <reified TElement : JetElement, TIntention: JetSelfTargetingRangeIntention<TElement>> registerIntentionBasedProcessing(
+    private inline fun <reified TElement : KtElement, TIntention: JetSelfTargetingRangeIntention<TElement>> registerIntentionBasedProcessing(
             intention: TIntention,
             crossinline apply: TIntention.(TElement) -> Unit
     ) {
@@ -108,13 +108,13 @@ object J2KPostProcessingRegistrar {
         return registerIntentionBasedProcessing<TElement, TIntention>(intention, { true }, apply)
     }
 
-    private inline fun <reified TElement : JetElement, TIntention: JetSelfTargetingRangeIntention<TElement>> registerIntentionBasedProcessing(
+    private inline fun <reified TElement : KtElement, TIntention: JetSelfTargetingRangeIntention<TElement>> registerIntentionBasedProcessing(
             intention: TIntention,
             noinline additionalChecker: (TElement) -> Boolean,
             crossinline apply: TIntention.(TElement) -> Unit
     ) {
         _processings.add(object : J2kPostProcessing {
-            override fun createAction(element: JetElement, diagnostics: Diagnostics): (() -> Unit)? {
+            override fun createAction(element: KtElement, diagnostics: Diagnostics): (() -> Unit)? {
                 if (!javaClass<TElement>().isInstance(element)) return null
                 val tElement = element as TElement
                 if (intention.applicabilityRange(tElement) == null) return null
@@ -124,19 +124,19 @@ object J2KPostProcessingRegistrar {
         })
     }
 
-    private inline fun <reified TElement : JetElement> registerDiagnosticBasedProcessing(
+    private inline fun <reified TElement : KtElement> registerDiagnosticBasedProcessing(
             diagnosticFactory: DiagnosticFactory<*>,
             crossinline fix: (TElement, Diagnostic) -> Unit
     ) {
         registerDiagnosticBasedProcessingFactory(diagnosticFactory) { element: TElement, diagnostic: Diagnostic -> { fix(element, diagnostic) } }
     }
 
-    private inline fun <reified TElement : JetElement> registerDiagnosticBasedProcessingFactory(
+    private inline fun <reified TElement : KtElement> registerDiagnosticBasedProcessingFactory(
             diagnosticFactory: DiagnosticFactory<*>,
             crossinline fixFactory: (TElement, Diagnostic) -> (() -> Unit)?
     ) {
         _processings.add(object : J2kPostProcessing {
-            override fun createAction(element: JetElement, diagnostics: Diagnostics): (() -> Unit)? {
+            override fun createAction(element: KtElement, diagnostics: Diagnostics): (() -> Unit)? {
                 if (!javaClass<TElement>().isInstance(element)) return null
                 val diagnostic = diagnostics.forElement(element).firstOrNull { it.factory == diagnosticFactory } ?: return null
                 return fixFactory(element as TElement, diagnostic)
@@ -145,16 +145,16 @@ object J2KPostProcessingRegistrar {
     }
 
     private class RemoveExplicitTypeArgumentsProcessing : J2kPostProcessing {
-        override fun createAction(element: JetElement, diagnostics: Diagnostics): (() -> Unit)? {
-            if (element !is JetTypeArgumentList || !RemoveExplicitTypeArgumentsIntention.isApplicableTo(element, approximateFlexible = true)) return null
+        override fun createAction(element: KtElement, diagnostics: Diagnostics): (() -> Unit)? {
+            if (element !is KtTypeArgumentList || !RemoveExplicitTypeArgumentsIntention.isApplicableTo(element, approximateFlexible = true)) return null
 
             return { element.delete() }
         }
     }
 
     private class RemoveRedundantOverrideVisibilityProcessing : J2kPostProcessing {
-        override fun createAction(element: JetElement, diagnostics: Diagnostics): (() -> Unit)? {
-            if (element !is JetCallableDeclaration || !element.hasModifier(JetTokens.OVERRIDE_KEYWORD)) return null
+        override fun createAction(element: KtElement, diagnostics: Diagnostics): (() -> Unit)? {
+            if (element !is KtCallableDeclaration || !element.hasModifier(KtTokens.OVERRIDE_KEYWORD)) return null
             val modifier = element.visibilityModifierType() ?: return null
             return { element.setVisibility(modifier) }
         }
@@ -163,8 +163,8 @@ object J2KPostProcessingRegistrar {
     private class MoveLambdaOutsideParenthesesProcessing : J2kPostProcessing {
         private val intention = MoveLambdaOutsideParenthesesIntention()
 
-        override fun createAction(element: JetElement, diagnostics: Diagnostics): (() -> Unit)? {
-            if (element !is JetCallExpression) return null
+        override fun createAction(element: KtElement, diagnostics: Diagnostics): (() -> Unit)? {
+            if (element !is KtCallExpression) return null
             val literalArgument = element.valueArguments.lastOrNull()?.getArgumentExpression()?.unpackFunctionLiteral() ?: return null
             if (!intention.isApplicableTo(element, literalArgument.textOffset)) return null
             return { intention.applyTo(element) }
@@ -174,8 +174,8 @@ object J2KPostProcessingRegistrar {
     private class ConvertToStringTemplateProcessing : J2kPostProcessing {
         private val intention = ConvertToStringTemplateIntention()
 
-        override fun createAction(element: JetElement, diagnostics: Diagnostics): (() -> Unit)? {
-            if (element is JetBinaryExpression && intention.isApplicableTo(element) && intention.shouldSuggestToConvert(element)) {
+        override fun createAction(element: KtElement, diagnostics: Diagnostics): (() -> Unit)? {
+            if (element is KtBinaryExpression && intention.isApplicableTo(element) && intention.shouldSuggestToConvert(element)) {
                 return { intention.applyTo(element) }
             }
             else {
@@ -187,16 +187,16 @@ object J2KPostProcessingRegistrar {
     private class UsePropertyAccessSyntaxProcessing : J2kPostProcessing {
         private val intention = UsePropertyAccessSyntaxIntention()
 
-        override fun createAction(element: JetElement, diagnostics: Diagnostics): (() -> Unit)? {
-            if (element !is JetCallExpression) return null
+        override fun createAction(element: KtElement, diagnostics: Diagnostics): (() -> Unit)? {
+            if (element !is KtCallExpression) return null
             val propertyName = intention.detectPropertyNameToUse(element) ?: return null
             return { intention.applyTo(element, propertyName) }
         }
     }
 
     private class RemoveRedundantSamAdaptersProcessing : J2kPostProcessing {
-        override fun createAction(element: JetElement, diagnostics: Diagnostics): (() -> Unit)? {
-            if (element !is JetCallExpression) return null
+        override fun createAction(element: KtElement, diagnostics: Diagnostics): (() -> Unit)? {
+            if (element !is KtCallExpression) return null
 
             val expressions = RedundantSamConstructorInspection.samConstructorCallsToBeConverted(element)
             if (expressions.isEmpty()) return null
@@ -211,8 +211,8 @@ object J2KPostProcessingRegistrar {
     private class AccessorBodyToExpression : J2kPostProcessing {
         private val intention = ConvertToExpressionBodyIntention()
 
-        override fun createAction(element: JetElement, diagnostics: Diagnostics): (() -> Unit)? {
-            if (element !is JetPropertyAccessor) return null
+        override fun createAction(element: KtElement, diagnostics: Diagnostics): (() -> Unit)? {
+            if (element !is KtPropertyAccessor) return null
             if (!intention.isApplicableTo(element)) return null
             return { intention.applyTo(element, true) }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessor.kt
index 5745006f66c..5927bcc6752 100644
--- a/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessor.kt
@@ -29,14 +29,14 @@ import org.jetbrains.kotlin.idea.conversion.copy.range
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.j2k.PostProcessor
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.elementsInRange
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import java.util.*
 
 public class J2kPostProcessor(private val formatCode: Boolean) : PostProcessor {
-    override fun insertImport(file: JetFile, fqName: FqName) {
+    override fun insertImport(file: KtFile, fqName: FqName) {
         val descriptors = file.resolveImportReference(fqName)
         descriptors.firstOrNull()?.let { ImportInsertHelper.getInstance(file.project).importDescriptor(file, it) }
     }
@@ -47,7 +47,7 @@ public class J2kPostProcessor(private val formatCode: Boolean) : PostProcessor {
         PROCESS
     }
 
-    override fun doAdditionalProcessing(file: JetFile, rangeMarker: RangeMarker?) {
+    override fun doAdditionalProcessing(file: KtFile, rangeMarker: RangeMarker?) {
         var elementToActions = collectAvailableActions(file, rangeMarker)
 
         while (elementToActions.isNotEmpty()) {
@@ -87,14 +87,14 @@ public class J2kPostProcessor(private val formatCode: Boolean) : PostProcessor {
 
     private data class ActionData(val action: () -> Unit, val processing: J2kPostProcessing)
 
-    private fun collectAvailableActions(file: JetFile, rangeMarker: RangeMarker?): LinkedHashMap<JetElement, SmartList<ActionData>> {
+    private fun collectAvailableActions(file: KtFile, rangeMarker: RangeMarker?): LinkedHashMap<KtElement, SmartList<ActionData>> {
         val diagnostics = analyzeFileRange(file, rangeMarker)
 
-        val elementToActions = LinkedHashMap<JetElement, SmartList<ActionData>>()
+        val elementToActions = LinkedHashMap<KtElement, SmartList<ActionData>>()
 
         file.accept(object : PsiRecursiveElementVisitor(){
             override fun visitElement(element: PsiElement) {
-                if (element is JetElement) {
+                if (element is KtElement) {
                     val rangeResult = rangeFilter(element, rangeMarker)
                     if (rangeResult == RangeFilterResult.SKIP) return
 
@@ -115,11 +115,11 @@ public class J2kPostProcessor(private val formatCode: Boolean) : PostProcessor {
         return elementToActions
     }
 
-    private fun analyzeFileRange(file: JetFile, rangeMarker: RangeMarker?): Diagnostics {
+    private fun analyzeFileRange(file: KtFile, rangeMarker: RangeMarker?): Diagnostics {
         val elements = if (rangeMarker == null)
             listOf(file)
         else
-            file.elementsInRange(rangeMarker.range!!).filterIsInstance<JetElement>()
+            file.elementsInRange(rangeMarker.range!!).filterIsInstance<KtElement>()
 
         return if (elements.isNotEmpty())
             file.getResolutionFacade().analyzeFullyAndGetResult(elements).bindingContext.diagnostics
diff --git a/idea/src/org/jetbrains/kotlin/idea/joinLines/JoinBlockIntoSingleStatementHandler.kt b/idea/src/org/jetbrains/kotlin/idea/joinLines/JoinBlockIntoSingleStatementHandler.kt
index 6e9ba7e142c..d231c91aaed 100644
--- a/idea/src/org/jetbrains/kotlin/idea/joinLines/JoinBlockIntoSingleStatementHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/joinLines/JoinBlockIntoSingleStatementHandler.kt
@@ -19,29 +19,29 @@ package org.jetbrains.kotlin.idea.joinLines
 import com.intellij.codeInsight.editorActions.JoinRawLinesHandlerDelegate
 import com.intellij.openapi.editor.Document
 import com.intellij.psi.PsiFile
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 
 public class JoinBlockIntoSingleStatementHandler : JoinRawLinesHandlerDelegate {
     override fun tryJoinRawLines(document: Document, file: PsiFile, start: Int, end: Int): Int {
-        if (file !is JetFile) return -1
+        if (file !is KtFile) return -1
 
         if (start == 0) return -1
         val c = document.getCharsSequence()[start]
         val index = if (c == '\n') start - 1 else start
 
         val brace = file.findElementAt(index)!!
-        if (brace.getNode()!!.getElementType() != JetTokens.LBRACE) return -1
+        if (brace.getNode()!!.getElementType() != KtTokens.LBRACE) return -1
 
-        val block = brace.getParent() as? JetBlockExpression ?: return -1
+        val block = brace.getParent() as? KtBlockExpression ?: return -1
         val statement = block.getStatements().singleOrNull() ?: return -1
         val parent = block.getParent()
-        if (parent !is JetContainerNode && parent !is JetWhenEntry) return -1
-        if (block.getNode().getChildren(JetTokens.COMMENTS).isNotEmpty()) return -1 // otherwise we will loose comments
+        if (parent !is KtContainerNode && parent !is KtWhenEntry) return -1
+        if (block.getNode().getChildren(KtTokens.COMMENTS).isNotEmpty()) return -1 // otherwise we will loose comments
 
         // handle nested if's
         val pparent = parent.getParent()
-        if (pparent is JetIfExpression && block == pparent.getThen() && statement is JetIfExpression && statement.getElse() == null) {
+        if (pparent is KtIfExpression && block == pparent.getThen() && statement is KtIfExpression && statement.getElse() == null) {
             // if outer if has else-branch and inner does not have it, do not remove braces otherwise else-branch will belong to different if!
             if (pparent.getElse() != null) return -1
 
@@ -49,7 +49,7 @@ public class JoinBlockIntoSingleStatementHandler : JoinRawLinesHandlerDelegate {
             val condition2 = statement.getCondition()
             val body = statement.getThen()
             if (condition1 != null && condition2 != null && body != null) {
-                val newCondition = JetPsiFactory(pparent).createExpressionByPattern("$0 && $1", condition1, condition2)
+                val newCondition = KtPsiFactory(pparent).createExpressionByPattern("$0 && $1", condition1, condition2)
                 condition1.replace(newCondition)
                 val newBody = block.replace(body)
                 return newBody.getTextRange()!!.getStartOffset()
diff --git a/idea/src/org/jetbrains/kotlin/idea/joinLines/JoinDeclarationAndAssignmentHandler.kt b/idea/src/org/jetbrains/kotlin/idea/joinLines/JoinDeclarationAndAssignmentHandler.kt
index 1ea38e1df56..931705e8934 100644
--- a/idea/src/org/jetbrains/kotlin/idea/joinLines/JoinDeclarationAndAssignmentHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/joinLines/JoinDeclarationAndAssignmentHandler.kt
@@ -21,20 +21,20 @@ import org.jetbrains.kotlin.psi.psiUtil.parents
 import com.intellij.codeInsight.editorActions.JoinRawLinesHandlerDelegate
 import com.intellij.openapi.editor.Document
 import com.intellij.psi.PsiFile
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import com.intellij.psi.PsiWhiteSpace
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import com.intellij.openapi.util.text.StringUtil
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 
 public class JoinDeclarationAndAssignmentHandler : JoinRawLinesHandlerDelegate {
 
     override fun tryJoinRawLines(document: Document, file: PsiFile, start: Int, end: Int): Int {
-        if (file !is JetFile) return -1
+        if (file !is KtFile) return -1
 
         val element = file.findElementAt(start)
                               ?.siblings(forward = false, withItself = false)
@@ -53,22 +53,22 @@ public class JoinDeclarationAndAssignmentHandler : JoinRawLinesHandlerDelegate {
     override fun tryJoinLines(document: Document, file: PsiFile, start: Int, end: Int)
             = -1
 
-    private fun getPropertyAndAssignment(element: PsiElement): Pair<JetProperty, JetBinaryExpression>? {
-        val property = element as? JetProperty ?: return null
+    private fun getPropertyAndAssignment(element: PsiElement): Pair<KtProperty, KtBinaryExpression>? {
+        val property = element as? KtProperty ?: return null
         if (property.hasInitializer()) return null
 
         val assignment = element.siblings(forward = true, withItself = false)
-                                 .firstOrNull { !isToSkip(it) } as? JetBinaryExpression ?: return null
-        if (assignment.getOperationToken() != JetTokens.EQ) return null
+                                 .firstOrNull { !isToSkip(it) } as? KtBinaryExpression ?: return null
+        if (assignment.getOperationToken() != KtTokens.EQ) return null
 
-        val left = assignment.getLeft() as? JetSimpleNameExpression ?: return null
+        val left = assignment.getLeft() as? KtSimpleNameExpression ?: return null
         if (assignment.getRight() == null) return null
         if (left.getReferencedName() != property.getName()) return null
 
         return property to assignment
     }
 
-    private fun doJoin(property: JetProperty, assignment: JetBinaryExpression) {
+    private fun doJoin(property: KtProperty, assignment: KtBinaryExpression) {
         property.setInitializer(assignment.getRight())
         property.getParent()!!.deleteChildRange(property.getNextSibling(), assignment) //TODO: should we delete range?
     }
@@ -76,7 +76,7 @@ public class JoinDeclarationAndAssignmentHandler : JoinRawLinesHandlerDelegate {
     private fun isToSkip(element: PsiElement): Boolean {
         return when (element) {
             is PsiWhiteSpace -> StringUtil.getLineBreakCount(element.getText()!!) <= 1 // do not skip blank line
-            else -> element.getNode()!!.getElementType() == JetTokens.SEMICOLON
+            else -> element.getNode()!!.getElementType() == KtTokens.SEMICOLON
         }
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/k2jsrun/K2JSRunConfigurationType.java b/idea/src/org/jetbrains/kotlin/idea/k2jsrun/K2JSRunConfigurationType.java
index 12588debd0b..b1717b1ac05 100644
--- a/idea/src/org/jetbrains/kotlin/idea/k2jsrun/K2JSRunConfigurationType.java
+++ b/idea/src/org/jetbrains/kotlin/idea/k2jsrun/K2JSRunConfigurationType.java
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.k2jsrun;
 
 import com.intellij.execution.configurations.*;
 import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.idea.JetIcons;
+import org.jetbrains.kotlin.idea.KtIcons;
 
 public final class K2JSRunConfigurationType extends ConfigurationTypeBase {
     public static K2JSRunConfigurationType getInstance() {
@@ -26,7 +26,7 @@ public final class K2JSRunConfigurationType extends ConfigurationTypeBase {
     }
 
     public K2JSRunConfigurationType() {
-        super("K2JSConfigurationType", "Kotlin (JavaScript - experimental)", "Kotlin to JavaScript configuration", JetIcons.LAUNCH);
+        super("K2JSConfigurationType", "Kotlin (JavaScript - experimental)", "Kotlin to JavaScript configuration", KtIcons.LAUNCH);
         addFactory(new K2JSConfigurationFactory());
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/kdoc/KDocTypedHandler.kt b/idea/src/org/jetbrains/kotlin/idea/kdoc/KDocTypedHandler.kt
index 0c15b17645b..6d9c2d1d69e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/kdoc/KDocTypedHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/kdoc/KDocTypedHandler.kt
@@ -26,8 +26,8 @@ import com.intellij.psi.PsiDocumentManager
 import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.kdoc.lexer.KDocTokens
 import org.jetbrains.kotlin.kdoc.psi.api.KDoc
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 
 public class KDocTypedHandler(): TypedHandlerDelegate() {
@@ -44,7 +44,7 @@ public class KDocTypedHandler(): TypedHandlerDelegate() {
 
     private fun overwriteClosingBracket(c: Char, editor: Editor, file: PsiFile): Boolean {
         if (c != ']' && c != ')') return false
-        if (file !is JetFile) return false
+        if (file !is KtFile) return false
         if (!CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET) return false
 
         val offset = editor.getCaretModel().getOffset()
@@ -59,7 +59,7 @@ public class KDocTypedHandler(): TypedHandlerDelegate() {
                 ']' -> {
                     // if the bracket is not part of a link, it will be part of KDOC_TEXT, not a separate RBRACKET element
                     element.getParentOfType<KDoc>(false) != null
-                           && (elementType == JetTokens.RBRACKET || (offset > 0 && chars[offset - 1] == '['))
+                           && (elementType == KtTokens.RBRACKET || (offset > 0 && chars[offset - 1] == '['))
                 }
 
                 ')' -> elementType == KDocTokens.MARKDOWN_INLINE_LINK
@@ -72,7 +72,7 @@ public class KDocTypedHandler(): TypedHandlerDelegate() {
 
     private fun handleBracketTyped(c: Char, project: Project, editor: Editor, file: PsiFile): Boolean {
         if (c != '[' && c != '(') return false
-        if (file !is JetFile) return false
+        if (file !is KtFile) return false
         if (!CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET) return false
 
         val offset = editor.getCaretModel().getOffset()
diff --git a/idea/src/org/jetbrains/kotlin/idea/liveTemplates/JetTemplateContextType.java b/idea/src/org/jetbrains/kotlin/idea/liveTemplates/JetTemplateContextType.java
index 60979acfde0..25018d638f6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/liveTemplates/JetTemplateContextType.java
+++ b/idea/src/org/jetbrains/kotlin/idea/liveTemplates/JetTemplateContextType.java
@@ -31,7 +31,7 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 
 public abstract class JetTemplateContextType extends TemplateContextType {
@@ -52,17 +52,17 @@ public abstract class JetTemplateContextType extends TemplateContextType {
             else if (PsiTreeUtil.getParentOfType(element, PsiComment.class, false) != null) {
                 return isCommentInContext();
             }
-            else if (PsiTreeUtil.getParentOfType(element, JetPackageDirective.class) != null
-                    || PsiTreeUtil.getParentOfType(element, JetImportDirective.class) != null) {
+            else if (PsiTreeUtil.getParentOfType(element, KtPackageDirective.class) != null
+                    || PsiTreeUtil.getParentOfType(element, KtImportDirective.class) != null) {
                 return false;
             }
             else if (element instanceof LeafPsiElement) {
                 IElementType elementType = ((LeafPsiElement) element).getElementType();
-                if (elementType == JetTokens.IDENTIFIER) {
+                if (elementType == KtTokens.IDENTIFIER) {
                     PsiElement parent = element.getParent();
-                    if (parent instanceof JetReferenceExpression) {
+                    if (parent instanceof KtReferenceExpression) {
                         PsiElement parentOfParent = parent.getParent();
-                        JetQualifiedExpression qualifiedExpression = PsiTreeUtil.getParentOfType(element, JetQualifiedExpression.class);
+                        KtQualifiedExpression qualifiedExpression = PsiTreeUtil.getParentOfType(element, KtQualifiedExpression.class);
                         if (qualifiedExpression != null && qualifiedExpression.getSelectorExpression() == parentOfParent) {
                             return false;
                         }
@@ -106,7 +106,7 @@ public abstract class JetTemplateContextType extends TemplateContextType {
         protected boolean isInContext(@NotNull PsiElement element) {
             PsiElement e = element;
             while (e != null) {
-                if (e instanceof JetModifierList) {
+                if (e instanceof KtModifierList) {
                     // skip property/function/class or object which is owner of modifier list
                     e = e.getParent();
                     if (e != null) {
@@ -114,8 +114,8 @@ public abstract class JetTemplateContextType extends TemplateContextType {
                     }
                     continue;
                 }
-                if (e instanceof JetProperty || e instanceof JetNamedFunction
-                    || e instanceof JetClassOrObject) {
+                if (e instanceof KtProperty || e instanceof KtNamedFunction
+                    || e instanceof KtClassOrObject) {
                     return false;
                 }
                 e = e.getParent();
@@ -132,8 +132,8 @@ public abstract class JetTemplateContextType extends TemplateContextType {
         @Override
         protected boolean isInContext(@NotNull PsiElement element) {
             PsiElement e = element;
-            while (e != null && !(e instanceof JetClassOrObject)) {
-                if (e instanceof JetModifierList) {
+            while (e != null && !(e instanceof KtClassOrObject)) {
+                if (e instanceof KtModifierList) {
                     // skip property/function/class or object which is owner of modifier list
                     e = e.getParent();
                     if (e != null) {
@@ -141,7 +141,7 @@ public abstract class JetTemplateContextType extends TemplateContextType {
                     }
                     continue;
                 }
-                if (e instanceof JetProperty || e instanceof JetNamedFunction) {
+                if (e instanceof KtProperty || e instanceof KtNamedFunction) {
                     return false;
                 }
                 e = e.getParent();
@@ -160,7 +160,7 @@ public abstract class JetTemplateContextType extends TemplateContextType {
             PsiElement parentStatement = PsiTreeUtil.findFirstParent(element, new Condition<PsiElement>() {
                 @Override
                 public boolean value(PsiElement element) {
-                    return element instanceof JetExpression && (element.getParent() instanceof JetBlockExpression);
+                    return element instanceof KtExpression && (element.getParent() instanceof KtBlockExpression);
                 }
             });
 
@@ -178,9 +178,9 @@ public abstract class JetTemplateContextType extends TemplateContextType {
 
         @Override
         protected boolean isInContext(@NotNull PsiElement element) {
-            return element.getParent() instanceof JetExpression && !(element.getParent() instanceof JetConstantExpression) &&
-                   !(element.getParent().getParent() instanceof JetDotQualifiedExpression)
-                   && !(element.getParent() instanceof JetParameter);
+            return element.getParent() instanceof KtExpression && !(element.getParent() instanceof KtConstantExpression) &&
+                   !(element.getParent().getParent() instanceof KtDotQualifiedExpression)
+                   && !(element.getParent() instanceof KtParameter);
         }
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/liveTemplates/KotlinShortenFQNamesProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/liveTemplates/KotlinShortenFQNamesProcessor.kt
index efd1589a3b5..fee47acbe58 100644
--- a/idea/src/org/jetbrains/kotlin/idea/liveTemplates/KotlinShortenFQNamesProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/liveTemplates/KotlinShortenFQNamesProcessor.kt
@@ -26,7 +26,7 @@ import com.intellij.codeInsight.CodeInsightBundle
 import com.intellij.psi.PsiDocumentManager
 import org.jetbrains.kotlin.idea.util.ShortenReferences
 import com.intellij.psi.util.PsiUtilBase
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
 public class KotlinShortenFQNamesProcessor : TemplateOptionalProcessor {
     override fun processText(project: Project, template: Template, document: Document, templateRange: RangeMarker, editor: Editor) {
@@ -34,7 +34,7 @@ public class KotlinShortenFQNamesProcessor : TemplateOptionalProcessor {
 
         PsiDocumentManager.getInstance(project).commitDocument(document)
 
-        val file = PsiUtilBase.getPsiFileInEditor(editor, project) as? JetFile ?: return
+        val file = PsiUtilBase.getPsiFileInEditor(editor, project) as? KtFile ?: return
         ShortenReferences.DEFAULT.process(file, templateRange.getStartOffset(), templateRange.getEndOffset())
 
         PsiDocumentManager.getInstance(project).doPostponedOperationsAndUnblockDocument(document)
diff --git a/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/AnonymousTemplateEditingListener.java b/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/AnonymousTemplateEditingListener.java
index a474246ce8f..171067f4bf3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/AnonymousTemplateEditingListener.java
+++ b/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/AnonymousTemplateEditingListener.java
@@ -33,12 +33,12 @@ import org.jetbrains.kotlin.descriptors.ConstructorDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
 import org.jetbrains.kotlin.idea.core.overrideImplement.ImplementMembersHandler;
-import org.jetbrains.kotlin.psi.JetReferenceExpression;
+import org.jetbrains.kotlin.psi.KtReferenceExpression;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
 
 class AnonymousTemplateEditingListener extends TemplateEditingAdapter {
-    private JetReferenceExpression classRef;
+    private KtReferenceExpression classRef;
     private ClassDescriptor classDescriptor;
     private final Editor editor;
     private final PsiFile psiFile;
@@ -56,8 +56,8 @@ class AnonymousTemplateEditingListener extends TemplateEditingAdapter {
         TextRange variableRange = templateState.getVariableRange("SUPERTYPE");
         if (variableRange == null) return;
         PsiElement name = psiFile.findElementAt(variableRange.getStartOffset());
-        if (name != null && name.getParent() instanceof JetReferenceExpression) {
-            JetReferenceExpression ref = (JetReferenceExpression) name.getParent();
+        if (name != null && name.getParent() instanceof KtReferenceExpression) {
+            KtReferenceExpression ref = (KtReferenceExpression) name.getParent();
             DeclarationDescriptor descriptor = ResolutionUtils.analyze(ref, BodyResolveMode.FULL).get(BindingContext.REFERENCE_TARGET, ref);
             if (descriptor instanceof ClassDescriptor) {
                 classRef = ref;
diff --git a/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/BaseJetVariableMacro.java b/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/BaseJetVariableMacro.java
index 5f68084d855..690ca31887a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/BaseJetVariableMacro.java
+++ b/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/BaseJetVariableMacro.java
@@ -45,28 +45,28 @@ import org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilsKt;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 
 import java.util.*;
 
 public abstract class BaseJetVariableMacro extends Macro {
     @Nullable
-    private JetNamedDeclaration[] getVariables(Expression[] params, ExpressionContext context) {
+    private KtNamedDeclaration[] getVariables(Expression[] params, ExpressionContext context) {
         if (params.length != 0) return null;
 
         Project project = context.getProject();
         PsiDocumentManager.getInstance(project).commitAllDocuments();
 
         PsiFile psiFile = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument());
-        if (!(psiFile instanceof JetFile)) return null;
+        if (!(psiFile instanceof KtFile)) return null;
 
-        JetExpression contextExpression = findContextExpression(psiFile, context.getStartOffset());
+        KtExpression contextExpression = findContextExpression(psiFile, context.getStartOffset());
         if (contextExpression == null) return null;
 
         ResolutionFacade resolutionFacade = ResolutionUtils.getResolutionFacade(contextExpression);
 
         BindingContext bindingContext = resolutionFacade.analyze(contextExpression, BodyResolveMode.FULL);
-        JetScope scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, contextExpression);
+        KtScope scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, contextExpression);
         if (scope == null) {
             return null;
         }
@@ -93,24 +93,24 @@ public abstract class BaseJetVariableMacro extends Macro {
         }
 
 
-        List<JetNamedDeclaration> declarations = new ArrayList<JetNamedDeclaration>();
+        List<KtNamedDeclaration> declarations = new ArrayList<KtNamedDeclaration>();
         for (DeclarationDescriptor declarationDescriptor : filteredDescriptors) {
             PsiElement declaration = DescriptorToSourceUtils.descriptorToDeclaration(declarationDescriptor);
             assert declaration == null || declaration instanceof PsiNamedElement;
 
-            if (declaration instanceof JetProperty || declaration instanceof JetParameter) {
-                declarations.add((JetNamedDeclaration) declaration);
+            if (declaration instanceof KtProperty || declaration instanceof KtParameter) {
+                declarations.add((KtNamedDeclaration) declaration);
             }
         }
 
-        return declarations.toArray(new JetNamedDeclaration[declarations.size()]);
+        return declarations.toArray(new KtNamedDeclaration[declarations.size()]);
     }
 
-    private static Collection<DeclarationDescriptor> getAllVariables(JetScope scope) {
+    private static Collection<DeclarationDescriptor> getAllVariables(KtScope scope) {
         Collection<DeclarationDescriptor> result = ContainerUtil.newArrayList();
-        result.addAll(scope.getDescriptors(DescriptorKindFilter.VARIABLES, JetScope.Companion.getALL_NAME_FILTER()));
+        result.addAll(scope.getDescriptors(DescriptorKindFilter.VARIABLES, KtScope.Companion.getALL_NAME_FILTER()));
         for (ReceiverParameterDescriptor implicitReceiver : scope.getImplicitReceiversHierarchy()) {
-            result.addAll(implicitReceiver.getType().getMemberScope().getDescriptors(DescriptorKindFilter.VARIABLES, JetScope.Companion.getALL_NAME_FILTER()));
+            result.addAll(implicitReceiver.getType().getMemberScope().getDescriptors(DescriptorKindFilter.VARIABLES, KtScope.Companion.getALL_NAME_FILTER()));
         }
         return result;
     }
@@ -122,11 +122,11 @@ public abstract class BaseJetVariableMacro extends Macro {
     );
 
     @Nullable
-    private static JetExpression findContextExpression(PsiFile psiFile, int startOffset) {
+    private static KtExpression findContextExpression(PsiFile psiFile, int startOffset) {
         PsiElement e = psiFile.findElementAt(startOffset);
         while (e != null) {
-            if (e instanceof JetExpression) {
-                return (JetExpression) e;
+            if (e instanceof KtExpression) {
+                return (KtExpression) e;
             }
             e = e.getParent();
         }
@@ -135,7 +135,7 @@ public abstract class BaseJetVariableMacro extends Macro {
 
     @Override
     public Result calculateResult(@NotNull Expression[] params, ExpressionContext context) {
-        JetNamedDeclaration[] vars = getVariables(params, context);
+        KtNamedDeclaration[] vars = getVariables(params, context);
         if (vars == null || vars.length == 0) return null;
         return new JetPsiElementResult(vars[0]);
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/JetAnonymousSuperMacro.java b/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/JetAnonymousSuperMacro.java
index 734b9a5f06d..53431c90e91 100644
--- a/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/JetAnonymousSuperMacro.java
+++ b/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/JetAnonymousSuperMacro.java
@@ -36,13 +36,13 @@ import org.jetbrains.kotlin.descriptors.ClassKind;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 
 import java.util.ArrayList;
 import java.util.LinkedHashSet;
@@ -91,18 +91,18 @@ public class JetAnonymousSuperMacro extends Macro {
         PsiDocumentManager.getInstance(project).commitAllDocuments();
 
         PsiFile psiFile = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument());
-        if (!(psiFile instanceof JetFile)) return null;
+        if (!(psiFile instanceof KtFile)) return null;
 
-        JetExpression expression = PsiTreeUtil.getParentOfType(psiFile.findElementAt(context.getStartOffset()), JetExpression.class);
+        KtExpression expression = PsiTreeUtil.getParentOfType(psiFile.findElementAt(context.getStartOffset()), KtExpression.class);
         if (expression == null) return null;
 
         BindingContext bc = ResolutionUtils.analyze(expression, BodyResolveMode.FULL);
-        JetScope scope = bc.get(BindingContext.RESOLUTION_SCOPE, expression);
+        KtScope scope = bc.get(BindingContext.RESOLUTION_SCOPE, expression);
         if (scope == null) return null;
 
         List<PsiNamedElement> result = new ArrayList<PsiNamedElement>();
 
-        for (DeclarationDescriptor descriptor : scope.getDescriptors(DescriptorKindFilter.NON_SINGLETON_CLASSIFIERS, JetScope.Companion.getALL_NAME_FILTER())) {
+        for (DeclarationDescriptor descriptor : scope.getDescriptors(DescriptorKindFilter.NON_SINGLETON_CLASSIFIERS, KtScope.Companion.getALL_NAME_FILTER())) {
             if (!(descriptor instanceof ClassDescriptor)) continue;
             ClassDescriptor classDescriptor = (ClassDescriptor) descriptor;
             if (!classDescriptor.getModality().isOverridable()) continue;
diff --git a/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/JetFunctionParametersMacro.java b/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/JetFunctionParametersMacro.java
index 449c0cff5c0..e16772faf01 100644
--- a/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/JetFunctionParametersMacro.java
+++ b/idea/src/org/jetbrains/kotlin/idea/liveTemplates/macro/JetFunctionParametersMacro.java
@@ -23,8 +23,8 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.JetBundle;
-import org.jetbrains.kotlin.psi.JetFunction;
-import org.jetbrains.kotlin.psi.JetParameter;
+import org.jetbrains.kotlin.psi.KtFunction;
+import org.jetbrains.kotlin.psi.KtParameter;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -52,9 +52,9 @@ public class JetFunctionParametersMacro extends Macro {
         if (file == null) return null;
         PsiElement place = file.findElementAt(offset);
         while (place != null){
-            if (place instanceof JetFunction) {
+            if (place instanceof KtFunction) {
                 List<Result> result = new ArrayList<Result>();
-                for (JetParameter param : ((JetFunction) place).getValueParameters()) {
+                for (KtParameter param : ((KtFunction) place).getValueParameters()) {
                     String name = param.getName();
                     assert name != null;
                     result.add(new TextResult(name));
diff --git a/idea/src/org/jetbrains/kotlin/idea/parameterInfo/KotlinFunctionParameterInfoHandler.kt b/idea/src/org/jetbrains/kotlin/idea/parameterInfo/KotlinFunctionParameterInfoHandler.kt
index 549f6cdc066..0abdfa76f68 100644
--- a/idea/src/org/jetbrains/kotlin/idea/parameterInfo/KotlinFunctionParameterInfoHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/parameterInfo/KotlinFunctionParameterInfoHandler.kt
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.core.OptionalParametersHelper
 import org.jetbrains.kotlin.idea.core.resolveCandidates
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.allChildren
 import org.jetbrains.kotlin.psi.psiUtil.parents
@@ -46,29 +46,29 @@ import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch
 import org.jetbrains.kotlin.resolve.calls.util.DelegatingCall
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasDefaultValue
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.typeUtil.containsError
 import java.awt.Color
 import java.util.*
 import kotlin.reflect.KClass
 
-class KotlinFunctionParameterInfoHandler : KotlinParameterInfoWithCallHandlerBase<JetValueArgumentList, JetValueArgument>(JetValueArgumentList::class, JetValueArgument::class) {
-    override fun getActualParameters(arguments: JetValueArgumentList) = arguments.arguments.toTypedArray()
+class KotlinFunctionParameterInfoHandler : KotlinParameterInfoWithCallHandlerBase<KtValueArgumentList, KtValueArgument>(KtValueArgumentList::class, KtValueArgument::class) {
+    override fun getActualParameters(arguments: KtValueArgumentList) = arguments.arguments.toTypedArray()
 
-    override fun getActualParametersRBraceType() = JetTokens.RPAR
+    override fun getActualParametersRBraceType() = KtTokens.RPAR
 
-    override fun getArgumentListAllowedParentClasses() = setOf(JetCallElement::class.java)
+    override fun getArgumentListAllowedParentClasses() = setOf(KtCallElement::class.java)
 }
 
-class KotlinArrayAccessParameterInfoHandler : KotlinParameterInfoWithCallHandlerBase<JetContainerNode, JetExpression>(JetContainerNode::class, JetExpression::class) {
-    override fun getArgumentListAllowedParentClasses() = setOf(JetArrayAccessExpression::class.java)
+class KotlinArrayAccessParameterInfoHandler : KotlinParameterInfoWithCallHandlerBase<KtContainerNode, KtExpression>(KtContainerNode::class, KtExpression::class) {
+    override fun getArgumentListAllowedParentClasses() = setOf(KtArrayAccessExpression::class.java)
 
-    override fun getActualParameters(containerNode: JetContainerNode): Array<out JetExpression> = containerNode.allChildren.filterIsInstance<JetExpression>().toList().toTypedArray()
+    override fun getActualParameters(containerNode: KtContainerNode): Array<out KtExpression> = containerNode.allChildren.filterIsInstance<KtExpression>().toList().toTypedArray()
 
-    override fun getActualParametersRBraceType() = JetTokens.RBRACKET
+    override fun getActualParametersRBraceType() = KtTokens.RBRACKET
 }
 
-abstract class KotlinParameterInfoWithCallHandlerBase<TArgumentList : JetElement, TArgument : JetElement>(
+abstract class KotlinParameterInfoWithCallHandlerBase<TArgumentList : KtElement, TArgument : KtElement>(
         private val argumentListClass: KClass<TArgumentList>,
         private val argumentClass: KClass<TArgument>
 ) : ParameterInfoHandlerWithTabActionSupport<TArgumentList, FunctionDescriptor, TArgument> {
@@ -78,12 +78,12 @@ abstract class KotlinParameterInfoWithCallHandlerBase<TArgumentList : JetElement
     }
 
     private fun findCall(argumentList: TArgumentList, bindingContext: BindingContext): Call? {
-        return (argumentList.parent as JetElement).getCall(bindingContext)
+        return (argumentList.parent as KtElement).getCall(bindingContext)
     }
 
-    override fun getActualParameterDelimiterType() = JetTokens.COMMA
+    override fun getActualParameterDelimiterType() = KtTokens.COMMA
 
-    override fun getArgListStopSearchClasses() = setOf(JetNamedFunction::class.java, JetVariableDeclaration::class.java)
+    override fun getArgListStopSearchClasses() = setOf(KtNamedFunction::class.java, KtVariableDeclaration::class.java)
 
     override fun getArgumentListClass() = argumentListClass.java
 
@@ -106,7 +106,7 @@ abstract class KotlinParameterInfoWithCallHandlerBase<TArgumentList : JetElement
 
     override fun findElementForParameterInfo(context: CreateParameterInfoContext): TArgumentList? {
         //todo: calls to this constructors, when we will have auxiliary constructors
-        val file = context.file as? JetFile ?: return null
+        val file = context.file as? KtFile ?: return null
 
         val token = file.findElementAt(context.offset) ?: return null
         val argumentList = PsiTreeUtil.getParentOfType(token, argumentListClass.java) ?: return null
@@ -128,7 +128,7 @@ abstract class KotlinParameterInfoWithCallHandlerBase<TArgumentList : JetElement
         val offset = context.offset
         val parameterIndex = argumentList.allChildren
                 .takeWhile { it.startOffset < offset }
-                .count { it.node.elementType == JetTokens.COMMA }
+                .count { it.node.elementType == KtTokens.COMMA }
         context.setCurrentParameter(parameterIndex)
     }
 
@@ -264,7 +264,7 @@ abstract class KotlinParameterInfoWithCallHandlerBase<TArgumentList : JetElement
                 return text
             }
 
-            if (expression is JetConstantExpression || expression is JetStringTemplateExpression) {
+            if (expression is KtConstantExpression || expression is KtStringTemplateExpression) {
                 if (text.startsWith("\"")) {
                     return "\"...\""
                 }
@@ -276,7 +276,7 @@ abstract class KotlinParameterInfoWithCallHandlerBase<TArgumentList : JetElement
         return "..."
     }
 
-    private fun parameterTypeToRender(descriptor: ValueParameterDescriptor): JetType {
+    private fun parameterTypeToRender(descriptor: ValueParameterDescriptor): KtType {
         var type = descriptor.varargElementType ?: descriptor.type
         if (type.containsError()) {
             val original = descriptor.original
@@ -325,10 +325,10 @@ abstract class KotlinParameterInfoWithCallHandlerBase<TArgumentList : JetElement
         else {
             // add dummy current argument if we don't have one
             currentArgument = object : ValueArgument {
-                override fun getArgumentExpression(): JetExpression? = null
+                override fun getArgumentExpression(): KtExpression? = null
                 override fun getArgumentName(): ValueArgumentName? = null
                 override fun isNamed(): Boolean = false
-                override fun asElement(): JetElement = call.callElement // is a hack but what to do?
+                override fun asElement(): KtElement = call.callElement // is a hack but what to do?
                 override fun getSpreadElement(): LeafPsiElement? = null
                 override fun isExternal() = false
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/presentation/JetClassPresenter.java b/idea/src/org/jetbrains/kotlin/idea/presentation/JetClassPresenter.java
index 9308244c3f0..646128efcb2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/presentation/JetClassPresenter.java
+++ b/idea/src/org/jetbrains/kotlin/idea/presentation/JetClassPresenter.java
@@ -18,11 +18,11 @@ package org.jetbrains.kotlin.idea.presentation;
 
 import com.intellij.navigation.ItemPresentation;
 import com.intellij.navigation.ItemPresentationProvider;
-import org.jetbrains.kotlin.psi.JetClass;
+import org.jetbrains.kotlin.psi.KtClass;
 
-public class JetClassPresenter implements ItemPresentationProvider<JetClass> {
+public class JetClassPresenter implements ItemPresentationProvider<KtClass> {
     @Override
-    public ItemPresentation getPresentation(JetClass item) {
+    public ItemPresentation getPresentation(KtClass item) {
         return new JetDefaultNamedDeclarationPresentation(item);
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/presentation/JetDefaultNamedDeclarationPresentation.java b/idea/src/org/jetbrains/kotlin/idea/presentation/JetDefaultNamedDeclarationPresentation.java
index 7e69b262a81..d5614656673 100644
--- a/idea/src/org/jetbrains/kotlin/idea/presentation/JetDefaultNamedDeclarationPresentation.java
+++ b/idea/src/org/jetbrains/kotlin/idea/presentation/JetDefaultNamedDeclarationPresentation.java
@@ -22,21 +22,21 @@ import com.intellij.openapi.editor.colors.TextAttributesKey;
 import com.intellij.openapi.util.Iconable;
 import org.jetbrains.kotlin.idea.JetIconProvider;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetNamedDeclaration;
-import org.jetbrains.kotlin.psi.JetPsiUtil;
+import org.jetbrains.kotlin.psi.KtNamedDeclaration;
+import org.jetbrains.kotlin.psi.KtPsiUtil;
 
 import javax.swing.*;
 
 public class JetDefaultNamedDeclarationPresentation implements ColoredItemPresentation {
-    private final JetNamedDeclaration declaration;
+    private final KtNamedDeclaration declaration;
 
-    JetDefaultNamedDeclarationPresentation(JetNamedDeclaration declaration) {
+    JetDefaultNamedDeclarationPresentation(KtNamedDeclaration declaration) {
         this.declaration = declaration;
     }
 
     @Override
     public TextAttributesKey getTextAttributesKey() {
-        if (JetPsiUtil.isDeprecated(declaration)) {
+        if (KtPsiUtil.isDeprecated(declaration)) {
             return CodeInsightColors.DEPRECATED_ATTRIBUTES;
         }
         return null;
diff --git a/idea/src/org/jetbrains/kotlin/idea/presentation/JetFunctionPresenter.java b/idea/src/org/jetbrains/kotlin/idea/presentation/JetFunctionPresenter.java
index 95bcf5a79be..a1fe1179d11 100644
--- a/idea/src/org/jetbrains/kotlin/idea/presentation/JetFunctionPresenter.java
+++ b/idea/src/org/jetbrains/kotlin/idea/presentation/JetFunctionPresenter.java
@@ -27,21 +27,21 @@ import org.jetbrains.kotlin.psi.*;
 
 import java.util.Collection;
 
-public class JetFunctionPresenter implements ItemPresentationProvider<JetFunction> {
+public class JetFunctionPresenter implements ItemPresentationProvider<KtFunction> {
     @Override
-    public ItemPresentation getPresentation(@NotNull final JetFunction function) {
-        if (function instanceof JetFunctionLiteral) return null;
+    public ItemPresentation getPresentation(@NotNull final KtFunction function) {
+        if (function instanceof KtFunctionLiteral) return null;
 
         return new JetDefaultNamedDeclarationPresentation(function) {
             @Override
             public String getPresentableText() {
                 StringBuilder presentation = new StringBuilder(function.getName() != null ? function.getName() : "");
 
-                Collection<String> paramsStrings = Collections2.transform(function.getValueParameters(), new Function<JetParameter, String>() {
+                Collection<String> paramsStrings = Collections2.transform(function.getValueParameters(), new Function<KtParameter, String>() {
                     @Override
-                    public String apply(JetParameter parameter) {
+                    public String apply(KtParameter parameter) {
                         if (parameter != null) {
-                            JetTypeReference reference = parameter.getTypeReference();
+                            KtTypeReference reference = parameter.getTypeReference();
                             if (reference != null) {
                                 String text = reference.getText();
                                 if (text != null) {
@@ -60,14 +60,14 @@ public class JetFunctionPresenter implements ItemPresentationProvider<JetFunctio
 
             @Override
             public String getLocationString() {
-                if (function instanceof JetConstructor) {
-                    FqName name = ((JetConstructor) function).getContainingClassOrObject().getFqName();
+                if (function instanceof KtConstructor) {
+                    FqName name = ((KtConstructor) function).getContainingClassOrObject().getFqName();
                     return name != null ? String.format("(in %s)", name) : "";
                 }
 
                 FqName name = function.getFqName();
                 if (name != null) {
-                    JetTypeReference receiverTypeRef = function.getReceiverTypeReference();
+                    KtTypeReference receiverTypeRef = function.getReceiverTypeReference();
                     String extensionLocation = receiverTypeRef != null ? "for " + receiverTypeRef.getText() + " " : "";
                     return String.format("(%sin %s)", extensionLocation, name.parent());
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/presentation/JetObjectPresenter.java b/idea/src/org/jetbrains/kotlin/idea/presentation/JetObjectPresenter.java
index 6e732ab5678..93a8a39eaef 100644
--- a/idea/src/org/jetbrains/kotlin/idea/presentation/JetObjectPresenter.java
+++ b/idea/src/org/jetbrains/kotlin/idea/presentation/JetObjectPresenter.java
@@ -18,11 +18,11 @@ package org.jetbrains.kotlin.idea.presentation;
 
 import com.intellij.navigation.ItemPresentation;
 import com.intellij.navigation.ItemPresentationProvider;
-import org.jetbrains.kotlin.psi.JetObjectDeclaration;
+import org.jetbrains.kotlin.psi.KtObjectDeclaration;
 
-public class JetObjectPresenter implements ItemPresentationProvider<JetObjectDeclaration> {
+public class JetObjectPresenter implements ItemPresentationProvider<KtObjectDeclaration> {
     @Override
-    public ItemPresentation getPresentation(JetObjectDeclaration item) {
+    public ItemPresentation getPresentation(KtObjectDeclaration item) {
         return new JetDefaultNamedDeclarationPresentation(item);
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/presentation/JetParameterPresenter.java b/idea/src/org/jetbrains/kotlin/idea/presentation/JetParameterPresenter.java
index e46e576505c..f9c2bf462b3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/presentation/JetParameterPresenter.java
+++ b/idea/src/org/jetbrains/kotlin/idea/presentation/JetParameterPresenter.java
@@ -18,11 +18,11 @@ package org.jetbrains.kotlin.idea.presentation;
 
 import com.intellij.navigation.ItemPresentation;
 import com.intellij.navigation.ItemPresentationProvider;
-import org.jetbrains.kotlin.psi.JetParameter;
+import org.jetbrains.kotlin.psi.KtParameter;
 
-public class JetParameterPresenter implements ItemPresentationProvider<JetParameter> {
+public class JetParameterPresenter implements ItemPresentationProvider<KtParameter> {
     @Override
-    public ItemPresentation getPresentation(JetParameter item) {
+    public ItemPresentation getPresentation(KtParameter item) {
         return new JetDefaultNamedDeclarationPresentation(item);
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/presentation/JetPropertyPresenter.java b/idea/src/org/jetbrains/kotlin/idea/presentation/JetPropertyPresenter.java
index 4b18c033573..aa3ba92c506 100644
--- a/idea/src/org/jetbrains/kotlin/idea/presentation/JetPropertyPresenter.java
+++ b/idea/src/org/jetbrains/kotlin/idea/presentation/JetPropertyPresenter.java
@@ -18,11 +18,11 @@ package org.jetbrains.kotlin.idea.presentation;
 
 import com.intellij.navigation.ItemPresentation;
 import com.intellij.navigation.ItemPresentationProvider;
-import org.jetbrains.kotlin.psi.JetProperty;
+import org.jetbrains.kotlin.psi.KtProperty;
 
-public class JetPropertyPresenter implements ItemPresentationProvider<JetProperty> {
+public class JetPropertyPresenter implements ItemPresentationProvider<KtProperty> {
     @Override
-    public ItemPresentation getPresentation(JetProperty item) {
+    public ItemPresentation getPresentation(KtProperty item) {
         return new JetDefaultNamedDeclarationPresentation(item);
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/project/PluginJetFilesProvider.java b/idea/src/org/jetbrains/kotlin/idea/project/PluginJetFilesProvider.java
index 622045f41e5..67554c2b56f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/project/PluginJetFilesProvider.java
+++ b/idea/src/org/jetbrains/kotlin/idea/project/PluginJetFilesProvider.java
@@ -21,7 +21,7 @@ import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.stubindex.JetExactPackagesIndex;
 import org.jetbrains.kotlin.idea.stubindex.JetSourceFilterScope;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -29,8 +29,8 @@ import java.util.Collection;
 public class PluginJetFilesProvider  {
 
     @NotNull
-    public static Collection<JetFile> allFilesInProject(@NotNull Project project) {
-        Collection<JetFile> result = new ArrayList<JetFile>();
+    public static Collection<KtFile> allFilesInProject(@NotNull Project project) {
+        Collection<KtFile> result = new ArrayList<KtFile>();
         GlobalSearchScope scope = JetSourceFilterScope.kotlinSources(GlobalSearchScope.allScope(project), project);
         for (String packageWithFiles : JetExactPackagesIndex.getInstance().getAllKeys(project)) {
             result.addAll(JetExactPackagesIndex.getInstance().get(packageWithFiles, project, scope));
diff --git a/idea/src/org/jetbrains/kotlin/idea/projectView/JetClassOrObjectTreeNode.java b/idea/src/org/jetbrains/kotlin/idea/projectView/JetClassOrObjectTreeNode.java
index b29aa57b24d..6c6641d0639 100644
--- a/idea/src/org/jetbrains/kotlin/idea/projectView/JetClassOrObjectTreeNode.java
+++ b/idea/src/org/jetbrains/kotlin/idea/projectView/JetClassOrObjectTreeNode.java
@@ -24,17 +24,17 @@ import com.intellij.ide.util.treeView.AbstractTreeNode;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.kotlin.idea.JetIconProvider;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetPsiUtil;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtPsiUtil;
 
 import java.util.Collection;
 
 import static org.jetbrains.kotlin.idea.projectView.JetProjectViewUtil.canRepresentPsiElement;
 import static org.jetbrains.kotlin.idea.projectView.JetProjectViewUtil.getClassOrObjectChildren;
 
-public class JetClassOrObjectTreeNode extends AbstractPsiBasedNode<JetClassOrObject> {
-    protected JetClassOrObjectTreeNode(Project project, JetClassOrObject jetClassOrObject, ViewSettings viewSettings) {
-        super(project, jetClassOrObject, viewSettings);
+public class JetClassOrObjectTreeNode extends AbstractPsiBasedNode<KtClassOrObject> {
+    protected JetClassOrObjectTreeNode(Project project, KtClassOrObject ktClassOrObject, ViewSettings viewSettings) {
+        super(project, ktClassOrObject, viewSettings);
     }
 
     @Override
@@ -56,7 +56,7 @@ public class JetClassOrObjectTreeNode extends AbstractPsiBasedNode<JetClassOrObj
 
     @Override
     protected void updateImpl(PresentationData data) {
-        JetClassOrObject classOrObject = getValue();
+        KtClassOrObject classOrObject = getValue();
         if (classOrObject != null) {
             data.setPresentableText(classOrObject.getName());
 
@@ -76,7 +76,7 @@ public class JetClassOrObjectTreeNode extends AbstractPsiBasedNode<JetClassOrObj
 
     @Override
     protected boolean isDeprecated() {
-        return JetPsiUtil.isDeprecated(getValue());
+        return KtPsiUtil.isDeprecated(getValue());
     }
 
     @Override
diff --git a/idea/src/org/jetbrains/kotlin/idea/projectView/JetDeclarationTreeNode.java b/idea/src/org/jetbrains/kotlin/idea/projectView/JetDeclarationTreeNode.java
index 17d30bd7c77..ecd0e97ae1f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/projectView/JetDeclarationTreeNode.java
+++ b/idea/src/org/jetbrains/kotlin/idea/projectView/JetDeclarationTreeNode.java
@@ -30,11 +30,11 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
-public class JetDeclarationTreeNode extends AbstractPsiBasedNode<JetDeclaration> {
+public class JetDeclarationTreeNode extends AbstractPsiBasedNode<KtDeclaration> {
     public static final String CLASS_INITIALIZER = "<class initializer>";
 
-    protected JetDeclarationTreeNode(Project project, JetDeclaration jetDeclaration, ViewSettings viewSettings) {
-        super(project, jetDeclaration, viewSettings);
+    protected JetDeclarationTreeNode(Project project, KtDeclaration ktDeclaration, ViewSettings viewSettings) {
+        super(project, ktDeclaration, viewSettings);
     }
 
     @Override
@@ -49,17 +49,17 @@ public class JetDeclarationTreeNode extends AbstractPsiBasedNode<JetDeclaration>
 
     @Override
     protected void updateImpl(PresentationData data) {
-        JetDeclaration declaration = getValue();
+        KtDeclaration declaration = getValue();
         if (declaration != null) {
-            String text = declaration instanceof JetClassInitializer ? CLASS_INITIALIZER : declaration.getName();
+            String text = declaration instanceof KtClassInitializer ? CLASS_INITIALIZER : declaration.getName();
             if (text == null) return;
 
             JetCodeStyleSettings settings = CodeStyleSettingsManager.getInstance(getProject()).getCurrentSettings()
                     .getCustomSettings(JetCodeStyleSettings.class);
 
-            if (declaration instanceof JetProperty) {
-                JetProperty property = (JetProperty) declaration;
-                JetTypeReference ref = property.getTypeReference();
+            if (declaration instanceof KtProperty) {
+                KtProperty property = (KtProperty) declaration;
+                KtTypeReference ref = property.getTypeReference();
                 if (ref != null) {
                     if (settings.SPACE_BEFORE_TYPE_COLON) text += " ";
                     text += ":";
@@ -67,22 +67,22 @@ public class JetDeclarationTreeNode extends AbstractPsiBasedNode<JetDeclaration>
                     text += ref.getText();
                 }
             }
-            else if (declaration instanceof JetFunction) {
-                JetFunction function = (JetFunction) declaration;
-                JetTypeReference receiverTypeRef = function.getReceiverTypeReference();
+            else if (declaration instanceof KtFunction) {
+                KtFunction function = (KtFunction) declaration;
+                KtTypeReference receiverTypeRef = function.getReceiverTypeReference();
                 if (receiverTypeRef != null) {
                     text = receiverTypeRef.getText() + "." + text;
                 }
                 text += "(";
-                List<JetParameter> parameters = function.getValueParameters();
-                for (JetParameter parameter : parameters) {
+                List<KtParameter> parameters = function.getValueParameters();
+                for (KtParameter parameter : parameters) {
                     if (parameter.getName() != null) {
                         text += parameter.getName();
                         if (settings.SPACE_BEFORE_TYPE_COLON) text += " ";
                         text += ":";
                         if (settings.SPACE_AFTER_TYPE_COLON) text += " ";
                     }
-                    JetTypeReference typeReference = parameter.getTypeReference();
+                    KtTypeReference typeReference = parameter.getTypeReference();
                     if (typeReference != null) {
                         text += typeReference.getText();
                     }
@@ -90,7 +90,7 @@ public class JetDeclarationTreeNode extends AbstractPsiBasedNode<JetDeclaration>
                 }
                 if (parameters.size() > 0) text = text.substring(0, text.length() - 2);
                 text += ")";
-                JetTypeReference typeReference = function.getTypeReference();
+                KtTypeReference typeReference = function.getTypeReference();
                 if (typeReference != null) {
                     if (settings.SPACE_BEFORE_TYPE_COLON) text += " ";
                     text += ":";
@@ -105,6 +105,6 @@ public class JetDeclarationTreeNode extends AbstractPsiBasedNode<JetDeclaration>
 
     @Override
     protected boolean isDeprecated() {
-        return JetPsiUtil.isDeprecated(getValue());
+        return KtPsiUtil.isDeprecated(getValue());
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/projectView/JetFileTreeNode.java b/idea/src/org/jetbrains/kotlin/idea/projectView/JetFileTreeNode.java
index 9c65404fd8e..fde48149e2c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/projectView/JetFileTreeNode.java
+++ b/idea/src/org/jetbrains/kotlin/idea/projectView/JetFileTreeNode.java
@@ -20,9 +20,9 @@ import com.intellij.ide.projectView.ViewSettings;
 import com.intellij.ide.projectView.impl.nodes.PsiFileNode;
 import com.intellij.ide.util.treeView.AbstractTreeNode;
 import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetDeclaration;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtFile;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -30,23 +30,23 @@ import java.util.Collections;
 import java.util.List;
 
 public class JetFileTreeNode extends PsiFileNode {
-    public JetFileTreeNode(Project project, JetFile value, ViewSettings viewSettings) {
+    public JetFileTreeNode(Project project, KtFile value, ViewSettings viewSettings) {
         super(project, value, viewSettings);
     }
 
     @Override
     public Collection<AbstractTreeNode> getChildrenImpl() {
-        JetFile file = (JetFile) getValue();
+        KtFile file = (KtFile) getValue();
 
         if (file == null) return Collections.emptyList();
         ArrayList<AbstractTreeNode> result = new ArrayList<AbstractTreeNode>();
 
         if (getSettings().isShowMembers()) {
-            List<JetDeclaration> declarations = file.getDeclarations();
+            List<KtDeclaration> declarations = file.getDeclarations();
 
-            for (JetDeclaration declaration : declarations) {
-                if (declaration instanceof JetClassOrObject) {
-                    result.add(new JetClassOrObjectTreeNode(file.getProject(), (JetClassOrObject) declaration, getSettings()));
+            for (KtDeclaration declaration : declarations) {
+                if (declaration instanceof KtClassOrObject) {
+                    result.add(new JetClassOrObjectTreeNode(file.getProject(), (KtClassOrObject) declaration, getSettings()));
                 }
                 else if (getSettings().isShowMembers()) {
                     result.add(new JetDeclarationTreeNode(getProject(), declaration, getSettings()));
diff --git a/idea/src/org/jetbrains/kotlin/idea/projectView/JetProjectViewProvider.java b/idea/src/org/jetbrains/kotlin/idea/projectView/JetProjectViewProvider.java
index 4ce1a921714..07b6347eba6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/projectView/JetProjectViewProvider.java
+++ b/idea/src/org/jetbrains/kotlin/idea/projectView/JetProjectViewProvider.java
@@ -27,10 +27,10 @@ import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.kotlin.idea.JetIconProvider;
-import org.jetbrains.kotlin.psi.JetClassBody;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetDeclaration;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtClassBody;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtFile;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -50,11 +50,11 @@ public class JetProjectViewProvider implements SelectableTreeStructureProvider,
         for (AbstractTreeNode child : children) {
             Object childValue = child.getValue();
 
-            if (childValue instanceof JetFile) {
-                JetFile file = (JetFile) childValue;
-                List<JetDeclaration> declarations = file.getDeclarations();
+            if (childValue instanceof KtFile) {
+                KtFile file = (KtFile) childValue;
+                List<KtDeclaration> declarations = file.getDeclarations();
 
-                JetClassOrObject mainClass = JetIconProvider.getMainClass(file);
+                KtClassOrObject mainClass = JetIconProvider.getMainClass(file);
                 if (mainClass != null && declarations.size() == 1) {
                     result.add(new JetClassOrObjectTreeNode(file.getProject(), mainClass, settings));
                 }
@@ -79,7 +79,7 @@ public class JetProjectViewProvider implements SelectableTreeStructureProvider,
     @Override
     public PsiElement getTopLevelElement(PsiElement element) {
         PsiFile file = element.getContainingFile();
-        if (file == null || !(file instanceof JetFile)) return null;
+        if (file == null || !(file instanceof KtFile)) return null;
 
         VirtualFile virtualFile = file.getVirtualFile();
         if (!fileInRoots(virtualFile)) return file;
@@ -90,10 +90,10 @@ public class JetProjectViewProvider implements SelectableTreeStructureProvider,
             current = current.getParent();
         }
 
-        if (current instanceof JetFile) {
-            List<JetDeclaration> declarations = ((JetFile) current).getDeclarations();
+        if (current instanceof KtFile) {
+            List<KtDeclaration> declarations = ((KtFile) current).getDeclarations();
             String nameWithoutExtension = virtualFile != null ? virtualFile.getNameWithoutExtension() : file.getName();
-            if (declarations.size() == 1 && declarations.get(0) instanceof JetClassOrObject &&
+            if (declarations.size() == 1 && declarations.get(0) instanceof KtClassOrObject &&
                 nameWithoutExtension.equals(declarations.get(0).getName())) {
                 current = declarations.get(0);
             }
@@ -103,15 +103,15 @@ public class JetProjectViewProvider implements SelectableTreeStructureProvider,
     }
 
     private static boolean isSelectable(PsiElement element) {
-        if (element instanceof JetFile) return true;
-        if (element instanceof JetDeclaration) {
+        if (element instanceof KtFile) return true;
+        if (element instanceof KtDeclaration) {
             PsiElement parent = element.getParent();
-            if (parent instanceof JetFile) {
+            if (parent instanceof KtFile) {
                 return true;
             }
-            else if (parent instanceof JetClassBody) {
+            else if (parent instanceof KtClassBody) {
                 parent = parent.getParent();
-                if (parent instanceof JetClassOrObject) {
+                if (parent instanceof KtClassOrObject) {
                     return isSelectable(parent);
                 }
                 else return false;
diff --git a/idea/src/org/jetbrains/kotlin/idea/projectView/JetProjectViewUtil.java b/idea/src/org/jetbrains/kotlin/idea/projectView/JetProjectViewUtil.java
index e833fb60864..62c708b02dd 100644
--- a/idea/src/org/jetbrains/kotlin/idea/projectView/JetProjectViewUtil.java
+++ b/idea/src/org/jetbrains/kotlin/idea/projectView/JetProjectViewUtil.java
@@ -21,8 +21,8 @@ import com.intellij.ide.util.treeView.AbstractTreeNode;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetDeclaration;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtDeclaration;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -34,14 +34,15 @@ public final class JetProjectViewUtil {
     private JetProjectViewUtil() {
     }
 
-    public static Collection<AbstractTreeNode> getClassOrObjectChildren(JetClassOrObject classOrObject, Project project,
+    public static Collection<AbstractTreeNode> getClassOrObjectChildren(
+            KtClassOrObject classOrObject, Project project,
                                                                         ViewSettings settings) {
         if (classOrObject != null && settings.isShowMembers()) {
             Collection<AbstractTreeNode> result = new ArrayList<AbstractTreeNode>();
-            List<JetDeclaration> declarations = classOrObject.getDeclarations();
-            for (JetDeclaration declaration : declarations) {
-                if (declaration instanceof JetClassOrObject) {
-                    result.add(new JetClassOrObjectTreeNode(project, (JetClassOrObject) declaration, settings));
+            List<KtDeclaration> declarations = classOrObject.getDeclarations();
+            for (KtDeclaration declaration : declarations) {
+                if (declaration instanceof KtClassOrObject) {
+                    result.add(new JetClassOrObjectTreeNode(project, (KtClassOrObject) declaration, settings));
                 }
                 else {
                     result.add(new JetDeclarationTreeNode(project, declaration, settings));
diff --git a/idea/src/org/jetbrains/kotlin/idea/projectView/KotlinProblemFileHighlightFilter.kt b/idea/src/org/jetbrains/kotlin/idea/projectView/KotlinProblemFileHighlightFilter.kt
index 790d9cc895f..3e3e0d35b0b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/projectView/KotlinProblemFileHighlightFilter.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/projectView/KotlinProblemFileHighlightFilter.kt
@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.idea.projectView
 
 import com.intellij.openapi.util.Condition
 import com.intellij.openapi.vfs.VirtualFile
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 
 public class KotlinProblemFileHighlightFilter : Condition<VirtualFile> {
-    override fun value(t: VirtualFile): Boolean = t.fileType == JetFileType.INSTANCE
+    override fun value(t: VirtualFile): Boolean = t.fileType == KotlinFileType.INSTANCE
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/properties/KotlinPropertiesReferenceContributor.kt b/idea/src/org/jetbrains/kotlin/idea/properties/KotlinPropertiesReferenceContributor.kt
index 43762317514..cd0e134b58f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/properties/KotlinPropertiesReferenceContributor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/properties/KotlinPropertiesReferenceContributor.kt
@@ -19,18 +19,18 @@ package org.jetbrains.kotlin.idea.properties
 import com.intellij.patterns.PlatformPatterns
 import com.intellij.psi.PsiReferenceContributor
 import com.intellij.psi.PsiReferenceRegistrar
-import org.jetbrains.kotlin.psi.JetLiteralStringTemplateEntry
-import org.jetbrains.kotlin.psi.JetStringTemplateExpression
+import org.jetbrains.kotlin.psi.KtLiteralStringTemplateEntry
+import org.jetbrains.kotlin.psi.KtStringTemplateExpression
 
 public class KotlinPropertiesReferenceContributor : PsiReferenceContributor() {
     override fun registerReferenceProviders(registrar: PsiReferenceRegistrar) {
         registrar.registerReferenceProvider(
-                PlatformPatterns.psiElement(JetStringTemplateExpression::class.java),
+                PlatformPatterns.psiElement(KtStringTemplateExpression::class.java),
                 KotlinPropertyKeyReferenceProvider
         )
 
         registrar.registerReferenceProvider(
-                PlatformPatterns.psiElement(JetStringTemplateExpression::class.java),
+                PlatformPatterns.psiElement(KtStringTemplateExpression::class.java),
                 KotlinResourceBundleNameReferenceProvider
         )
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/properties/referenceProviders.kt b/idea/src/org/jetbrains/kotlin/idea/properties/referenceProviders.kt
index 6420d69c00d..09bbd6c1e03 100644
--- a/idea/src/org/jetbrains/kotlin/idea/properties/referenceProviders.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/properties/referenceProviders.kt
@@ -60,15 +60,15 @@ private fun DeclarationDescriptor.getBundleNameByAnnotation(): String? {
     return (annotations.findAnnotation(PROPERTY_KEY) ?: annotations.findExternalAnnotation(PROPERTY_KEY))?.getBundleName()
 }
 
-private fun JetExpression.getBundleNameByContext(): String? {
-    val expression = JetPsiUtil.safeDeparenthesize(this)
+private fun KtExpression.getBundleNameByContext(): String? {
+    val expression = KtPsiUtil.safeDeparenthesize(this)
     val parent = expression.parent
 
-    (parent as? JetProperty)?.let { return it.resolveToDescriptor().getBundleNameByAnnotation() }
+    (parent as? KtProperty)?.let { return it.resolveToDescriptor().getBundleNameByAnnotation() }
 
     val bindingContext = expression.analyze(BodyResolveMode.PARTIAL)
     val resolvedCall =
-            if (parent is JetQualifiedExpression && expression == parent.receiverExpression) {
+            if (parent is KtQualifiedExpression && expression == parent.receiverExpression) {
                 parent.selectorExpression.getResolvedCall(bindingContext)
             }
             else {
@@ -89,35 +89,35 @@ private fun JetExpression.getBundleNameByContext(): String? {
             ?.getBundleNameByAnnotation()
 }
 
-private fun JetAnnotationEntry.getPropertyKeyResolvedCall(): ResolvedCall<*>? {
+private fun KtAnnotationEntry.getPropertyKeyResolvedCall(): ResolvedCall<*>? {
     val resolvedCall = getResolvedCall(analyze(BodyResolveMode.PARTIAL)) ?: return null
     val klass = (resolvedCall.resultingDescriptor as? ConstructorDescriptor)?.containingDeclaration ?: return null
     if (klass.kind != ClassKind.ANNOTATION_CLASS || klass.importableFqName != PROPERTY_KEY) return null
     return resolvedCall
 }
 
-private fun JetStringTemplateExpression.isBundleName(): Boolean {
-    val parent = JetPsiUtil.safeDeparenthesize(this).parent
+private fun KtStringTemplateExpression.isBundleName(): Boolean {
+    val parent = KtPsiUtil.safeDeparenthesize(this).parent
     when (parent) {
-        is JetValueArgument -> {
-            val resolvedCall = parent.getStrictParentOfType<JetAnnotationEntry>()?.getPropertyKeyResolvedCall() ?: return false
+        is KtValueArgument -> {
+            val resolvedCall = parent.getStrictParentOfType<KtAnnotationEntry>()?.getPropertyKeyResolvedCall() ?: return false
             val valueParameter = (resolvedCall.getArgumentMapping(parent) as? ArgumentMatch)?.valueParameter ?: return false
             if (valueParameter.name != PROPERTY_KEY_RESOURCE_BUNDLE) return false
 
             return true
         }
 
-        is JetProperty -> {
+        is KtProperty -> {
             val contexts = (parent.useScope as? LocalSearchScope)?.scope ?: arrayOf(parent.containingFile)
             return contexts.any {
-                it.anyDescendantOfType<JetAnnotationEntry> f@ { entry ->
+                it.anyDescendantOfType<KtAnnotationEntry> f@ { entry ->
                     if (!entry.valueArguments.any { it.getArgumentName()?.asName == PROPERTY_KEY_RESOURCE_BUNDLE }) return@f false
                     val resolvedCall = entry.getPropertyKeyResolvedCall() ?: return@f false
                     val parameter = resolvedCall.resultingDescriptor.valueParameters.singleOrNull { it.name == PROPERTY_KEY_RESOURCE_BUNDLE }
                                     ?: return@f false
                     val valueArgument = resolvedCall.valueArguments[parameter] as? ExpressionValueArgument ?: return@f false
                     val bundleNameExpression = valueArgument.valueArgument?.getArgumentExpression() ?: return@f false
-                    bundleNameExpression is JetSimpleNameExpression && bundleNameExpression.mainReference.resolve() == parent
+                    bundleNameExpression is KtSimpleNameExpression && bundleNameExpression.mainReference.resolve() == parent
                 }
             }
         }
@@ -128,7 +128,7 @@ private fun JetStringTemplateExpression.isBundleName(): Boolean {
 
 public object KotlinPropertyKeyReferenceProvider : PsiReferenceProvider() {
     override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<out PsiReference> {
-        if (!(element is JetStringTemplateExpression && element.isPlain())) return PsiReference.EMPTY_ARRAY
+        if (!(element is KtStringTemplateExpression && element.isPlain())) return PsiReference.EMPTY_ARRAY
         val bundleName = element.getBundleNameByContext() ?: return PsiReference.EMPTY_ARRAY
         return arrayOf(PropertyReference(ElementManipulators.getValueText(element), element, bundleName, false))
     }
@@ -136,7 +136,7 @@ public object KotlinPropertyKeyReferenceProvider : PsiReferenceProvider() {
 
 public object KotlinResourceBundleNameReferenceProvider : PsiReferenceProvider() {
     override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<out PsiReference> {
-        if (!(element is JetStringTemplateExpression && element.isPlain() && element.isBundleName())) return PsiReference.EMPTY_ARRAY
+        if (!(element is KtStringTemplateExpression && element.isPlain() && element.isBundleName())) return PsiReference.EMPTY_ARRAY
         return arrayOf(ResourceBundleReference(element))
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddConstModifierFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddConstModifierFix.kt
index 3100cd54f79..1b89b6f284a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddConstModifierFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddConstModifierFix.kt
@@ -31,40 +31,40 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingIntention
 import org.jetbrains.kotlin.idea.search.allScope
 import org.jetbrains.kotlin.idea.search.usagesSearch.descriptor
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetReferenceExpression
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtReferenceExpression
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.ConstModifierChecker
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.source.PsiSourceElement
 
-public class AddConstModifierFix(val property: JetProperty) : AddModifierFix(property, JetTokens.CONST_KEYWORD), CleanupFix {
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+public class AddConstModifierFix(val property: KtProperty) : AddModifierFix(property, KtTokens.CONST_KEYWORD), CleanupFix {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         addConstModifier(property)
     }
 
     companion object {
-        fun addConstModifier(property: JetProperty) {
+        fun addConstModifier(property: KtProperty) {
             replaceReferencesToGetterByReferenceToField(property)
-            property.addModifier(JetTokens.CONST_KEYWORD)
+            property.addModifier(KtTokens.CONST_KEYWORD)
         }
     }
 }
 
-public class AddConstModifierIntention : JetSelfTargetingIntention<JetProperty>(javaClass(), "Add 'const' modifier") {
-    override fun applyTo(element: JetProperty, editor: Editor) {
+public class AddConstModifierIntention : JetSelfTargetingIntention<KtProperty>(javaClass(), "Add 'const' modifier") {
+    override fun applyTo(element: KtProperty, editor: Editor) {
         AddConstModifierFix.addConstModifier(element)
     }
 
-    override fun isApplicableTo(element: JetProperty, caretOffset: Int): Boolean {
+    override fun isApplicableTo(element: KtProperty, caretOffset: Int): Boolean {
         return isApplicableTo(element)
     }
 
     companion object {
-        fun isApplicableTo(element: JetProperty): Boolean {
+        fun isApplicableTo(element: KtProperty): Boolean {
             if (element.isLocal || element.isVar || element.hasDelegate() || element.initializer == null
                     || element.getter?.hasBody() == true || element.receiverTypeReference != null) {
                 return false
@@ -78,10 +78,10 @@ public class AddConstModifierIntention : JetSelfTargetingIntention<JetProperty>(
 
 public object ConstFixFactory : JetSingleIntentionActionFactory() {
     override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-        val expr = diagnostic.psiElement as? JetReferenceExpression ?: return null
+        val expr = diagnostic.psiElement as? KtReferenceExpression ?: return null
         val bindingContext = expr.analyze(BodyResolveMode.PARTIAL)
         val targetDescriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, expr) as? VariableDescriptor ?: return null
-        val declaration = (targetDescriptor.source as? PsiSourceElement)?.psi as? JetProperty ?: return null
+        val declaration = (targetDescriptor.source as? PsiSourceElement)?.psi as? KtProperty ?: return null
         if (ConstModifierChecker.checkCanBeConst(declaration, declaration, targetDescriptor) == null) {
             return AddConstModifierFix(declaration)
         }
@@ -89,7 +89,7 @@ public object ConstFixFactory : JetSingleIntentionActionFactory() {
     }
 }
 
-fun replaceReferencesToGetterByReferenceToField(property: JetProperty) {
+fun replaceReferencesToGetterByReferenceToField(property: KtProperty) {
     val project = property.project
     val getter = LightClassUtil.getLightClassPropertyMethods(property).getter
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionBodyFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionBodyFix.java
index 7ff6154dffb..fa9b4ba6408 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionBodyFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionBodyFix.java
@@ -27,13 +27,13 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetFunction;
-import org.jetbrains.kotlin.psi.JetPsiFactory;
-import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtFunction;
+import org.jetbrains.kotlin.psi.KtPsiFactory;
+import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
 
-public class AddFunctionBodyFix extends KotlinQuickFixAction<JetFunction> {
-    public AddFunctionBodyFix(@NotNull JetFunction element) {
+public class AddFunctionBodyFix extends KotlinQuickFixAction<KtFunction> {
+    public AddFunctionBodyFix(@NotNull KtFunction element) {
         super(element);
     }
 
@@ -55,9 +55,9 @@ public class AddFunctionBodyFix extends KotlinQuickFixAction<JetFunction> {
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetFunction newElement = (JetFunction) getElement().copy();
-        JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(file);
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        KtFunction newElement = (KtFunction) getElement().copy();
+        KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(file);
         if (!(newElement.getLastChild() instanceof PsiWhiteSpace)) {
             newElement.add(psiFactory.createWhiteSpace());
         }
@@ -73,7 +73,7 @@ public class AddFunctionBodyFix extends KotlinQuickFixAction<JetFunction> {
             @Override
             public KotlinQuickFixAction createAction(Diagnostic diagnostic) {
                 PsiElement element = diagnostic.getPsiElement();
-                JetFunction function = PsiTreeUtil.getParentOfType(element, JetFunction.class, false);
+                KtFunction function = PsiTreeUtil.getParentOfType(element, KtFunction.class, false);
                 if (function == null) return null;
                 return new AddFunctionBodyFix(function);
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.kt
index d3b191e21e8..32bb3696c94 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.kt
@@ -27,21 +27,21 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.CollectingNameValidator
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.*
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
-import org.jetbrains.kotlin.psi.JetCallElement
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtCallElement
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.ValueArgument
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.KtType
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import java.util.*
 
 public class AddFunctionParametersFix(
-        private val callElement: JetCallElement,
+        private val callElement: KtCallElement,
         functionDescriptor: FunctionDescriptor,
         private val hasTypeMismatches: Boolean) : ChangeFunctionSignatureFix(callElement, functionDescriptor) {
-    private val typesToShorten = ArrayList<JetType>()
+    private val typesToShorten = ArrayList<KtType>()
 
     override fun getText(): String {
         val parameters = functionDescriptor.valueParameters
@@ -74,7 +74,7 @@ public class AddFunctionParametersFix(
         return newParametersCnt > 0
     }
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         runChangeSignature(project, functionDescriptor, addParameterConfiguration(), callElement, text)
     }
 
@@ -98,7 +98,7 @@ public class AddFunctionParametersFix(
                             }
                             val parameterType = parameters.get(i).type
 
-                            if (argumentType != null && !JetTypeChecker.DEFAULT.isSubtypeOf(argumentType, parameterType)) {
+                            if (argumentType != null && !KotlinTypeChecker.DEFAULT.isSubtypeOf(argumentType, parameterType)) {
                                 it.parameters.get(i).currentTypeText = IdeDescriptorRenderers.SOURCE_CODE.renderType(argumentType)
                                 typesToShorten.add(argumentType)
                             }
@@ -142,7 +142,7 @@ public class AddFunctionParametersFix(
 
     private fun hasOtherUsages(function: PsiElement): Boolean {
         return ReferencesSearch.search(function).any {
-            val call = it.element.getParentOfType<JetCallElement>(false)
+            val call = it.element.getParentOfType<KtCallElement>(false)
             call != null && callElement != call
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionToSupertypeFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionToSupertypeFix.kt
index 339fcbee780..f56916d140b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionToSupertypeFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionToSupertypeFix.kt
@@ -34,19 +34,19 @@ import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.types.KtType
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.typeUtil.supertypes
 import java.util.*
 
 class AddFunctionToSupertypeFix private constructor(
-        element: JetNamedFunction,
+        element: KtNamedFunction,
         private val functions: List<AddFunctionToSupertypeFix.FunctionData>
-) : KotlinQuickFixAction<JetNamedFunction>(element), LowPriorityAction {
+) : KotlinQuickFixAction<KtNamedFunction>(element), LowPriorityAction {
 
     init {
         assert(functions.isNotEmpty())
@@ -55,7 +55,7 @@ class AddFunctionToSupertypeFix private constructor(
     private class FunctionData(
             val signaturePreview: String,
             val sourceCode: String,
-            val targetClass: JetClass
+            val targetClass: KtClass
     )
 
     override fun getText(): String {
@@ -68,7 +68,7 @@ class AddFunctionToSupertypeFix private constructor(
 
     override fun getFamilyName() = "Add function to supertype"
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         CommandProcessor.getInstance().runUndoTransparentAction(object : Runnable {
             override fun run() {
                 if (functions.size == 1 || editor == null || !editor.component.isShowing) {
@@ -85,8 +85,8 @@ class AddFunctionToSupertypeFix private constructor(
         project.executeWriteCommand("Add Function to Type") {
             val classBody = functionData.targetClass.getOrCreateBody()
 
-            val functionElement = JetPsiFactory(project).createFunction(functionData.sourceCode)
-            val insertedFunctionElement = classBody.addBefore(functionElement, classBody.rBrace) as JetNamedFunction
+            val functionElement = KtPsiFactory(project).createFunction(functionData.sourceCode)
+            val insertedFunctionElement = classBody.addBefore(functionElement, classBody.rBrace) as KtNamedFunction
 
             ShortenReferences.DEFAULT.process(insertedFunctionElement)
         }
@@ -113,7 +113,7 @@ class AddFunctionToSupertypeFix private constructor(
 
     companion object: JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-            val function = diagnostic.psiElement as? JetNamedFunction ?: return null
+            val function = diagnostic.psiElement as? KtNamedFunction ?: return null
 
             val descriptors = generateFunctionsToAdd(function)
             if (descriptors.isEmpty()) return null
@@ -139,14 +139,14 @@ class AddFunctionToSupertypeFix private constructor(
                 }
             }
 
-            val targetClass = DescriptorToSourceUtilsIde.getAnyDeclaration(project, classDescriptor) as? JetClass ?: return null
+            val targetClass = DescriptorToSourceUtilsIde.getAnyDeclaration(project, classDescriptor) as? KtClass ?: return null
             return FunctionData(
                     IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.render(functionDescriptor),
                     sourceCode,
                     targetClass)
         }
 
-        private fun generateFunctionsToAdd(functionElement: JetNamedFunction): List<FunctionDescriptor> {
+        private fun generateFunctionsToAdd(functionElement: KtNamedFunction): List<FunctionDescriptor> {
             val functionDescriptor = functionElement.resolveToDescriptor() as FunctionDescriptor
 
             val containingClass = functionDescriptor.containingDeclaration as? ClassDescriptor ?: return emptyList()
@@ -158,12 +158,12 @@ class AddFunctionToSupertypeFix private constructor(
         }
 
         private fun getSuperClasses(classDescriptor: ClassDescriptor): List<ClassDescriptor> {
-            val supertypes = classDescriptor.defaultType.supertypes().sortedWith(object : Comparator<JetType> {
-                override fun compare(o1: JetType, o2: JetType): Int {
+            val supertypes = classDescriptor.defaultType.supertypes().sortedWith(object : Comparator<KtType> {
+                override fun compare(o1: KtType, o2: KtType): Int {
                     return when {
                         o1 == o2 -> 0
-                        JetTypeChecker.DEFAULT.isSubtypeOf(o1, o2) -> -1
-                        JetTypeChecker.DEFAULT.isSubtypeOf(o2, o1) -> 1
+                        KotlinTypeChecker.DEFAULT.isSubtypeOf(o1, o2) -> -1
+                        KotlinTypeChecker.DEFAULT.isSubtypeOf(o2, o1) -> 1
                         else -> o1.toString().compareTo(o2.toString())
                     }
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddGenericUpperBoundFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddGenericUpperBoundFix.kt
index 6103e377333..4fe14b5059b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddGenericUpperBoundFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddGenericUpperBoundFix.kt
@@ -25,22 +25,22 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetTypeParameter
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtTypeParameter
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintsUtil
 import org.jetbrains.kotlin.resolve.calls.inference.InferenceErrorData
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.utils.singletonOrEmptyList
 
 public class AddGenericUpperBoundFix(
-        typeParameter: JetTypeParameter,
-        upperBound: JetType
-) : KotlinQuickFixAction<JetTypeParameter>(typeParameter) {
+        typeParameter: KtTypeParameter,
+        upperBound: KtType
+) : KotlinQuickFixAction<KtTypeParameter>(typeParameter) {
     private val renderedUpperBound: String = IdeDescriptorRenderers.SOURCE_CODE.renderType(upperBound)
 
     override fun getText() = "Add '$renderedUpperBound' as upper bound for ${element.name}"
@@ -52,10 +52,10 @@ public class AddGenericUpperBoundFix(
         return (element.name != null && element.extendsBound == null)
     }
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         assert(element.extendsBound == null) { "Don't know what to do with existing bounds" }
 
-        val typeReference = JetPsiFactory(project).createType(renderedUpperBound)
+        val typeReference = KtPsiFactory(project).createType(renderedUpperBound)
         val insertedTypeReference = element.setExtendsBound(typeReference)!!
 
         ShortenReferences.DEFAULT.process(insertedTypeReference)
@@ -100,12 +100,12 @@ public class AddGenericUpperBoundFix(
             }.filterNotNull()
         }
 
-        private fun createAction(argument: JetType, upperBound: JetType): IntentionAction? {
+        private fun createAction(argument: KtType, upperBound: KtType): IntentionAction? {
             if (!upperBound.constructor.isDenotable) return null
 
             val typeParameterDescriptor = (argument.constructor.declarationDescriptor as? TypeParameterDescriptor) ?: return null
             val typeParameterDeclaration =
-                    (DescriptorToSourceUtils.getSourceFromDescriptor(typeParameterDescriptor) as? JetTypeParameter) ?: return null
+                    (DescriptorToSourceUtils.getSourceFromDescriptor(typeParameterDescriptor) as? KtTypeParameter) ?: return null
 
             return AddGenericUpperBoundFix(typeParameterDeclaration, upperBound)
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddLoopLabelFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddLoopLabelFix.kt
index 6a653d677b3..adf8a25c3fe 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddLoopLabelFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddLoopLabelFix.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.parents
 
-public class AddLoopLabelFix(loop: JetLoopExpression, val jumpExpression: JetElement): KotlinQuickFixAction<JetLoopExpression>(loop) {
+public class AddLoopLabelFix(loop: KtLoopExpression, val jumpExpression: KtElement): KotlinQuickFixAction<KtLoopExpression>(loop) {
     override fun getText() = "Add label to loop"
     override fun getFamilyName() = getText()
 
@@ -33,31 +33,31 @@ public class AddLoopLabelFix(loop: JetLoopExpression, val jumpExpression: JetEle
         return super.isAvailable(project, editor, file)
     }
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         val usedLabels = collectUsedLabels(element)
         val labelName = getUniqueLabelName(usedLabels)
 
-        val jumpWithLabel = JetPsiFactory(project).createExpression(jumpExpression.getText() + "@" + labelName)
+        val jumpWithLabel = KtPsiFactory(project).createExpression(jumpExpression.getText() + "@" + labelName)
         jumpExpression.replace(jumpWithLabel)
 
         // TODO(yole) use createExpressionByPattern() once it's available
-        val labeledLoopExpression = JetPsiFactory(project).createLabeledExpression(labelName)
+        val labeledLoopExpression = KtPsiFactory(project).createLabeledExpression(labelName)
         labeledLoopExpression.getBaseExpression()!!.replace(element)
         element.replace(labeledLoopExpression)
 
         // TODO(yole) We should initiate in-place rename for the label here, but in-place rename for labels is not yet implemented
     }
 
-    private fun collectUsedLabels(element: JetElement): Set<String> {
+    private fun collectUsedLabels(element: KtElement): Set<String> {
         val usedLabels = hashSetOf<String>()
-        element.acceptChildren(object : JetTreeVisitorVoid() {
-            override fun visitLabeledExpression(expression: JetLabeledExpression) {
+        element.acceptChildren(object : KtTreeVisitorVoid() {
+            override fun visitLabeledExpression(expression: KtLabeledExpression) {
                 super.visitLabeledExpression(expression)
                 usedLabels.add(expression.getLabelName()!!)
             }
         })
         element.parents.forEach {
-            if (it is JetLabeledExpression) {
+            if (it is KtLabeledExpression) {
                 usedLabels.add(it.getLabelName()!!)
             }
         }
@@ -75,10 +75,10 @@ public class AddLoopLabelFix(loop: JetLoopExpression, val jumpExpression: JetEle
 
     companion object: JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-            val element = diagnostic.getPsiElement() as? JetElement
-            assert(element is JetBreakExpression || element is JetContinueExpression)
-            assert((element as? JetLabeledExpression)?.getLabelName() == null)
-            val loop = element?.getStrictParentOfType<JetLoopExpression>() ?: return null
+            val element = diagnostic.getPsiElement() as? KtElement
+            assert(element is KtBreakExpression || element is KtContinueExpression)
+            assert((element as? KtLabeledExpression)?.getLabelName() == null)
+            val loop = element?.getStrictParentOfType<KtLoopExpression>() ?: return null
             return AddLoopLabelFix(loop, element!!)
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddModifierFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddModifierFix.java
index 5cc2900db73..3b2151a4d91 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddModifierFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddModifierFix.java
@@ -26,25 +26,25 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetModifierListOwner;
-import org.jetbrains.kotlin.psi.JetObjectDeclaration;
-import org.jetbrains.kotlin.psi.JetPropertyAccessor;
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtModifierListOwner;
+import org.jetbrains.kotlin.psi.KtObjectDeclaration;
+import org.jetbrains.kotlin.psi.KtPropertyAccessor;
 
-import static org.jetbrains.kotlin.lexer.JetTokens.ABSTRACT_KEYWORD;
+import static org.jetbrains.kotlin.lexer.KtTokens.ABSTRACT_KEYWORD;
 
-public class AddModifierFix extends KotlinQuickFixAction<JetModifierListOwner> {
-    @NotNull private final JetModifierKeywordToken modifier;
+public class AddModifierFix extends KotlinQuickFixAction<KtModifierListOwner> {
+    @NotNull private final KtModifierKeywordToken modifier;
 
-    public AddModifierFix(@NotNull JetModifierListOwner element, @NotNull JetModifierKeywordToken modifier) {
+    public AddModifierFix(@NotNull KtModifierListOwner element, @NotNull KtModifierKeywordToken modifier) {
         super(element);
         this.modifier = modifier;
     }
 
     @NotNull
-    /*package*/ static String getElementName(@NotNull JetModifierListOwner modifierListOwner) {
+    /*package*/ static String getElementName(@NotNull KtModifierListOwner modifierListOwner) {
         String name = null;
         if (modifierListOwner instanceof PsiNameIdentifierOwner) {
             PsiElement nameIdentifier = ((PsiNameIdentifierOwner) modifierListOwner).getNameIdentifier();
@@ -52,8 +52,8 @@ public class AddModifierFix extends KotlinQuickFixAction<JetModifierListOwner> {
                 name = nameIdentifier.getText();
             }
         }
-        else if (modifierListOwner instanceof JetPropertyAccessor) {
-            name = ((JetPropertyAccessor) modifierListOwner).getNamePlaceholder().getText();
+        else if (modifierListOwner instanceof KtPropertyAccessor) {
+            name = ((KtPropertyAccessor) modifierListOwner).getNamePlaceholder().getText();
         }
         if (name == null) {
             name = modifierListOwner.getText();
@@ -64,7 +64,7 @@ public class AddModifierFix extends KotlinQuickFixAction<JetModifierListOwner> {
     @NotNull
     @Override
     public String getText() {
-        if (modifier == ABSTRACT_KEYWORD || modifier == JetTokens.OPEN_KEYWORD) {
+        if (modifier == ABSTRACT_KEYWORD || modifier == KtTokens.OPEN_KEYWORD) {
             return JetBundle.message("make.element.modifier", getElementName(getElement()), modifier.getValue());
         }
         return JetBundle.message("add.modifier", modifier.getValue());
@@ -77,7 +77,7 @@ public class AddModifierFix extends KotlinQuickFixAction<JetModifierListOwner> {
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
         getElement().addModifier(modifier);
     }
 
@@ -86,23 +86,23 @@ public class AddModifierFix extends KotlinQuickFixAction<JetModifierListOwner> {
         return true;
     }
 
-    public static <T extends JetModifierListOwner> JetSingleIntentionActionFactory createFactory(final JetModifierKeywordToken modifier, final Class<T> modifierOwnerClass) {
+    public static <T extends KtModifierListOwner> JetSingleIntentionActionFactory createFactory(final KtModifierKeywordToken modifier, final Class<T> modifierOwnerClass) {
         return new JetSingleIntentionActionFactory() {
             @Override
             public IntentionAction createAction(Diagnostic diagnostic) {
-                JetModifierListOwner modifierListOwner = QuickFixUtil.getParentElementOfType(diagnostic, modifierOwnerClass);
+                KtModifierListOwner modifierListOwner = QuickFixUtil.getParentElementOfType(diagnostic, modifierOwnerClass);
                 if (modifierListOwner == null) return null;
 
-                if (modifier == JetTokens.ABSTRACT_KEYWORD &&
-                    modifierListOwner instanceof JetObjectDeclaration &&
-                    ((JetObjectDeclaration) modifierListOwner).isObjectLiteral()) return null;
+                if (modifier == KtTokens.ABSTRACT_KEYWORD &&
+                    modifierListOwner instanceof KtObjectDeclaration &&
+                    ((KtObjectDeclaration) modifierListOwner).isObjectLiteral()) return null;
 
                 return new AddModifierFix(modifierListOwner, modifier);
             }
         };
     }
 
-    public static JetSingleIntentionActionFactory createFactory(JetModifierKeywordToken modifier) {
-        return createFactory(modifier, JetModifierListOwner.class);
+    public static JetSingleIntentionActionFactory createFactory(KtModifierKeywordToken modifier) {
+        return createFactory(modifier, KtModifierListOwner.class);
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddNameToArgumentFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddNameToArgumentFix.kt
index 9c0dd361921..991e6f69e75 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddNameToArgumentFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddNameToArgumentFix.kt
@@ -25,20 +25,20 @@ import com.intellij.openapi.ui.popup.PopupStep
 import com.intellij.openapi.ui.popup.util.BaseListPopupStep
 import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.idea.JetIcons
+import org.jetbrains.kotlin.idea.KtIcons
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetCallElement
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetValueArgument
+import org.jetbrains.kotlin.psi.KtCallElement
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtValueArgument
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 
-public class AddNameToArgumentFix(argument: JetValueArgument) : KotlinQuickFixAction<JetValueArgument>(argument) {
+public class AddNameToArgumentFix(argument: KtValueArgument) : KotlinQuickFixAction<KtValueArgument>(argument) {
 
     override fun isAvailable(project: Project, editor: Editor?, file: PsiFile): Boolean {
         if (!super.isAvailable(project, editor, file)) return false
@@ -46,7 +46,7 @@ public class AddNameToArgumentFix(argument: JetValueArgument) : KotlinQuickFixAc
         return calculatePossibleArgumentNames().isNotEmpty()
     }
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         val possibleNames = calculatePossibleArgumentNames()
         assert(possibleNames.isNotEmpty()) { "isAvailable() should be checked before invoke()" }
         if (possibleNames.size() == 1 || editor == null || !editor.component.isShowing) {
@@ -67,7 +67,7 @@ public class AddNameToArgumentFix(argument: JetValueArgument) : KotlinQuickFixAc
     override fun getFamilyName() = "Add name to argument"
 
     private fun calculatePossibleArgumentNames(): List<Name> {
-        val callElement = element.getParentOfType<JetCallElement>(true) ?: return emptyList()
+        val callElement = element.getParentOfType<KtCallElement>(true) ?: return emptyList()
 
         val context = element.analyze(BodyResolveMode.PARTIAL)
         val resolvedCall = callElement.getResolvedCall(context) ?: return emptyList()
@@ -86,15 +86,15 @@ public class AddNameToArgumentFix(argument: JetValueArgument) : KotlinQuickFixAc
                 .map { it.name }
     }
 
-    private fun addName(project: Project, argument: JetValueArgument, name: Name) {
+    private fun addName(project: Project, argument: KtValueArgument, name: Name) {
         project.executeWriteCommand("Add name to argument") {
             argument.replace(createArgumentWithName(name))
         }
     }
 
-    private fun createArgumentWithName(name: Name): JetValueArgument {
+    private fun createArgumentWithName(name: Name): KtValueArgument {
         val argumentExpression = element.getArgumentExpression()!!
-        val newArgument = JetPsiFactory(element).createArgument(argumentExpression, name, element.getSpreadElement() != null)
+        val newArgument = KtPsiFactory(element).createArgument(argumentExpression, name, element.getSpreadElement() != null)
         return newArgument
     }
 
@@ -109,7 +109,7 @@ public class AddNameToArgumentFix(argument: JetValueArgument) : KotlinQuickFixAc
                 return PopupStep.FINAL_CHOICE
             }
 
-            override fun getIconFor(name: Name) = JetIcons.PARAMETER
+            override fun getIconFor(name: Name) = KtIcons.PARAMETER
 
             override fun getTextFor(name: Name) = createArgumentWithName(name).text
         }
@@ -117,7 +117,7 @@ public class AddNameToArgumentFix(argument: JetValueArgument) : KotlinQuickFixAc
 
     companion object : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-            val argument = diagnostic.psiElement.getParentOfType<JetValueArgument>(false) ?: return null
+            val argument = diagnostic.psiElement.getParentOfType<KtValueArgument>(false) ?: return null
             return AddNameToArgumentFix(argument)
         }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddOpenModifierToClassDeclarationFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddOpenModifierToClassDeclarationFix.java
index b18fb65ce8f..96ebad1cb48 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddOpenModifierToClassDeclarationFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddOpenModifierToClassDeclarationFix.java
@@ -30,13 +30,13 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
 import org.jetbrains.kotlin.idea.references.ReferenceUtilKt;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 
-public class AddOpenModifierToClassDeclarationFix extends KotlinQuickFixAction<JetTypeReference> {
-    private JetClass classDeclaration;
+public class AddOpenModifierToClassDeclarationFix extends KotlinQuickFixAction<KtTypeReference> {
+    private KtClass classDeclaration;
 
-    public AddOpenModifierToClassDeclarationFix(@NotNull JetTypeReference typeReference) {
+    public AddOpenModifierToClassDeclarationFix(@NotNull KtTypeReference typeReference) {
         super(typeReference);
     }
 
@@ -46,18 +46,18 @@ public class AddOpenModifierToClassDeclarationFix extends KotlinQuickFixAction<J
             return false;
         }
 
-        JetSimpleNameExpression referenceExpression = PsiTreeUtil.findChildOfType(getElement(), JetSimpleNameExpression.class);
+        KtSimpleNameExpression referenceExpression = PsiTreeUtil.findChildOfType(getElement(), KtSimpleNameExpression.class);
         if (referenceExpression == null) {
             return false;
         }
 
         PsiReference reference = ReferenceUtilKt.getMainReference(referenceExpression);
         PsiElement target = reference.resolve();
-        if (target instanceof JetSecondaryConstructor) {
-            target = ((JetSecondaryConstructor) target).getContainingClassOrObject();
+        if (target instanceof KtSecondaryConstructor) {
+            target = ((KtSecondaryConstructor) target).getContainingClassOrObject();
         }
-        if (target instanceof JetClass && QuickFixUtil.canModifyElement(target)) {
-            classDeclaration = (JetClass) target;
+        if (target instanceof KtClass && QuickFixUtil.canModifyElement(target)) {
+            classDeclaration = (KtClass) target;
             return !(classDeclaration.isEnum() || classDeclaration.isInterface());
         }
 
@@ -77,8 +77,8 @@ public class AddOpenModifierToClassDeclarationFix extends KotlinQuickFixAction<J
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        classDeclaration.addModifier(JetTokens.OPEN_KEYWORD);
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        classDeclaration.addModifier(KtTokens.OPEN_KEYWORD);
     }
 
     @NotNull
@@ -87,7 +87,7 @@ public class AddOpenModifierToClassDeclarationFix extends KotlinQuickFixAction<J
             @Nullable
             @Override
             public IntentionAction createAction(Diagnostic diagnostic) {
-                JetTypeReference typeReference = QuickFixUtil.getParentElementOfType(diagnostic, JetTypeReference.class);
+                KtTypeReference typeReference = QuickFixUtil.getParentElementOfType(diagnostic, KtTypeReference.class);
                 return typeReference == null ? null : new AddOpenModifierToClassDeclarationFix(typeReference);
             }
         };
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddOverrideToEqualsHashCodeToStringFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddOverrideToEqualsHashCodeToStringFix.java
index 2d0dd506726..bb976cad202 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddOverrideToEqualsHashCodeToStringFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddOverrideToEqualsHashCodeToStringFix.java
@@ -33,8 +33,8 @@ import org.jetbrains.kotlin.psi.*;
 import java.util.Collection;
 import java.util.List;
 
-import static org.jetbrains.kotlin.lexer.JetTokens.OVERRIDE_KEYWORD;
-import static org.jetbrains.kotlin.lexer.JetTokens.PUBLIC_KEYWORD;
+import static org.jetbrains.kotlin.lexer.KtTokens.OVERRIDE_KEYWORD;
+import static org.jetbrains.kotlin.lexer.KtTokens.PUBLIC_KEYWORD;
 
 public class AddOverrideToEqualsHashCodeToStringFix extends KotlinQuickFixAction<PsiElement> {
     public AddOverrideToEqualsHashCodeToStringFix(@NotNull PsiElement element) {
@@ -59,14 +59,14 @@ public class AddOverrideToEqualsHashCodeToStringFix extends KotlinQuickFixAction
     }
 
     private static boolean isEqualsHashCodeOrToString(@Nullable PsiElement element) {
-        if (!(element instanceof JetNamedFunction)) return false;
-        JetNamedFunction function = (JetNamedFunction) element;
+        if (!(element instanceof KtNamedFunction)) return false;
+        KtNamedFunction function = (KtNamedFunction) element;
         String name = function.getName();
 
         if ("equals".equals(name)) {
-            List<JetParameter> parameters = function.getValueParameters();
+            List<KtParameter> parameters = function.getValueParameters();
             if (parameters.size() != 1) return false;
-            JetTypeReference parameterType = parameters.iterator().next().getTypeReference();
+            KtTypeReference parameterType = parameters.iterator().next().getTypeReference();
             return parameterType != null && "Any?".equals(parameterType.getText());
         }
 
@@ -78,14 +78,14 @@ public class AddOverrideToEqualsHashCodeToStringFix extends KotlinQuickFixAction
     }
 
     @Override
-    protected void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        Collection<JetFile> files = PluginJetFilesProvider.allFilesInProject(file.getProject());
+    protected void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        Collection<KtFile> files = PluginJetFilesProvider.allFilesInProject(file.getProject());
 
-        for (JetFile jetFile : files) {
+        for (KtFile jetFile : files) {
             for (Diagnostic diagnostic : ResolutionUtils.analyzeFully(jetFile).getDiagnostics()) {
                 if (diagnostic.getFactory() != Errors.VIRTUAL_MEMBER_HIDDEN) continue;
 
-                JetModifierListOwner element = (JetModifierListOwner) diagnostic.getPsiElement();
+                KtModifierListOwner element = (KtModifierListOwner) diagnostic.getPsiElement();
                 if (!isEqualsHashCodeOrToString(element)) continue;
 
                 element.addModifier(OVERRIDE_KEYWORD);
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddStarProjectionsFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddStarProjectionsFix.java
index eb035b6908a..e10a8f29e6d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddStarProjectionsFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddStarProjectionsFix.java
@@ -32,11 +32,11 @@ import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.types.expressions.TypeReconstructionUtil;
 
-public abstract class AddStarProjectionsFix extends KotlinQuickFixAction<JetUserType> {
+public abstract class AddStarProjectionsFix extends KotlinQuickFixAction<KtUserType> {
 
     private final int argumentCount;
 
-    private AddStarProjectionsFix(@NotNull JetUserType element, int count) {
+    private AddStarProjectionsFix(@NotNull KtUserType element, int count) {
         super(element);
         argumentCount = count;
     }
@@ -54,11 +54,11 @@ public abstract class AddStarProjectionsFix extends KotlinQuickFixAction<JetUser
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
         assert getElement().getTypeArguments().isEmpty();
 
         String typeString = TypeReconstructionUtil.getTypeNameAndStarProjectionsString(getElement().getText(), argumentCount);
-        JetTypeElement replacement = JetPsiFactoryKt.JetPsiFactory(file).createType(typeString).getTypeElement();
+        KtTypeElement replacement = KtPsiFactoryKt.KtPsiFactory(file).createType(typeString).getTypeElement();
         assert replacement != null : "No type element after parsing " + typeString;
 
         getElement().replace(replacement);
@@ -73,15 +73,15 @@ public abstract class AddStarProjectionsFix extends KotlinQuickFixAction<JetUser
         return new JetSingleIntentionActionFactory() {
             @Override
             public IntentionAction createAction(Diagnostic diagnostic) {
-                DiagnosticWithParameters2<JetTypeReference, Integer, String> diagnosticWithParameters =
+                DiagnosticWithParameters2<KtTypeReference, Integer, String> diagnosticWithParameters =
                         Errors.NO_TYPE_ARGUMENTS_ON_RHS.cast(diagnostic);
-                JetTypeElement typeElement = diagnosticWithParameters.getPsiElement().getTypeElement();
-                while (typeElement instanceof JetNullableType) {
-                    typeElement = ((JetNullableType) typeElement).getInnerType();
+                KtTypeElement typeElement = diagnosticWithParameters.getPsiElement().getTypeElement();
+                while (typeElement instanceof KtNullableType) {
+                    typeElement = ((KtNullableType) typeElement).getInnerType();
                 }
-                if (!(typeElement instanceof JetUserType)) return null;
+                if (!(typeElement instanceof KtUserType)) return null;
                 Integer size = diagnosticWithParameters.getA();
-                return new AddStarProjectionsFix((JetUserType) typeElement, size) {};
+                return new AddStarProjectionsFix((KtUserType) typeElement, size) {};
             }
         };
     }
@@ -90,11 +90,11 @@ public abstract class AddStarProjectionsFix extends KotlinQuickFixAction<JetUser
         return new JetSingleIntentionActionFactory() {
             @Override
             public IntentionAction createAction(Diagnostic diagnostic) {
-                DiagnosticWithParameters1<JetElement, Integer> diagnosticWithParameters = Errors.WRONG_NUMBER_OF_TYPE_ARGUMENTS.cast(diagnostic);
+                DiagnosticWithParameters1<KtElement, Integer> diagnosticWithParameters = Errors.WRONG_NUMBER_OF_TYPE_ARGUMENTS.cast(diagnostic);
 
                 Integer size = diagnosticWithParameters.getA();
 
-                JetUserType userType = QuickFixUtil.getParentElementOfType(diagnostic, JetUserType.class);
+                KtUserType userType = QuickFixUtil.getParentElementOfType(diagnostic, KtUserType.class);
                 if (userType == null) return null;
 
                 return new AddStarProjectionsFix(userType, size) {
@@ -112,10 +112,10 @@ public abstract class AddStarProjectionsFix extends KotlinQuickFixAction<JetUser
 
                     private boolean isInsideJavaClassCall() {
                         PsiElement parent = getElement().getParent().getParent().getParent().getParent();
-                        if (parent instanceof JetCallExpression) {
-                            JetExpression calleeExpression = ((JetCallExpression) parent).getCalleeExpression();
-                            if (calleeExpression instanceof JetSimpleNameExpression) {
-                                JetSimpleNameExpression simpleNameExpression = (JetSimpleNameExpression) calleeExpression;
+                        if (parent instanceof KtCallExpression) {
+                            KtExpression calleeExpression = ((KtCallExpression) parent).getCalleeExpression();
+                            if (calleeExpression instanceof KtSimpleNameExpression) {
+                                KtSimpleNameExpression simpleNameExpression = (KtSimpleNameExpression) calleeExpression;
                                 // Resolve is expensive so we use a heuristic here: the case is rare enough not to be annoying
                                 return "javaClass".equals(simpleNameExpression.getReferencedName());
                             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddTypeToLHSOfCallableReferenceFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddTypeToLHSOfCallableReferenceFix.kt
index bbeb4a96e27..3f197e7d414 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddTypeToLHSOfCallableReferenceFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddTypeToLHSOfCallableReferenceFix.kt
@@ -23,33 +23,33 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences
-import org.jetbrains.kotlin.psi.JetCallableReferenceExpression
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 
 class AddTypeToLHSOfCallableReferenceFix(
-        expression: JetCallableReferenceExpression
-) : KotlinQuickFixAction<JetCallableReferenceExpression>(expression), CleanupFix {
+        expression: KtCallableReferenceExpression
+) : KotlinQuickFixAction<KtCallableReferenceExpression>(expression), CleanupFix {
     override fun getFamilyName() = "Add type to left-hand side"
     override fun getText() = familyName
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         val resolvedCall = element.callableReference.getResolvedCall(element.analyze(BodyResolveMode.PARTIAL)) ?: return
         val receiver = with(resolvedCall) {
             if (dispatchReceiver.exists()) dispatchReceiver
             else if (extensionReceiver.exists()) extensionReceiver
             else return
         }
-        val type = JetPsiFactory(project).createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(receiver.type))
+        val type = KtPsiFactory(project).createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(receiver.type))
         element.setTypeReference(type)
         ShortenReferences.DEFAULT.process(element)
     }
 
     companion object : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-            return AddTypeToLHSOfCallableReferenceFix(diagnostic.psiElement.parent as JetCallableReferenceExpression)
+            return AddTypeToLHSOfCallableReferenceFix(diagnostic.psiElement.parent as KtCallableReferenceExpression)
         }
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddWhenElseBranchFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddWhenElseBranchFix.java
index 00dabaa9259..aa76f5d3952 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddWhenElseBranchFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddWhenElseBranchFix.java
@@ -30,10 +30,10 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.psi.*;
 
-public class AddWhenElseBranchFix extends KotlinQuickFixAction<JetWhenExpression> {
+public class AddWhenElseBranchFix extends KotlinQuickFixAction<KtWhenExpression> {
     private static final String ELSE_ENTRY_TEXT = "else -> {}";
 
-    public AddWhenElseBranchFix(@NotNull JetWhenExpression element) {
+    public AddWhenElseBranchFix(@NotNull KtWhenExpression element) {
         super(element);
     }
 
@@ -56,17 +56,17 @@ public class AddWhenElseBranchFix extends KotlinQuickFixAction<JetWhenExpression
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
         PsiElement whenCloseBrace = getElement().getCloseBrace();
         assert (whenCloseBrace != null) : "isAvailable should check if close brace exist";
 
-        JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(file);
-        JetWhenEntry entry = psiFactory.createWhenEntry(ELSE_ENTRY_TEXT);
+        KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(file);
+        KtWhenEntry entry = psiFactory.createWhenEntry(ELSE_ENTRY_TEXT);
 
         PsiElement insertedBranch = getElement().addBefore(entry, whenCloseBrace);
         getElement().addAfter(psiFactory.createNewLine(), insertedBranch);
 
-        JetWhenEntry insertedWhenEntry = (JetWhenEntry) CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(insertedBranch);
+        KtWhenEntry insertedWhenEntry = (KtWhenEntry) CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(insertedBranch);
         TextRange textRange = insertedWhenEntry.getTextRange();
 
         int indexOfOpenBrace = insertedWhenEntry.getText().indexOf('{');
@@ -79,7 +79,7 @@ public class AddWhenElseBranchFix extends KotlinQuickFixAction<JetWhenExpression
             @Override
             public KotlinQuickFixAction createAction(@NotNull Diagnostic diagnostic) {
                 PsiElement element = diagnostic.getPsiElement();
-                JetWhenExpression whenExpression = PsiTreeUtil.getParentOfType(element, JetWhenExpression.class, false);
+                KtWhenExpression whenExpression = PsiTreeUtil.getParentOfType(element, KtWhenExpression.class, false);
                 if (whenExpression == null) return null;
                 return new AddWhenElseBranchFix(whenExpression);
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AutoImportFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AutoImportFix.kt
index bcb568d83c2..c306e7ca776 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AutoImportFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AutoImportFix.kt
@@ -41,9 +41,9 @@ import org.jetbrains.kotlin.idea.core.getResolutionScope
 import org.jetbrains.kotlin.idea.core.isVisible
 import org.jetbrains.kotlin.idea.project.ProjectStructureUtil
 import org.jetbrains.kotlin.idea.util.CallTypeAndReceiver
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetPsiUtil
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtPsiUtil
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.psiUtil.isImportDirectiveExpression
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.utils.CachedValueProperty
@@ -52,7 +52,7 @@ import java.util.*
 /**
  * Check possibility and perform fix for unresolved references.
  */
-public class AutoImportFix(element: JetSimpleNameExpression) : KotlinQuickFixAction<JetSimpleNameExpression>(element), HighPriorityAction, HintAction {
+public class AutoImportFix(element: KtSimpleNameExpression) : KotlinQuickFixAction<KtSimpleNameExpression>(element), HighPriorityAction, HintAction {
     private val modificationCountOnCreate = PsiModificationTracker.SERVICE.getInstance(element.getProject()).getModificationCount()
 
     @Volatile private var anySuggestionFound: Boolean? = null
@@ -88,7 +88,7 @@ public class AutoImportFix(element: JetSimpleNameExpression) : KotlinQuickFixAct
     override fun isAvailable(project: Project, editor: Editor?, file: PsiFile)
             = (super.isAvailable(project, editor, file)) && (anySuggestionFound ?: !suggestions.isEmpty())
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         CommandProcessor.getInstance().runUndoTransparentAction {
             createAction(project, editor!!).execute()
         }
@@ -101,10 +101,10 @@ public class AutoImportFix(element: JetSimpleNameExpression) : KotlinQuickFixAct
     private fun createAction(project: Project, editor: Editor) = KotlinAddImportAction(project, editor, element, suggestions)
 
     companion object : JetSingleIntentionActionFactory() {
-        override fun createAction(diagnostic: Diagnostic): KotlinQuickFixAction<JetSimpleNameExpression>? {
+        override fun createAction(diagnostic: Diagnostic): KotlinQuickFixAction<KtSimpleNameExpression>? {
             // There could be different psi elements (i.e. JetArrayAccessExpression), but we can fix only JetSimpleNameExpression case
             val psiElement = diagnostic.getPsiElement()
-            if (psiElement is JetSimpleNameExpression) {
+            if (psiElement is KtSimpleNameExpression) {
                 return AutoImportFix(psiElement)
             }
 
@@ -115,10 +115,10 @@ public class AutoImportFix(element: JetSimpleNameExpression) : KotlinQuickFixAct
 
         private val ERRORS by lazy(LazyThreadSafetyMode.PUBLICATION ) { QuickFixes.getInstance().getDiagnostics(this) }
 
-        public fun computeSuggestions(element: JetSimpleNameExpression): Collection<DeclarationDescriptor> {
+        public fun computeSuggestions(element: KtSimpleNameExpression): Collection<DeclarationDescriptor> {
             if (!element.isValid()) return emptyList()
 
-            val file = element.getContainingFile() as? JetFile ?: return emptyList()
+            val file = element.getContainingFile() as? KtFile ?: return emptyList()
 
             val callTypeAndReceiver = CallTypeAndReceiver.detect(element)
             if (callTypeAndReceiver is CallTypeAndReceiver.UNKNOWN) return emptyList()
@@ -128,7 +128,7 @@ public class AutoImportFix(element: JetSimpleNameExpression) : KotlinQuickFixAct
 
             var referenceName = element.getReferencedName()
             if (element.getIdentifier() == null) {
-                val conventionName = JetPsiUtil.getConventionName(element)
+                val conventionName = KtPsiUtil.getConventionName(element)
                 if (conventionName != null) {
                     referenceName = conventionName.asString()
                 }
@@ -157,7 +157,7 @@ public class AutoImportFix(element: JetSimpleNameExpression) : KotlinQuickFixAct
 
             val indicesHelper = KotlinIndicesHelper(element.getResolutionFacade(), searchScope, ::isVisible, true)
 
-            if (!element.isImportDirectiveExpression() && !JetPsiUtil.isSelectorInQualified(element)) {
+            if (!element.isImportDirectiveExpression() && !KtPsiUtil.isSelectorInQualified(element)) {
                 if (ProjectStructureUtil.isJsKotlinModule(file)) {
                     indicesHelper.getKotlinClasses({ it == referenceName }, { true }).filterTo(result, ::filterByCallType)
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/CastExpressionFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/CastExpressionFix.java
index 757b355a3e5..8012a4a1e05 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/CastExpressionFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/CastExpressionFix.java
@@ -33,13 +33,13 @@ import org.jetbrains.kotlin.idea.util.ShortenReferences;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm;
 import org.jetbrains.kotlin.types.FlexibleTypesKt;
-import org.jetbrains.kotlin.types.JetType;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.KtType;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
-public class CastExpressionFix extends KotlinQuickFixAction<JetExpression> {
-    private final JetType type;
+public class CastExpressionFix extends KotlinQuickFixAction<KtExpression> {
+    private final KtType type;
 
-    public CastExpressionFix(@NotNull JetExpression element, @NotNull JetType type) {
+    public CastExpressionFix(@NotNull KtExpression element, @NotNull KtType type) {
         super(element);
         this.type = type;
     }
@@ -63,37 +63,37 @@ public class CastExpressionFix extends KotlinQuickFixAction<JetExpression> {
     @Override
     public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
         if (!super.isAvailable(project, editor, file)) return false;
-        JetType expressionType = ResolutionUtils.analyze(getElement()).getType(getElement());
+        KtType expressionType = ResolutionUtils.analyze(getElement()).getType(getElement());
         return expressionType != null
                && (
-                       JetTypeChecker.DEFAULT.isSubtypeOf(type, expressionType) // downcast
-                       || JetTypeChecker.DEFAULT.isSubtypeOf(expressionType, type) // upcast
+                       KotlinTypeChecker.DEFAULT.isSubtypeOf(type, expressionType) // downcast
+                       || KotlinTypeChecker.DEFAULT.isSubtypeOf(expressionType, type) // upcast
                );
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
         String renderedType = IdeDescriptorRenderers.SOURCE_CODE.renderType(type);
 
-        JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(file);
-        JetBinaryExpressionWithTypeRHS castExpression =
-                (JetBinaryExpressionWithTypeRHS) psiFactory.createExpression("(" + getElement().getText() + ") as " + renderedType);
-        if (JetPsiUtil.areParenthesesUseless((JetParenthesizedExpression) castExpression.getLeft())) {
-            castExpression = (JetBinaryExpressionWithTypeRHS) psiFactory.createExpression(getElement().getText() + " as " + renderedType);
+        KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(file);
+        KtBinaryExpressionWithTypeRHS castExpression =
+                (KtBinaryExpressionWithTypeRHS) psiFactory.createExpression("(" + getElement().getText() + ") as " + renderedType);
+        if (KtPsiUtil.areParenthesesUseless((KtParenthesizedExpression) castExpression.getLeft())) {
+            castExpression = (KtBinaryExpressionWithTypeRHS) psiFactory.createExpression(getElement().getText() + " as " + renderedType);
         }
 
-        JetParenthesizedExpression castExpressionInParentheses =
-                (JetParenthesizedExpression) getElement().replace(psiFactory.createExpression("(" + castExpression.getText() + ")"));
+        KtParenthesizedExpression castExpressionInParentheses =
+                (KtParenthesizedExpression) getElement().replace(psiFactory.createExpression("(" + castExpression.getText() + ")"));
 
-        if (JetPsiUtil.areParenthesesUseless(castExpressionInParentheses)) {
-            castExpression = (JetBinaryExpressionWithTypeRHS) castExpressionInParentheses.replace(castExpression);
+        if (KtPsiUtil.areParenthesesUseless(castExpressionInParentheses)) {
+            castExpression = (KtBinaryExpressionWithTypeRHS) castExpressionInParentheses.replace(castExpression);
         }
         else {
-            castExpression = (JetBinaryExpressionWithTypeRHS) castExpressionInParentheses.getExpression();
+            castExpression = (KtBinaryExpressionWithTypeRHS) castExpressionInParentheses.getExpression();
             assert castExpression != null;
         }
 
-        JetTypeReference typeRef = castExpression.getRight();
+        KtTypeReference typeRef = castExpression.getRight();
         assert typeRef != null;
         ShortenReferences.DEFAULT.process(typeRef);
     }
@@ -104,7 +104,7 @@ public class CastExpressionFix extends KotlinQuickFixAction<JetExpression> {
             @Nullable
             @Override
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
-                DiagnosticWithParameters2<JetExpression, JetType, String> diagnosticWithParameters =
+                DiagnosticWithParameters2<KtExpression, KtType, String> diagnosticWithParameters =
                         Errors.SMARTCAST_IMPOSSIBLE.cast(diagnostic);
                 return new CastExpressionFix(diagnosticWithParameters.getPsiElement(), diagnosticWithParameters.getA());
             }
@@ -117,7 +117,7 @@ public class CastExpressionFix extends KotlinQuickFixAction<JetExpression> {
             @Nullable
             @Override
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
-                DiagnosticWithParameters2<JetExpression, JetType, JetType> diagnosticWithParameters =
+                DiagnosticWithParameters2<KtExpression, KtType, KtType> diagnosticWithParameters =
                         ErrorsJvm.JAVA_TYPE_MISMATCH.cast(diagnostic);
                 return new CastExpressionFix(
                         diagnosticWithParameters.getPsiElement(), FlexibleTypesKt.flexibility(diagnosticWithParameters.getB()).getUpperBound()
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeAccessorTypeFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeAccessorTypeFix.java
index 6a3be773150..52537fd8c48 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeAccessorTypeFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeAccessorTypeFix.java
@@ -28,20 +28,20 @@ import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
 import org.jetbrains.kotlin.idea.util.ShortenReferences;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
-public class ChangeAccessorTypeFix extends KotlinQuickFixAction<JetPropertyAccessor> {
-    private JetType type;
+public class ChangeAccessorTypeFix extends KotlinQuickFixAction<KtPropertyAccessor> {
+    private KtType type;
 
-    public ChangeAccessorTypeFix(@NotNull JetPropertyAccessor element) {
+    public ChangeAccessorTypeFix(@NotNull KtPropertyAccessor element) {
         super(element);
     }
 
     @Override
     public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
-        JetProperty property = PsiTreeUtil.getParentOfType(getElement(), JetProperty.class);
+        KtProperty property = PsiTreeUtil.getParentOfType(getElement(), KtProperty.class);
         if (property == null) return false;
-        JetType type = QuickFixUtil.getDeclarationReturnType(property);
+        KtType type = QuickFixUtil.getDeclarationReturnType(property);
         if (super.isAvailable(project, editor, file) && type != null && !type.isError()) {
             this.type = type;
             return true;
@@ -65,30 +65,30 @@ public class ChangeAccessorTypeFix extends KotlinQuickFixAction<JetPropertyAcces
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetTypeReference newTypeReference = JetPsiFactoryKt
-                .JetPsiFactory(file).createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type));
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        KtTypeReference newTypeReference = KtPsiFactoryKt
+                .KtPsiFactory(file).createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type));
 
-        JetTypeReference typeReference;
+        KtTypeReference typeReference;
         if (getElement().isGetter()) {
             typeReference = getElement().getReturnTypeReference();
         }
         else {
-            JetParameter parameter = getElement().getParameter();
+            KtParameter parameter = getElement().getParameter();
             assert parameter != null;
             typeReference = parameter.getTypeReference();
         }
         assert typeReference != null;
 
-        newTypeReference = (JetTypeReference) typeReference.replace(newTypeReference);
+        newTypeReference = (KtTypeReference) typeReference.replace(newTypeReference);
         ShortenReferences.DEFAULT.process(newTypeReference);
     }
 
     public static JetSingleIntentionActionFactory createFactory() {
         return new JetSingleIntentionActionFactory() {
             @Override
-            public KotlinQuickFixAction<JetPropertyAccessor> createAction(@NotNull Diagnostic diagnostic) {
-                JetPropertyAccessor accessor = QuickFixUtil.getParentElementOfType(diagnostic, JetPropertyAccessor.class);
+            public KotlinQuickFixAction<KtPropertyAccessor> createAction(@NotNull Diagnostic diagnostic) {
+                KtPropertyAccessor accessor = QuickFixUtil.getParentElementOfType(diagnostic, KtPropertyAccessor.class);
                 if (accessor == null) return null;
                 return new ChangeAccessorTypeFix(accessor);
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionLiteralReturnTypeFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionLiteralReturnTypeFix.java
index ddb00ab6221..9aea2a08d17 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionLiteralReturnTypeFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionLiteralReturnTypeFix.java
@@ -38,47 +38,47 @@ import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeProjection;
 import org.jetbrains.kotlin.types.TypeUtils;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.LinkedList;
 import java.util.List;
 
 import static org.jetbrains.kotlin.idea.project.PlatformKt.getPlatform;
 
-public class ChangeFunctionLiteralReturnTypeFix extends KotlinQuickFixAction<JetFunctionLiteralExpression> {
-    private final JetType type;
-    private final JetTypeReference functionLiteralReturnTypeRef;
+public class ChangeFunctionLiteralReturnTypeFix extends KotlinQuickFixAction<KtFunctionLiteralExpression> {
+    private final KtType type;
+    private final KtTypeReference functionLiteralReturnTypeRef;
     private IntentionAction appropriateQuickFix = null;
 
-    public ChangeFunctionLiteralReturnTypeFix(@NotNull JetFunctionLiteralExpression functionLiteralExpression, @NotNull JetType type) {
+    public ChangeFunctionLiteralReturnTypeFix(@NotNull KtFunctionLiteralExpression functionLiteralExpression, @NotNull KtType type) {
         super(functionLiteralExpression);
         this.type = type;
         functionLiteralReturnTypeRef = functionLiteralExpression.getFunctionLiteral().getTypeReference();
 
         AnalysisResult analysisResult = ResolutionUtils.analyzeFullyAndGetResult(functionLiteralExpression.getContainingJetFile());
         BindingContext context = analysisResult.getBindingContext();
-        JetType functionLiteralType = context.getType(functionLiteralExpression);
+        KtType functionLiteralType = context.getType(functionLiteralExpression);
         assert functionLiteralType != null : "Type of function literal not available in binding context";
 
         KotlinBuiltIns builtIns = analysisResult.getModuleDescriptor().getBuiltIns();
         ClassDescriptor functionClass = builtIns.getFunction(functionLiteralType.getArguments().size() - 1);
-        List<JetType> functionClassTypeParameters = new LinkedList<JetType>();
+        List<KtType> functionClassTypeParameters = new LinkedList<KtType>();
         for (TypeProjection typeProjection: functionLiteralType.getArguments()) {
             functionClassTypeParameters.add(typeProjection.getType());
         }
         // Replacing return type:
         functionClassTypeParameters.remove(functionClassTypeParameters.size() - 1);
         functionClassTypeParameters.add(type);
-        JetType eventualFunctionLiteralType = TypeUtils.substituteParameters(functionClass, functionClassTypeParameters);
+        KtType eventualFunctionLiteralType = TypeUtils.substituteParameters(functionClass, functionClassTypeParameters);
 
-        JetProperty correspondingProperty = PsiTreeUtil.getParentOfType(functionLiteralExpression, JetProperty.class);
+        KtProperty correspondingProperty = PsiTreeUtil.getParentOfType(functionLiteralExpression, KtProperty.class);
         if (correspondingProperty != null && QuickFixUtil.canEvaluateTo(correspondingProperty.getInitializer(), functionLiteralExpression)) {
-            JetTypeReference correspondingPropertyTypeRef = correspondingProperty.getTypeReference();
-            JetType propertyType = context.get(BindingContext.TYPE, correspondingPropertyTypeRef);
-            if (propertyType != null && !JetTypeChecker.DEFAULT.isSubtypeOf(eventualFunctionLiteralType, propertyType)) {
+            KtTypeReference correspondingPropertyTypeRef = correspondingProperty.getTypeReference();
+            KtType propertyType = context.get(BindingContext.TYPE, correspondingPropertyTypeRef);
+            if (propertyType != null && !KotlinTypeChecker.DEFAULT.isSubtypeOf(eventualFunctionLiteralType, propertyType)) {
                 appropriateQuickFix = new ChangeVariableTypeFix(correspondingProperty, eventualFunctionLiteralType);
             }
             return;
@@ -88,11 +88,11 @@ public class ChangeFunctionLiteralReturnTypeFix extends KotlinQuickFixAction<Jet
                 functionLiteralExpression, context, true);
         if (resolvedCall != null) {
             ValueArgument valueArgument = CallUtilKt.getValueArgumentForExpression(resolvedCall.getCall(), functionLiteralExpression);
-            JetParameter correspondingParameter = QuickFixUtil.getParameterDeclarationForValueArgument(resolvedCall, valueArgument);
+            KtParameter correspondingParameter = QuickFixUtil.getParameterDeclarationForValueArgument(resolvedCall, valueArgument);
             if (correspondingParameter != null) {
-                JetTypeReference correspondingParameterTypeRef = correspondingParameter.getTypeReference();
-                JetType parameterType = context.get(BindingContext.TYPE, correspondingParameterTypeRef);
-                if (parameterType != null && !JetTypeChecker.DEFAULT.isSubtypeOf(eventualFunctionLiteralType, parameterType)) {
+                KtTypeReference correspondingParameterTypeRef = correspondingParameter.getTypeReference();
+                KtType parameterType = context.get(BindingContext.TYPE, correspondingParameterTypeRef);
+                if (parameterType != null && !KotlinTypeChecker.DEFAULT.isSubtypeOf(eventualFunctionLiteralType, parameterType)) {
                     appropriateQuickFix = new ChangeParameterTypeFix(correspondingParameter, eventualFunctionLiteralType);
                 }
                 return;
@@ -100,11 +100,11 @@ public class ChangeFunctionLiteralReturnTypeFix extends KotlinQuickFixAction<Jet
         }
 
 
-        JetFunction parentFunction = PsiTreeUtil.getParentOfType(functionLiteralExpression, JetFunction.class, true);
+        KtFunction parentFunction = PsiTreeUtil.getParentOfType(functionLiteralExpression, KtFunction.class, true);
         if (parentFunction != null && QuickFixUtil.canFunctionOrGetterReturnExpression(parentFunction, functionLiteralExpression)) {
-            JetTypeReference parentFunctionReturnTypeRef = parentFunction.getTypeReference();
-            JetType parentFunctionReturnType = context.get(BindingContext.TYPE, parentFunctionReturnTypeRef);
-            if (parentFunctionReturnType != null && !JetTypeChecker.DEFAULT.isSubtypeOf(eventualFunctionLiteralType, parentFunctionReturnType)) {
+            KtTypeReference parentFunctionReturnTypeRef = parentFunction.getTypeReference();
+            KtType parentFunctionReturnType = context.get(BindingContext.TYPE, parentFunctionReturnTypeRef);
+            if (parentFunctionReturnType != null && !KotlinTypeChecker.DEFAULT.isSubtypeOf(eventualFunctionLiteralType, parentFunctionReturnType)) {
                 appropriateQuickFix = new ChangeFunctionReturnTypeFix(parentFunction, eventualFunctionLiteralType);
             }
         }
@@ -132,10 +132,10 @@ public class ChangeFunctionLiteralReturnTypeFix extends KotlinQuickFixAction<Jet
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
         if (functionLiteralReturnTypeRef != null) {
-            JetTypeReference newTypeRef = JetPsiFactoryKt.JetPsiFactory(file).createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type));
-            newTypeRef = (JetTypeReference) functionLiteralReturnTypeRef.replace(newTypeRef);
+            KtTypeReference newTypeRef = KtPsiFactoryKt.KtPsiFactory(file).createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type));
+            newTypeRef = (KtTypeReference) functionLiteralReturnTypeRef.replace(newTypeRef);
             ShortenReferences.DEFAULT.process(newTypeRef);
         }
         if (appropriateQuickFix != null && appropriateQuickFix.isAvailable(project, editor, file)) {
@@ -149,7 +149,8 @@ public class ChangeFunctionLiteralReturnTypeFix extends KotlinQuickFixAction<Jet
             @Nullable
             @Override
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
-                JetFunctionLiteralExpression functionLiteralExpression = QuickFixUtil.getParentElementOfType(diagnostic, JetFunctionLiteralExpression.class);
+                KtFunctionLiteralExpression
+                        functionLiteralExpression = QuickFixUtil.getParentElementOfType(diagnostic, KtFunctionLiteralExpression.class);
                 if (functionLiteralExpression == null) return null;
                 return new ChangeFunctionLiteralReturnTypeFix(functionLiteralExpression, getPlatform(functionLiteralExpression).getBuiltIns().getUnitType());
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionLiteralSignatureFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionLiteralSignatureFix.kt
index 966c71a895f..3d360bcfba2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionLiteralSignatureFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionLiteralSignatureFix.kt
@@ -26,19 +26,19 @@ import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.core.CollectingNameValidator
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.*
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetFunctionLiteral
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtFunctionLiteral
+import org.jetbrains.kotlin.types.KtType
 
 class ChangeFunctionLiteralSignatureFix private constructor(
-        functionLiteral: JetFunctionLiteral,
+        functionLiteral: KtFunctionLiteral,
         functionDescriptor: FunctionDescriptor,
-        private val parameterTypes: List<JetType>
+        private val parameterTypes: List<KtType>
 ) : ChangeFunctionSignatureFix(functionLiteral, functionDescriptor) {
 
     override fun getText() = "Change the signature of function literal"
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         runChangeSignature(
                 project,
                 functionDescriptor,
@@ -61,15 +61,15 @@ class ChangeFunctionLiteralSignatureFix private constructor(
                 text)
     }
 
-    companion object : KotlinSingleIntentionActionFactoryWithDelegate<JetFunctionLiteral, Data>() {
-        data class Data(val functionLiteral: JetFunctionLiteral, val descriptor: FunctionDescriptor, val parameterTypes: List<JetType>)
+    companion object : KotlinSingleIntentionActionFactoryWithDelegate<KtFunctionLiteral, Data>() {
+        data class Data(val functionLiteral: KtFunctionLiteral, val descriptor: FunctionDescriptor, val parameterTypes: List<KtType>)
 
-        override fun getElementOfInterest(diagnostic: Diagnostic): JetFunctionLiteral? {
+        override fun getElementOfInterest(diagnostic: Diagnostic): KtFunctionLiteral? {
             val diagnosticWithParameters = Errors.EXPECTED_PARAMETERS_NUMBER_MISMATCH.cast(diagnostic)
-            return diagnosticWithParameters.psiElement as? JetFunctionLiteral
+            return diagnosticWithParameters.psiElement as? KtFunctionLiteral
         }
 
-        override fun extractFixData(element: JetFunctionLiteral, diagnostic: Diagnostic): Data? {
+        override fun extractFixData(element: KtFunctionLiteral, diagnostic: Diagnostic): Data? {
             val descriptor = element.resolveToDescriptor() as? FunctionDescriptor ?: return null
             val parameterTypes = Errors.EXPECTED_PARAMETERS_NUMBER_MISMATCH.cast(diagnostic).b
             return Data(element, descriptor, parameterTypes)
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionReturnTypeFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionReturnTypeFix.java
index 51ba2a0e9e6..46f64cf6bec 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionReturnTypeFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionReturnTypeFix.java
@@ -44,8 +44,8 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.dataClassUtils.DataClassUtilsKt;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.KtType;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.LinkedList;
 import java.util.List;
@@ -54,15 +54,15 @@ import static org.jetbrains.kotlin.diagnostics.Errors.COMPONENT_FUNCTION_RETURN_
 import static org.jetbrains.kotlin.idea.project.PlatformKt.getPlatform;
 import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.getBuiltIns;
 
-public class ChangeFunctionReturnTypeFix extends KotlinQuickFixAction<JetFunction> {
-    private final JetType type;
+public class ChangeFunctionReturnTypeFix extends KotlinQuickFixAction<KtFunction> {
+    private final KtType type;
     private final ChangeFunctionLiteralReturnTypeFix changeFunctionLiteralReturnTypeFix;
 
-    public ChangeFunctionReturnTypeFix(@NotNull JetFunction element, @NotNull JetType type) {
+    public ChangeFunctionReturnTypeFix(@NotNull KtFunction element, @NotNull KtType type) {
         super(element);
         this.type = type;
-        if (element instanceof JetFunctionLiteral) {
-            JetFunctionLiteralExpression functionLiteralExpression = PsiTreeUtil.getParentOfType(element, JetFunctionLiteralExpression.class);
+        if (element instanceof KtFunctionLiteral) {
+            KtFunctionLiteralExpression functionLiteralExpression = PsiTreeUtil.getParentOfType(element, KtFunctionLiteralExpression.class);
             assert functionLiteralExpression != null : "FunctionLiteral outside any FunctionLiteralExpression: " +
                                                        PsiUtilsKt.getElementTextWithContext(element);
             changeFunctionLiteralReturnTypeFix = new ChangeFunctionLiteralReturnTypeFix(functionLiteralExpression, type);
@@ -106,13 +106,14 @@ public class ChangeFunctionReturnTypeFix extends KotlinQuickFixAction<JetFunctio
     }
 
     @Override
-    public void invoke(@NotNull Project project, @Nullable Editor editor, JetFile file) throws IncorrectOperationException {
+    public void invoke(@NotNull Project project, @Nullable Editor editor, KtFile file) throws IncorrectOperationException {
         if (changeFunctionLiteralReturnTypeFix != null) {
             changeFunctionLiteralReturnTypeFix.invoke(project, editor, file);
         }
         else {
             if (!(KotlinBuiltIns.isUnit(type) && getElement().hasBlockBody())) {
-                JetTypeReference newTypeRef = JetPsiFactoryKt.JetPsiFactory(project).createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type));
+                KtTypeReference newTypeRef = KtPsiFactoryKt
+                        .KtPsiFactory(project).createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type));
                 newTypeRef = getElement().setTypeReference(newTypeRef);
                 assert newTypeRef != null;
                 ShortenReferences.DEFAULT.process(newTypeRef);
@@ -124,10 +125,10 @@ public class ChangeFunctionReturnTypeFix extends KotlinQuickFixAction<JetFunctio
     }
 
     @NotNull
-    public static JetMultiDeclarationEntry getMultiDeclarationEntryThatTypeMismatchComponentFunction(Diagnostic diagnostic) {
+    public static KtMultiDeclarationEntry getMultiDeclarationEntryThatTypeMismatchComponentFunction(Diagnostic diagnostic) {
         Name componentName = COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH.cast(diagnostic).getA();
         int componentIndex = DataClassUtilsKt.getComponentIndex(componentName);
-        JetMultiDeclaration multiDeclaration = QuickFixUtil.getParentElementOfType(diagnostic, JetMultiDeclaration.class);
+        KtMultiDeclaration multiDeclaration = QuickFixUtil.getParentElementOfType(diagnostic, KtMultiDeclaration.class);
         assert multiDeclaration != null : "COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH reported on expression that is not within any multi declaration";
         return multiDeclaration.getEntries().get(componentIndex - 1);
     }
@@ -138,13 +139,13 @@ public class ChangeFunctionReturnTypeFix extends KotlinQuickFixAction<JetFunctio
             @Nullable
             @Override
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
-                JetMultiDeclarationEntry entry = getMultiDeclarationEntryThatTypeMismatchComponentFunction(diagnostic);
+                KtMultiDeclarationEntry entry = getMultiDeclarationEntryThatTypeMismatchComponentFunction(diagnostic);
                 BindingContext context = ResolutionUtils.analyze(entry);
                 ResolvedCall<FunctionDescriptor> resolvedCall = context.get(BindingContext.COMPONENT_RESOLVED_CALL, entry);
                 if (resolvedCall == null) return null;
-                JetFunction componentFunction = (JetFunction) DescriptorToSourceUtils
+                KtFunction componentFunction = (KtFunction) DescriptorToSourceUtils
                         .descriptorToDeclaration(resolvedCall.getCandidateDescriptor());
-                JetType expectedType = context.get(BindingContext.TYPE, entry.getTypeReference());
+                KtType expectedType = context.get(BindingContext.TYPE, entry.getTypeReference());
                 if (componentFunction != null && expectedType != null) {
                     return new ChangeFunctionReturnTypeFix(componentFunction, expectedType);
                 }
@@ -159,13 +160,13 @@ public class ChangeFunctionReturnTypeFix extends KotlinQuickFixAction<JetFunctio
             @Nullable
             @Override
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
-                JetExpression expression = QuickFixUtil.getParentElementOfType(diagnostic, JetExpression.class);
+                KtExpression expression = QuickFixUtil.getParentElementOfType(diagnostic, KtExpression.class);
                 assert expression != null : "HAS_NEXT_FUNCTION_TYPE_MISMATCH reported on element that is not within any expression";
                 BindingContext context = ResolutionUtils.analyze(expression);
                 ResolvedCall<FunctionDescriptor> resolvedCall = context.get(BindingContext.LOOP_RANGE_HAS_NEXT_RESOLVED_CALL, expression);
                 if (resolvedCall == null) return null;
                 FunctionDescriptor hasNextDescriptor = resolvedCall.getCandidateDescriptor();
-                JetFunction hasNextFunction = (JetFunction) DescriptorToSourceUtils
+                KtFunction hasNextFunction = (KtFunction) DescriptorToSourceUtils
                         .descriptorToDeclaration(hasNextDescriptor);
                 if (hasNextFunction != null) {
                     return new ChangeFunctionReturnTypeFix(hasNextFunction, getBuiltIns(hasNextDescriptor).getBooleanType());
@@ -181,15 +182,15 @@ public class ChangeFunctionReturnTypeFix extends KotlinQuickFixAction<JetFunctio
             @Nullable
             @Override
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
-                JetBinaryExpression expression = QuickFixUtil.getParentElementOfType(diagnostic, JetBinaryExpression.class);
+                KtBinaryExpression expression = QuickFixUtil.getParentElementOfType(diagnostic, KtBinaryExpression.class);
                 assert expression != null : "COMPARE_TO_TYPE_MISMATCH reported on element that is not within any expression";
                 BindingContext context = ResolutionUtils.analyze(expression);
                 ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(expression, context);
                 if (resolvedCall == null) return null;
                 CallableDescriptor compareToDescriptor = resolvedCall.getCandidateDescriptor();
                 PsiElement compareTo = DescriptorToSourceUtils.descriptorToDeclaration(compareToDescriptor);
-                if (!(compareTo instanceof JetFunction)) return null;
-                return new ChangeFunctionReturnTypeFix((JetFunction) compareTo, getBuiltIns(compareToDescriptor).getIntType());
+                if (!(compareTo instanceof KtFunction)) return null;
+                return new ChangeFunctionReturnTypeFix((KtFunction) compareTo, getBuiltIns(compareToDescriptor).getIntType());
             }
         };
     }
@@ -202,23 +203,23 @@ public class ChangeFunctionReturnTypeFix extends KotlinQuickFixAction<JetFunctio
             protected List<IntentionAction> doCreateActions(@NotNull Diagnostic diagnostic) {
                 List<IntentionAction> actions = new LinkedList<IntentionAction>();
 
-                JetFunction function = QuickFixUtil.getParentElementOfType(diagnostic, JetFunction.class);
+                KtFunction function = QuickFixUtil.getParentElementOfType(diagnostic, KtFunction.class);
                 if (function != null) {
                     FunctionDescriptor descriptor = (FunctionDescriptor) ResolutionUtils.resolveToDescriptor(function);
 
-                    JetType matchingReturnType = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(descriptor);
+                    KtType matchingReturnType = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(descriptor);
                     if (matchingReturnType != null) {
                         actions.add(new ChangeFunctionReturnTypeFix(function, matchingReturnType));
                     }
 
-                    JetType functionType = descriptor.getReturnType();
+                    KtType functionType = descriptor.getReturnType();
                     if (functionType == null) return actions;
 
                     List<FunctionDescriptor> overriddenMismatchingFunctions = new LinkedList<FunctionDescriptor>();
                     for (FunctionDescriptor overriddenFunction: descriptor.getOverriddenDescriptors()) {
-                        JetType overriddenFunctionType = overriddenFunction.getReturnType();
+                        KtType overriddenFunctionType = overriddenFunction.getReturnType();
                         if (overriddenFunctionType == null) continue;
-                        if (!JetTypeChecker.DEFAULT.isSubtypeOf(functionType, overriddenFunctionType)) {
+                        if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(functionType, overriddenFunctionType)) {
                             overriddenMismatchingFunctions.add(overriddenFunction);
                         }
                     }
@@ -226,8 +227,8 @@ public class ChangeFunctionReturnTypeFix extends KotlinQuickFixAction<JetFunctio
                     if (overriddenMismatchingFunctions.size() == 1) {
                         PsiElement overriddenFunction = DescriptorToSourceUtils
                                 .descriptorToDeclaration(overriddenMismatchingFunctions.get(0));
-                        if (overriddenFunction instanceof JetFunction) {
-                            actions.add(new ChangeFunctionReturnTypeFix((JetFunction) overriddenFunction, functionType));
+                        if (overriddenFunction instanceof KtFunction) {
+                            actions.add(new ChangeFunctionReturnTypeFix((KtFunction) overriddenFunction, functionType));
                         }
                     }
                 }
@@ -242,7 +243,7 @@ public class ChangeFunctionReturnTypeFix extends KotlinQuickFixAction<JetFunctio
             @Nullable
             @Override
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
-                JetFunction function = QuickFixUtil.getParentElementOfType(diagnostic, JetFunction.class);
+                KtFunction function = QuickFixUtil.getParentElementOfType(diagnostic, KtFunction.class);
                 return function == null ? null : new ChangeFunctionReturnTypeFix(function, getPlatform(function).getBuiltIns().getUnitType());
             }
         };
@@ -254,7 +255,7 @@ public class ChangeFunctionReturnTypeFix extends KotlinQuickFixAction<JetFunctio
             @Nullable
             @Override
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
-                JetFunction function = QuickFixUtil.getParentElementOfType(diagnostic, JetFunction.class);
+                KtFunction function = QuickFixUtil.getParentElementOfType(diagnostic, KtFunction.class);
                 return function == null ? null : new ChangeFunctionReturnTypeFix(function, getPlatform(function).getBuiltIns().getNothingType());
             }
         };
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.kt
index e7aef8e5b56..d12a5400d5a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.kt
@@ -36,13 +36,13 @@ import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeSignatureC
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.modify
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.runChangeSignature
-import org.jetbrains.kotlin.psi.JetCallElement
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtCallElement
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.ValueArgument
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 
 abstract class ChangeFunctionSignatureFix(
         protected val context: PsiElement,
@@ -76,21 +76,21 @@ abstract class ChangeFunctionSignatureFix(
         }
     }
 
-    companion object : KotlinSingleIntentionActionFactoryWithDelegate<JetCallElement, Data>() {
-        data class Data(val callElement: JetCallElement, val descriptor: CallableDescriptor)
+    companion object : KotlinSingleIntentionActionFactoryWithDelegate<KtCallElement, Data>() {
+        data class Data(val callElement: KtCallElement, val descriptor: CallableDescriptor)
 
-        override fun getElementOfInterest(diagnostic: Diagnostic): JetCallElement? {
-            return diagnostic.psiElement.getNonStrictParentOfType<JetCallElement>()
+        override fun getElementOfInterest(diagnostic: Diagnostic): KtCallElement? {
+            return diagnostic.psiElement.getNonStrictParentOfType<KtCallElement>()
         }
 
-        override fun extractFixData(element: JetCallElement, diagnostic: Diagnostic): Data? {
+        override fun extractFixData(element: KtCallElement, diagnostic: Diagnostic): Data? {
             val descriptor = DiagnosticFactory.cast(diagnostic, Errors.TOO_MANY_ARGUMENTS, Errors.NO_VALUE_FOR_PARAMETER).a
             return Data(element, descriptor)
         }
 
         override fun createFix(data: Data) = createFix(data.callElement, data.descriptor)
 
-        private fun createFix(callElement: JetCallElement, descriptor: CallableDescriptor): ChangeFunctionSignatureFix? {
+        private fun createFix(callElement: KtCallElement, descriptor: CallableDescriptor): ChangeFunctionSignatureFix? {
             val functionDescriptor = descriptor as? FunctionDescriptor
                     ?: (descriptor as? ValueParameterDescriptor)?.containingDeclaration as? FunctionDescriptor
                     ?: return null
@@ -111,7 +111,7 @@ abstract class ChangeFunctionSignatureFix(
                     val hasTypeMismatches = argumentToParameter.any {
                         val (argument, parameter) = it
                         val argumentType = argument.getArgumentExpression()?.let { bindingContext.getType(it) }
-                        argumentType == null || !JetTypeChecker.DEFAULT.isSubtypeOf(argumentType, parameter.type)
+                        argumentType == null || !KotlinTypeChecker.DEFAULT.isSubtypeOf(argumentType, parameter.type)
                     }
                     return AddFunctionParametersFix(callElement, functionDescriptor, hasTypeMismatches)
                 }
@@ -128,7 +128,7 @@ abstract class ChangeFunctionSignatureFix(
 
             override fun getText() = "Remove parameter '${parameterToRemove.name.asString()}'"
 
-            override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+            override fun invoke(project: Project, editor: Editor?, file: KtFile) {
                 runRemoveParameter(parameterToRemove, context)
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeMemberFunctionSignatureFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeMemberFunctionSignatureFix.kt
index 2ed2827f8cd..99782a8db07 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeMemberFunctionSignatureFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeMemberFunctionSignatureFix.kt
@@ -33,15 +33,15 @@ import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetParameterList
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtParameterList
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.NameShortness
 import org.jetbrains.kotlin.resolve.FunctionDescriptorUtil
 import org.jetbrains.kotlin.resolve.findMemberWithMaxVisibility
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.typeUtil.supertypes
 import org.jetbrains.kotlin.utils.addToStdlib.check
 import java.util.*
@@ -50,9 +50,9 @@ import java.util.*
  * Fix that changes member function's signature to match one of super functions' signatures.
  */
 class ChangeMemberFunctionSignatureFix private constructor(
-        element: JetNamedFunction,
+        element: KtNamedFunction,
         private val signatures: List<ChangeMemberFunctionSignatureFix.Signature>
-) : KotlinQuickFixAction<JetNamedFunction>(element) {
+) : KotlinQuickFixAction<KtNamedFunction>(element) {
 
     init {
         assert(signatures.isNotEmpty())
@@ -80,7 +80,7 @@ class ChangeMemberFunctionSignatureFix private constructor(
 
     companion object : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-            val function = diagnostic.psiElement as? JetNamedFunction ?: return null
+            val function = diagnostic.psiElement as? KtNamedFunction ?: return null
             val signatures = computePossibleSignatures(function)
             if (signatures.isEmpty()) return null
             return ChangeMemberFunctionSignatureFix(function, signatures)
@@ -89,7 +89,7 @@ class ChangeMemberFunctionSignatureFix private constructor(
         /**
          * Computes all the signatures a 'functionElement' could be changed to in order to remove NOTHING_TO_OVERRIDE error.
          */
-        private fun computePossibleSignatures(functionElement: JetNamedFunction): List<Signature> {
+        private fun computePossibleSignatures(functionElement: KtNamedFunction): List<Signature> {
             if (functionElement.valueParameterList == null) {
                 // we won't be able to modify its signature
                 return emptyList()
@@ -194,7 +194,7 @@ class ChangeMemberFunctionSignatureFix private constructor(
 
     override fun getFamilyName() = "Change function signature"
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         CommandProcessor.getInstance().runUndoTransparentAction {
             MyAction(project, editor, element, signatures).execute()
         }
@@ -218,7 +218,7 @@ class ChangeMemberFunctionSignatureFix private constructor(
         object MatchTypes : ParameterChooser {
             override fun choose(parameter: ValueParameterDescriptor, superParameter: ValueParameterDescriptor): ValueParameterDescriptor? {
                 // TODO: support for generic functions
-                if (JetTypeChecker.DEFAULT.equalTypes(parameter.type, superParameter.type)) {
+                if (KotlinTypeChecker.DEFAULT.equalTypes(parameter.type, superParameter.type)) {
                     return superParameter.copy(parameter.containingDeclaration, parameter.name)
                 }
                 else {
@@ -232,7 +232,7 @@ class ChangeMemberFunctionSignatureFix private constructor(
     private class MyAction(
             private val project: Project,
             private val editor: Editor?,
-            private val function: JetNamedFunction,
+            private val function: KtNamedFunction,
             private val signatures: List<Signature>
     ) {
         fun execute() {
@@ -270,14 +270,14 @@ class ChangeMemberFunctionSignatureFix private constructor(
             PsiDocumentManager.getInstance(project).commitAllDocuments()
 
             project.executeWriteCommand("Change Function Signature") {
-                val patternFunction = JetPsiFactory(project).createFunction(signature.sourceCode)
+                val patternFunction = KtPsiFactory(project).createFunction(signature.sourceCode)
 
                 val newTypeRef = function.setTypeReference(patternFunction.typeReference)
                 if (newTypeRef != null) {
                     ShortenReferences.DEFAULT.process(newTypeRef)
                 }
 
-                val newParameterList = function.valueParameterList!!.replace(patternFunction.valueParameterList!!) as JetParameterList
+                val newParameterList = function.valueParameterList!!.replace(patternFunction.valueParameterList!!) as KtParameterList
                 ShortenReferences.DEFAULT.process(newParameterList)
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeParameterTypeFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeParameterTypeFix.java
index 9ecb539e971..93f13e1a383 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeParameterTypeFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeParameterTypeFix.java
@@ -27,18 +27,18 @@ import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
 import org.jetbrains.kotlin.idea.util.ShortenReferences;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
-public class ChangeParameterTypeFix extends KotlinQuickFixAction<JetParameter> {
-    private final JetType type;
+public class ChangeParameterTypeFix extends KotlinQuickFixAction<KtParameter> {
+    private final KtType type;
     private final String containingDeclarationName;
     private final boolean isPrimaryConstructorParameter;
 
-    public ChangeParameterTypeFix(@NotNull JetParameter element, @NotNull JetType type) {
+    public ChangeParameterTypeFix(@NotNull KtParameter element, @NotNull KtType type) {
         super(element);
         this.type = type;
-        JetNamedDeclaration declaration = PsiTreeUtil.getParentOfType(element, JetNamedDeclaration.class);
-        isPrimaryConstructorParameter = declaration instanceof JetPrimaryConstructor;
+        KtNamedDeclaration declaration = PsiTreeUtil.getParentOfType(element, KtNamedDeclaration.class);
+        isPrimaryConstructorParameter = declaration instanceof KtPrimaryConstructor;
         FqName declarationFQName = declaration == null ? null : declaration.getFqName();
         containingDeclarationName = declarationFQName == null ? declaration.getName() : declarationFQName.asString();
     }
@@ -64,8 +64,8 @@ public class ChangeParameterTypeFix extends KotlinQuickFixAction<JetParameter> {
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetTypeReference newTypeRef = JetPsiFactoryKt.JetPsiFactory(file).createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type));
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        KtTypeReference newTypeRef = KtPsiFactoryKt.KtPsiFactory(file).createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type));
         newTypeRef = getElement().setTypeReference(newTypeRef);
         assert newTypeRef != null;
         ShortenReferences.DEFAULT.process(newTypeRef);
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangePrivateTopLevelToInternalFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangePrivateTopLevelToInternalFix.kt
index c893b684f84..655ebc5c1ac 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangePrivateTopLevelToInternalFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangePrivateTopLevelToInternalFix.kt
@@ -24,18 +24,18 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithVisibility
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory3
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetModifierListOwner
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtModifierListOwner
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 
-public class ChangePrivateTopLevelToInternalFix(element: JetModifierListOwner, private val elementName: String) : KotlinQuickFixAction<JetModifierListOwner>(element), CleanupFix {
+public class ChangePrivateTopLevelToInternalFix(element: KtModifierListOwner, private val elementName: String) : KotlinQuickFixAction<KtModifierListOwner>(element), CleanupFix {
     override fun getText() = "Make $elementName internal"
     override fun getFamilyName() = "Make top-level declaration internal"
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
-        element.addModifier(JetTokens.INTERNAL_KEYWORD)
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+        element.addModifier(KtTokens.INTERNAL_KEYWORD)
     }
 
     companion object : JetSingleIntentionActionFactory() {
@@ -47,7 +47,7 @@ public class ChangePrivateTopLevelToInternalFix(element: JetModifierListOwner, p
                 descriptor !is DeclarationDescriptorWithVisibility ||
                 descriptor.visibility != Visibilities.PRIVATE) return null
 
-            val declaration = DescriptorToSourceUtils.getSourceFromDescriptor(descriptor) as? JetModifierListOwner ?: return null
+            val declaration = DescriptorToSourceUtils.getSourceFromDescriptor(descriptor) as? KtModifierListOwner ?: return null
             return ChangePrivateTopLevelToInternalFix(declaration, descriptor.name.asString())
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeToFunctionInvocationFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeToFunctionInvocationFix.java
index cd4f94c43b3..dc3b010d3df 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeToFunctionInvocationFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeToFunctionInvocationFix.java
@@ -22,13 +22,13 @@ import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
-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;
 
-public class ChangeToFunctionInvocationFix extends KotlinQuickFixAction<JetExpression> {
+public class ChangeToFunctionInvocationFix extends KotlinQuickFixAction<KtExpression> {
 
-    public ChangeToFunctionInvocationFix(@NotNull JetExpression element) {
+    public ChangeToFunctionInvocationFix(@NotNull KtExpression element) {
         super(element);
     }
 
@@ -45,17 +45,17 @@ public class ChangeToFunctionInvocationFix extends KotlinQuickFixAction<JetExpre
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetExpression reference = (JetExpression) getElement().copy();
-        getElement().replace(JetPsiFactoryKt.JetPsiFactory(file).createExpression(reference.getText() + "()"));
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        KtExpression reference = (KtExpression) getElement().copy();
+        getElement().replace(KtPsiFactoryKt.KtPsiFactory(file).createExpression(reference.getText() + "()"));
     }
 
     public static JetSingleIntentionActionFactory createFactory() {
         return new JetSingleIntentionActionFactory() {
             @Override
-            public KotlinQuickFixAction<JetExpression> createAction(Diagnostic diagnostic) {
-                if (diagnostic.getPsiElement() instanceof JetExpression) {
-                    return new ChangeToFunctionInvocationFix((JetExpression) diagnostic.getPsiElement());
+            public KotlinQuickFixAction<KtExpression> createAction(Diagnostic diagnostic) {
+                if (diagnostic.getPsiElement() instanceof KtExpression) {
+                    return new ChangeToFunctionInvocationFix((KtExpression) diagnostic.getPsiElement());
                 }
                 return null;
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeToPropertyNameFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeToPropertyNameFix.java
index 50da3026bc9..ed7f2ae79ef 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeToPropertyNameFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeToPropertyNameFix.java
@@ -26,8 +26,8 @@ import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
 import org.jetbrains.kotlin.psi.*;
 
-public class ChangeToPropertyNameFix extends KotlinQuickFixAction<JetSimpleNameExpression> {
-    public ChangeToPropertyNameFix(@NotNull JetSimpleNameExpression element) {
+public class ChangeToPropertyNameFix extends KotlinQuickFixAction<KtSimpleNameExpression> {
+    public ChangeToPropertyNameFix(@NotNull KtSimpleNameExpression element) {
         super(element);
     }
 
@@ -53,22 +53,22 @@ public class ChangeToPropertyNameFix extends KotlinQuickFixAction<JetSimpleNameE
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetSimpleNameExpression propertyName = (JetSimpleNameExpression) JetPsiFactoryKt.JetPsiFactory(file).createExpression(getPropertyName());
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        KtSimpleNameExpression propertyName = (KtSimpleNameExpression) KtPsiFactoryKt.KtPsiFactory(file).createExpression(getPropertyName());
         getElement().replace(propertyName);
     }
 
     public static JetSingleIntentionActionFactory createFactory() {
         return new JetSingleIntentionActionFactory() {
             @Override
-            public KotlinQuickFixAction<JetSimpleNameExpression> createAction(Diagnostic diagnostic) {
-                JetSimpleNameExpression expression = QuickFixUtil.getParentElementOfType(diagnostic, JetSimpleNameExpression.class);
+            public KotlinQuickFixAction<KtSimpleNameExpression> createAction(Diagnostic diagnostic) {
+                KtSimpleNameExpression expression = QuickFixUtil.getParentElementOfType(diagnostic, KtSimpleNameExpression.class);
                 if (expression == null) {
                     PsiElement element = diagnostic.getPsiElement();
-                    if (element instanceof JetQualifiedExpression && ((JetQualifiedExpression) element).getReceiverExpression() instanceof JetThisExpression) {
-                        JetExpression selector = ((JetQualifiedExpression) element).getSelectorExpression();
-                        if (selector instanceof JetSimpleNameExpression) {
-                            expression = (JetSimpleNameExpression) selector;
+                    if (element instanceof KtQualifiedExpression && ((KtQualifiedExpression) element).getReceiverExpression() instanceof KtThisExpression) {
+                        KtExpression selector = ((KtQualifiedExpression) element).getSelectorExpression();
+                        if (selector instanceof KtSimpleNameExpression) {
+                            expression = (KtSimpleNameExpression) selector;
                         }
                     }
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeToStarProjectionFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeToStarProjectionFix.java
index 7b4e7f3465a..ee510ef5753 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeToStarProjectionFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeToStarProjectionFix.java
@@ -27,8 +27,8 @@ import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.types.expressions.TypeReconstructionUtil;
 
-public class ChangeToStarProjectionFix extends KotlinQuickFixAction<JetTypeElement> {
-    public ChangeToStarProjectionFix(@NotNull JetTypeElement element) {
+public class ChangeToStarProjectionFix extends KotlinQuickFixAction<KtTypeElement> {
+    public ChangeToStarProjectionFix(@NotNull KtTypeElement element) {
         super(element);
     }
 
@@ -46,10 +46,10 @@ public class ChangeToStarProjectionFix extends KotlinQuickFixAction<JetTypeEleme
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        for (JetTypeReference typeReference : getElement().getTypeArgumentsAsTypes()) {
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        for (KtTypeReference typeReference : getElement().getTypeArgumentsAsTypes()) {
             if (typeReference != null) {
-                typeReference.replace(JetPsiFactoryKt.JetPsiFactory(file).createStar());
+                typeReference.replace(KtPsiFactoryKt.KtPsiFactory(file).createStar());
             }
         }
     }
@@ -58,17 +58,17 @@ public class ChangeToStarProjectionFix extends KotlinQuickFixAction<JetTypeEleme
         return new JetSingleIntentionActionFactory() {
             @Override
             public IntentionAction createAction(Diagnostic diagnostic) {
-                JetBinaryExpressionWithTypeRHS expression = QuickFixUtil
-                        .getParentElementOfType(diagnostic, JetBinaryExpressionWithTypeRHS.class);
-                JetTypeReference typeReference;
+                KtBinaryExpressionWithTypeRHS expression = QuickFixUtil
+                        .getParentElementOfType(diagnostic, KtBinaryExpressionWithTypeRHS.class);
+                KtTypeReference typeReference;
                 if (expression == null) {
-                    typeReference = QuickFixUtil.getParentElementOfType(diagnostic, JetTypeReference.class);
+                    typeReference = QuickFixUtil.getParentElementOfType(diagnostic, KtTypeReference.class);
                 }
                 else {
                     typeReference = expression.getRight();
                 }
                 if (typeReference == null) return null;
-                JetTypeElement typeElement = typeReference.getTypeElement();
+                KtTypeElement typeElement = typeReference.getTypeElement();
                 assert typeElement != null;
                 return new ChangeToStarProjectionFix(typeElement);
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeTypeFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeTypeFix.java
index 9e5b8e896b3..8e6690a6904 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeTypeFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeTypeFix.java
@@ -29,17 +29,17 @@ import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
 import org.jetbrains.kotlin.idea.util.ShortenReferences;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetParameter;
-import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
-import org.jetbrains.kotlin.psi.JetTypeReference;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtParameter;
+import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
+import org.jetbrains.kotlin.psi.KtTypeReference;
+import org.jetbrains.kotlin.types.KtType;
 
-public class ChangeTypeFix extends KotlinQuickFixAction<JetTypeReference> {
-    private final JetType type;
+public class ChangeTypeFix extends KotlinQuickFixAction<KtTypeReference> {
+    private final KtType type;
     private final String renderedType;
 
-    public ChangeTypeFix(@NotNull JetTypeReference element, JetType type) {
+    public ChangeTypeFix(@NotNull KtTypeReference element, KtType type) {
         super(element);
         this.type = type;
         renderedType = IdeDescriptorRenderers.SOURCE_CODE.renderType(type);
@@ -59,8 +59,8 @@ public class ChangeTypeFix extends KotlinQuickFixAction<JetTypeReference> {
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetTypeReference newTypeRef = (JetTypeReference) getElement().replace(JetPsiFactoryKt.JetPsiFactory(file).createType(renderedType));
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        KtTypeReference newTypeRef = (KtTypeReference) getElement().replace(KtPsiFactoryKt.KtPsiFactory(file).createType(renderedType));
         ShortenReferences.DEFAULT.process(newTypeRef);
     }
 
@@ -70,8 +70,8 @@ public class ChangeTypeFix extends KotlinQuickFixAction<JetTypeReference> {
             @Nullable
             @Override
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
-                DiagnosticWithParameters1<JetParameter, JetType> diagnosticWithParameters = Errors.EXPECTED_PARAMETER_TYPE_MISMATCH.cast(diagnostic);
-                JetTypeReference typeReference = diagnosticWithParameters.getPsiElement().getTypeReference();
+                DiagnosticWithParameters1<KtParameter, KtType> diagnosticWithParameters = Errors.EXPECTED_PARAMETER_TYPE_MISMATCH.cast(diagnostic);
+                KtTypeReference typeReference = diagnosticWithParameters.getPsiElement().getTypeReference();
                 assert typeReference != null : "EXPECTED_PARAMETER_TYPE_MISMATCH reported on parameter without explicitly declared type";
                 return new ChangeTypeFix(typeReference, diagnosticWithParameters.getA());
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVariableMutabilityFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVariableMutabilityFix.kt
index 04174fb3584..62be0a8a0b3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVariableMutabilityFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVariableMutabilityFix.kt
@@ -22,13 +22,13 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetPropertyAccessor
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtPropertyAccessor
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 
-public class ChangeVariableMutabilityFix(element: JetProperty, private val makeVar: Boolean) : KotlinQuickFixAction<JetProperty>(element) {
+public class ChangeVariableMutabilityFix(element: KtProperty, private val makeVar: Boolean) : KotlinQuickFixAction<KtProperty>(element) {
 
     override fun getText() = if (makeVar) "Make variable mutable" else "Make variable immutable"
 
@@ -38,8 +38,8 @@ public class ChangeVariableMutabilityFix(element: JetProperty, private val makeV
         return element.isVar() != makeVar
     }
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
-        val factory = JetPsiFactory(project)
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+        val factory = KtPsiFactory(project)
         val newKeyword = if (makeVar) factory.createVarKeyword() else factory.createValKeyword()
         element.getValOrVarKeyword().replace(newKeyword)
     }
@@ -47,8 +47,8 @@ public class ChangeVariableMutabilityFix(element: JetProperty, private val makeV
     companion object {
         public val VAL_WITH_SETTER_FACTORY: JetSingleIntentionActionFactory = object: JetSingleIntentionActionFactory() {
             override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-                val accessor = diagnostic.getPsiElement() as JetPropertyAccessor
-                val property = accessor.getParent() as JetProperty
+                val accessor = diagnostic.getPsiElement() as KtPropertyAccessor
+                val property = accessor.getParent() as KtProperty
                 return ChangeVariableMutabilityFix(property, true)
             }
         }
@@ -56,14 +56,14 @@ public class ChangeVariableMutabilityFix(element: JetProperty, private val makeV
         public val VAL_REASSIGNMENT_FACTORY: JetSingleIntentionActionFactory = object: JetSingleIntentionActionFactory() {
             override fun createAction(diagnostic: Diagnostic): IntentionAction? {
                 val propertyDescriptor = Errors.VAL_REASSIGNMENT.cast(diagnostic).getA()
-                val declaration = DescriptorToSourceUtils.descriptorToDeclaration(propertyDescriptor) as? JetProperty ?: return null
+                val declaration = DescriptorToSourceUtils.descriptorToDeclaration(propertyDescriptor) as? KtProperty ?: return null
                 return ChangeVariableMutabilityFix(declaration, true)
             }
         }
 
         public val VAR_OVERRIDDEN_BY_VAL_FACTORY: JetSingleIntentionActionFactory = object: JetSingleIntentionActionFactory() {
             override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-                return ChangeVariableMutabilityFix(diagnostic.getPsiElement() as JetProperty, true)
+                return ChangeVariableMutabilityFix(diagnostic.getPsiElement() as KtProperty, true)
             }
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVariableTypeFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVariableTypeFix.java
index 6e4970e3646..79b53ab7abd 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVariableTypeFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVariableTypeFix.java
@@ -40,19 +40,19 @@ import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.KtType;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
 
-public class ChangeVariableTypeFix extends KotlinQuickFixAction<JetVariableDeclaration> {
+public class ChangeVariableTypeFix extends KotlinQuickFixAction<KtVariableDeclaration> {
     private final static Logger LOG = Logger.getInstance(ChangeVariableTypeFix.class);
 
-    private final JetType type;
+    private final KtType type;
 
-    public ChangeVariableTypeFix(@NotNull JetVariableDeclaration element, @NotNull JetType type) {
+    public ChangeVariableTypeFix(@NotNull KtVariableDeclaration element, @NotNull KtType type) {
         super(element);
         this.type = type;
     }
@@ -79,28 +79,28 @@ public class ChangeVariableTypeFix extends KotlinQuickFixAction<JetVariableDecla
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(file);
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(file);
 
         PsiElement nameIdentifier = getElement().getNameIdentifier();
         assert nameIdentifier != null : "ChangeVariableTypeFix applied to variable without name";
 
-        JetTypeReference replacingTypeReference = psiFactory.createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type));
-        ArrayList<JetTypeReference> toShorten = new ArrayList<JetTypeReference>();
+        KtTypeReference replacingTypeReference = psiFactory.createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type));
+        ArrayList<KtTypeReference> toShorten = new ArrayList<KtTypeReference>();
         toShorten.add(getElement().setTypeReference(replacingTypeReference));
 
-        if (getElement() instanceof JetProperty) {
-            JetPropertyAccessor getter = ((JetProperty) getElement()).getGetter();
-            JetTypeReference getterReturnTypeRef = getter == null ? null : getter.getReturnTypeReference();
+        if (getElement() instanceof KtProperty) {
+            KtPropertyAccessor getter = ((KtProperty) getElement()).getGetter();
+            KtTypeReference getterReturnTypeRef = getter == null ? null : getter.getReturnTypeReference();
             if (getterReturnTypeRef != null) {
-                toShorten.add((JetTypeReference) getterReturnTypeRef.replace(replacingTypeReference));
+                toShorten.add((KtTypeReference) getterReturnTypeRef.replace(replacingTypeReference));
             }
 
-            JetPropertyAccessor setter = ((JetProperty) getElement()).getSetter();
-            JetParameter setterParameter = setter == null ? null : setter.getParameter();
-            JetTypeReference setterParameterTypeRef = setterParameter == null ? null : setterParameter.getTypeReference();
+            KtPropertyAccessor setter = ((KtProperty) getElement()).getSetter();
+            KtParameter setterParameter = setter == null ? null : setter.getParameter();
+            KtTypeReference setterParameterTypeRef = setterParameter == null ? null : setterParameter.getTypeReference();
             if (setterParameterTypeRef != null) {
-                toShorten.add((JetTypeReference) setterParameterTypeRef.replace(replacingTypeReference));
+                toShorten.add((KtTypeReference) setterParameterTypeRef.replace(replacingTypeReference));
             }
         }
 
@@ -113,14 +113,15 @@ public class ChangeVariableTypeFix extends KotlinQuickFixAction<JetVariableDecla
             @Nullable
             @Override
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
-                JetMultiDeclarationEntry entry = ChangeFunctionReturnTypeFix.getMultiDeclarationEntryThatTypeMismatchComponentFunction(diagnostic);
+                KtMultiDeclarationEntry
+                        entry = ChangeFunctionReturnTypeFix.getMultiDeclarationEntryThatTypeMismatchComponentFunction(diagnostic);
                 BindingContext context = ResolutionUtils.analyze(entry);
                 ResolvedCall<FunctionDescriptor> resolvedCall = context.get(BindingContext.COMPONENT_RESOLVED_CALL, entry);
                 if (resolvedCall == null) return null;
-                JetFunction componentFunction = (JetFunction) DescriptorToSourceUtils
+                KtFunction componentFunction = (KtFunction) DescriptorToSourceUtils
                         .descriptorToDeclaration(resolvedCall.getCandidateDescriptor());
                 if (componentFunction == null) return null;
-                JetType expectedType = resolvedCall.getCandidateDescriptor().getReturnType();
+                KtType expectedType = resolvedCall.getCandidateDescriptor().getReturnType();
                 return expectedType == null ? null : new ChangeVariableTypeFix(entry, expectedType);
             }
         };
@@ -134,30 +135,31 @@ public class ChangeVariableTypeFix extends KotlinQuickFixAction<JetVariableDecla
             protected List<IntentionAction> doCreateActions(@NotNull Diagnostic diagnostic) {
                 List<IntentionAction> actions = new LinkedList<IntentionAction>();
 
-                if (diagnostic.getPsiElement() instanceof JetProperty) {
-                    JetProperty property = (JetProperty) diagnostic.getPsiElement();
+                if (diagnostic.getPsiElement() instanceof KtProperty) {
+                    KtProperty property = (KtProperty) diagnostic.getPsiElement();
                     DeclarationDescriptor descriptor = ResolutionUtils.resolveToDescriptor(property);
                     if (!(descriptor instanceof PropertyDescriptor)) return actions;
                     PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
 
-                    JetType lowerBoundOfOverriddenPropertiesTypes = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(propertyDescriptor);
+                    KtType
+                            lowerBoundOfOverriddenPropertiesTypes = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(propertyDescriptor);
 
-                    JetType propertyType = propertyDescriptor.getReturnType();
+                    KtType propertyType = propertyDescriptor.getReturnType();
                     assert propertyType != null : "Property type cannot be null if it mismatch something";
 
                     List<PropertyDescriptor> overriddenMismatchingProperties = new LinkedList<PropertyDescriptor>();
                     boolean canChangeOverriddenPropertyType = true;
                     for (PropertyDescriptor overriddenProperty: propertyDescriptor.getOverriddenDescriptors()) {
-                        JetType overriddenPropertyType = overriddenProperty.getReturnType();
+                        KtType overriddenPropertyType = overriddenProperty.getReturnType();
                         if (overriddenPropertyType != null) {
-                            if (!JetTypeChecker.DEFAULT.isSubtypeOf(propertyType, overriddenPropertyType)) {
+                            if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(propertyType, overriddenPropertyType)) {
                                 overriddenMismatchingProperties.add(overriddenProperty);
                             }
-                            else if (overriddenProperty.isVar() && !JetTypeChecker.DEFAULT.equalTypes(overriddenPropertyType, propertyType)) {
+                            else if (overriddenProperty.isVar() && !KotlinTypeChecker.DEFAULT.equalTypes(overriddenPropertyType, propertyType)) {
                                 canChangeOverriddenPropertyType = false;
                             }
                             if (overriddenProperty.isVar() && lowerBoundOfOverriddenPropertiesTypes != null &&
-                                !JetTypeChecker.DEFAULT.equalTypes(lowerBoundOfOverriddenPropertiesTypes, overriddenPropertyType)) {
+                                !KotlinTypeChecker.DEFAULT.equalTypes(lowerBoundOfOverriddenPropertiesTypes, overriddenPropertyType)) {
                                 lowerBoundOfOverriddenPropertiesTypes = null;
                             }
                         }
@@ -170,8 +172,8 @@ public class ChangeVariableTypeFix extends KotlinQuickFixAction<JetVariableDecla
                     if (overriddenMismatchingProperties.size() == 1 && canChangeOverriddenPropertyType) {
                         PsiElement overriddenProperty = DescriptorToSourceUtils
                                 .descriptorToDeclaration(overriddenMismatchingProperties.get(0));
-                        if (overriddenProperty instanceof JetProperty) {
-                            actions.add(new ChangeVariableTypeFix((JetProperty) overriddenProperty, propertyType));
+                        if (overriddenProperty instanceof KtProperty) {
+                            actions.add(new ChangeVariableTypeFix((KtProperty) overriddenProperty, propertyType));
                         }
                     }
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVisibilityModifierFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVisibilityModifierFix.java
index 1f8d72dd2f4..699abec4d3f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVisibilityModifierFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVisibilityModifierFix.java
@@ -32,14 +32,14 @@ import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
 import org.jetbrains.kotlin.idea.core.DescriptorUtilsKt;
 import org.jetbrains.kotlin.idea.core.PsiModificationUtilsKt;
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
-import org.jetbrains.kotlin.psi.JetDeclaration;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetParameter;
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtParameter;
 import org.jetbrains.kotlin.resolve.BindingContext;
 
-public class ChangeVisibilityModifierFix extends KotlinQuickFixAction<JetDeclaration> {
-    public ChangeVisibilityModifierFix(@NotNull JetDeclaration element) {
+public class ChangeVisibilityModifierFix extends KotlinQuickFixAction<KtDeclaration> {
+    public ChangeVisibilityModifierFix(@NotNull KtDeclaration element) {
         super(element);
     }
 
@@ -57,22 +57,22 @@ public class ChangeVisibilityModifierFix extends KotlinQuickFixAction<JetDeclara
 
     @Override
     public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
-        if (!(file instanceof JetFile)) return false;
-        return super.isAvailable(project, editor, file) && (findVisibilityChangeTo((JetFile)file) != null);
+        if (!(file instanceof KtFile)) return false;
+        return super.isAvailable(project, editor, file) && (findVisibilityChangeTo((KtFile)file) != null);
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetModifierKeywordToken modifier = findVisibilityChangeTo(file);
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        KtModifierKeywordToken modifier = findVisibilityChangeTo(file);
         assert modifier != null;
         PsiModificationUtilsKt.setVisibility(getElement(), modifier);
     }
 
     @Nullable
-    private JetModifierKeywordToken findVisibilityChangeTo(JetFile file) {
+    private KtModifierKeywordToken findVisibilityChangeTo(KtFile file) {
         BindingContext bindingContext = ResolutionUtils.analyze(getElement());
         DeclarationDescriptor descriptor;
-        if (getElement() instanceof JetParameter) {
+        if (getElement() instanceof KtParameter) {
             descriptor = bindingContext.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, getElement());
         }
         else {
@@ -110,10 +110,10 @@ public class ChangeVisibilityModifierFix extends KotlinQuickFixAction<JetDeclara
     public static JetSingleIntentionActionFactory createFactory() {
         return new JetSingleIntentionActionFactory() {
             @Override
-            public KotlinQuickFixAction<JetDeclaration> createAction(Diagnostic diagnostic) {
+            public KotlinQuickFixAction<KtDeclaration> createAction(Diagnostic diagnostic) {
                 PsiElement element = diagnostic.getPsiElement();
-                if (!(element instanceof JetDeclaration)) return null;
-                return new ChangeVisibilityModifierFix((JetDeclaration)element);
+                if (!(element instanceof KtDeclaration)) return null;
+                return new ChangeVisibilityModifierFix((KtDeclaration)element);
             }
         };
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedFunctionConventionFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedFunctionConventionFix.kt
index 8685f661bd2..8237b00bd39 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedFunctionConventionFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedFunctionConventionFix.kt
@@ -27,18 +27,18 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters2
 import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters3
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetOperationReferenceExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtOperationReferenceExpression
 
 class DeprecatedFunctionConventionFix(
-        element: JetNamedFunction,
+        element: KtNamedFunction,
         private val newName: String
-) : KotlinQuickFixAction<JetNamedFunction>(element), CleanupFix {
+) : KotlinQuickFixAction<KtNamedFunction>(element), CleanupFix {
     override fun getText(): String = "Rename to '$newName'"
     override fun getFamilyName(): String = text
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         FilteredRenameProcessor(project, element, newName, false, false).run()
     }
 
@@ -52,7 +52,7 @@ class DeprecatedFunctionConventionFix(
             if (functionDescriptor !is FunctionDescriptor || newName !is String) return null
 
             val element = DescriptorToSourceUtilsIde.getAnyDeclaration(diagnostic.psiFile.project, functionDescriptor)
-                    as? JetNamedFunction ?: return null
+                    as? KtNamedFunction ?: return null
             return DeprecatedFunctionConventionFix(element, newName)
         }
     }
@@ -66,7 +66,7 @@ class DeprecatedFunctionConventionFix(
     ) : RenameProcessor(project, element, newName, isSearchInComments, isSearchTextOccurrences) {
         override fun findUsages(): Array<out UsageInfo> {
             return super.findUsages().filter {
-                it.element !is JetOperationReferenceExpression
+                it.element !is KtOperationReferenceExpression
             }.toTypedArray()
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ExclExlCallFixes.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ExclExlCallFixes.kt
index ad5ff7f157d..3083eb729b9 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ExclExlCallFixes.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ExclExlCallFixes.kt
@@ -25,18 +25,18 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.JetBundle
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetPostfixExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtPostfixExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 
 public abstract class ExclExclCallFix : IntentionAction {
     override fun getFamilyName(): String = getText()
 
     override fun startInWriteAction(): Boolean = true
 
-    override fun isAvailable(project: Project, editor: Editor?, file: PsiFile) = file is JetFile
+    override fun isAvailable(project: Project, editor: Editor?, file: PsiFile) = file is KtFile
 }
 
 public class RemoveExclExclCallFix(val psiElement: PsiElement) : ExclExclCallFix(), CleanupFix {
@@ -50,13 +50,13 @@ public class RemoveExclExclCallFix(val psiElement: PsiElement) : ExclExclCallFix
         if (!FileModificationService.getInstance().prepareFileForWrite(file)) return
 
         val postfixExpression = getExclExclPostfixExpression() ?: return
-        val expression = JetPsiFactory(project).createExpression(postfixExpression.getBaseExpression()!!.getText())
+        val expression = KtPsiFactory(project).createExpression(postfixExpression.getBaseExpression()!!.getText())
         postfixExpression.replace(expression)
     }
 
-    private fun getExclExclPostfixExpression(): JetPostfixExpression? {
+    private fun getExclExclPostfixExpression(): KtPostfixExpression? {
         val operationParent = psiElement.getParent()
-        if (operationParent is JetPostfixExpression && operationParent.getBaseExpression() != null) {
+        if (operationParent is KtPostfixExpression && operationParent.getBaseExpression() != null) {
             return operationParent
         }
         return null
@@ -77,14 +77,14 @@ public class AddExclExclCallFix(val psiElement: PsiElement) : ExclExclCallFix()
 
     override fun invoke(project: Project, editor: Editor?, file: PsiFile?) {
         val modifiedExpression = getExpressionForIntroduceCall() ?: return
-        val exclExclExpression = JetPsiFactory(project).createExpression(modifiedExpression.getText() + "!!")
+        val exclExclExpression = KtPsiFactory(project).createExpression(modifiedExpression.getText() + "!!")
         modifiedExpression.replace(exclExclExpression)
     }
 
-    protected fun getExpressionForIntroduceCall(): JetExpression? {
-        if (psiElement is LeafPsiElement && psiElement.getElementType() == JetTokens.DOT) {
+    protected fun getExpressionForIntroduceCall(): KtExpression? {
+        if (psiElement is LeafPsiElement && psiElement.getElementType() == KtTokens.DOT) {
             val sibling = psiElement.getPrevSibling()
-            if (sibling is JetExpression) {
+            if (sibling is KtExpression) {
                 return sibling
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/InsertDelegationCallQuickfix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/InsertDelegationCallQuickfix.kt
index d2b8337ab67..45a24fd8ff3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/InsertDelegationCallQuickfix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/InsertDelegationCallQuickfix.kt
@@ -27,22 +27,22 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.quickfix.quickfixUtil.createIntentionForFirstParentOfType
 import org.jetbrains.kotlin.idea.search.usagesSearch.descriptor
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetSecondaryConstructor
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtSecondaryConstructor
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.isReallySuccess
 
 
-public class InsertDelegationCallQuickfix(val isThis: Boolean, element: JetSecondaryConstructor) : KotlinQuickFixAction<JetSecondaryConstructor>(element) {
+public class InsertDelegationCallQuickfix(val isThis: Boolean, element: KtSecondaryConstructor) : KotlinQuickFixAction<KtSecondaryConstructor>(element) {
     override fun getText() = JetBundle.message("insert.delegation.call", keywordToUse)
     override fun getFamilyName() = "Insert explicit delegation call"
 
     private val keywordToUse = if (isThis) "this" else "super"
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         val newDelegationCall = element.replaceImplicitDelegationCallWithExplicit(isThis)
 
         val resolvedCall = newDelegationCall.getResolvedCall(newDelegationCall.analyze())
@@ -61,7 +61,7 @@ public class InsertDelegationCallQuickfix(val isThis: Boolean, element: JetSecon
     }
 
     object InsertThisDelegationCallFactory : JetSingleIntentionActionFactory() {
-        override fun createAction(diagnostic: Diagnostic) = diagnostic.createIntentionForFirstParentOfType<JetSecondaryConstructor> {
+        override fun createAction(diagnostic: Diagnostic) = diagnostic.createIntentionForFirstParentOfType<KtSecondaryConstructor> {
             secondaryConstructor ->
             if (secondaryConstructor.getContainingClassOrObject().getConstructorsCount() <= 1 ||
                 !secondaryConstructor.hasImplicitDelegationCall()) return null
@@ -69,14 +69,14 @@ public class InsertDelegationCallQuickfix(val isThis: Boolean, element: JetSecon
             return InsertDelegationCallQuickfix(isThis = true, element = secondaryConstructor)
         }
 
-        private fun JetClassOrObject.getConstructorsCount() = (descriptor as ClassDescriptor).getConstructors().size()
+        private fun KtClassOrObject.getConstructorsCount() = (descriptor as ClassDescriptor).getConstructors().size()
     }
 
     object InsertSuperDelegationCallFactory : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-            val secondaryConstructor = diagnostic.getPsiElement().getNonStrictParentOfType<JetSecondaryConstructor>() ?: return null
+            val secondaryConstructor = diagnostic.getPsiElement().getNonStrictParentOfType<KtSecondaryConstructor>() ?: return null
             if (!secondaryConstructor.hasImplicitDelegationCall()) return null
-            val klass = secondaryConstructor.getContainingClassOrObject() as? JetClass ?: return null
+            val klass = secondaryConstructor.getContainingClassOrObject() as? KtClass ?: return null
             if (klass.hasPrimaryConstructor()) return null
 
             return InsertDelegationCallQuickfix(isThis = false, element = secondaryConstructor)
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/JetWholeProjectModalAction.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/JetWholeProjectModalAction.kt
index 1bfe6a566db..9fa75703b77 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/JetWholeProjectModalAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/JetWholeProjectModalAction.kt
@@ -32,10 +32,10 @@ import org.jetbrains.kotlin.idea.project.PluginJetFilesProvider
 import org.jetbrains.kotlin.idea.util.application.executeCommand
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetVisitor
-import org.jetbrains.kotlin.psi.JetVisitorVoid
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtVisitor
+import org.jetbrains.kotlin.psi.KtVisitorVoid
 import org.jetbrains.kotlin.psi.psiUtil.flatMapDescendantsOfTypeVisitor
 import org.jetbrains.kotlin.utils.singletonOrEmptyList
 import java.util.HashMap
@@ -53,7 +53,7 @@ public abstract class JetWholeProjectModalAction<TData : Any>(val title: String)
         ProgressManager.getInstance().run(
             object : Task.Modal(project, title, true) {
                 override fun run(indicator: ProgressIndicator) {
-                    val filesToData = HashMap<JetFile, TData>()
+                    val filesToData = HashMap<KtFile, TData>()
                     runReadAction (fun() {
                         val files = PluginJetFilesProvider.allFilesInProject(project)
 
@@ -77,7 +77,7 @@ public abstract class JetWholeProjectModalAction<TData : Any>(val title: String)
                 }
             })
 
-    private fun applyAll(project: Project, filesToData: Map<JetFile, TData>) {
+    private fun applyAll(project: Project, filesToData: Map<KtFile, TData>) {
         UIUtil.invokeLaterIfNeeded {
             project.executeCommand(getText()) {
                 runWriteAction {
@@ -95,25 +95,25 @@ public abstract class JetWholeProjectModalAction<TData : Any>(val title: String)
     }
 
     // this method will be started under read action
-    protected abstract fun collectDataForFile(project: Project, file: JetFile): TData?
+    protected abstract fun collectDataForFile(project: Project, file: KtFile): TData?
 
     // this method will be started under write action
-    protected abstract fun applyChangesForFile(project: Project, file: JetFile, data: TData)
+    protected abstract fun applyChangesForFile(project: Project, file: KtFile, data: TData)
 }
 
 public abstract class JetWholeProjectModalByCollectionAction<TTask : Any>(modalTitle: String)
 : JetWholeProjectModalAction<Collection<TTask>>(modalTitle) {
-    override fun collectDataForFile(project: Project, file: JetFile): Collection<TTask>? {
+    override fun collectDataForFile(project: Project, file: KtFile): Collection<TTask>? {
         val accumulator = arrayListOf<TTask>()
         collectTasksForFile(project, file, accumulator)
         return if (!accumulator.isEmpty()) accumulator else null
     }
 
-    abstract fun collectTasksForFile(project: Project, file: JetFile, accumulator: MutableCollection<TTask>)
+    abstract fun collectTasksForFile(project: Project, file: KtFile, accumulator: MutableCollection<TTask>)
 }
 
 internal class JetWholeProjectForEachElementOfTypeFix<TTask : Any> private constructor(
-        private val collectingVisitorFactory: (MutableCollection<TTask>) -> JetVisitorVoid,
+        private val collectingVisitorFactory: (MutableCollection<TTask>) -> KtVisitorVoid,
         private val tasksProcessor: (Collection<TTask>) -> Unit,
         private val name: String,
         private val familyName: String = name
@@ -122,13 +122,13 @@ internal class JetWholeProjectForEachElementOfTypeFix<TTask : Any> private const
     override fun getFamilyName() = familyName
     override fun getText() = name
 
-    override fun collectTasksForFile(project: Project, file: JetFile, accumulator: MutableCollection<TTask>) {
+    override fun collectTasksForFile(project: Project, file: KtFile, accumulator: MutableCollection<TTask>) {
         file.accept(collectingVisitorFactory(accumulator))
     }
-    override fun applyChangesForFile(project: Project, file: JetFile, data: Collection<TTask>) = tasksProcessor(data)
+    override fun applyChangesForFile(project: Project, file: KtFile, data: Collection<TTask>) = tasksProcessor(data)
 
     companion object {
-        inline fun <reified TElement : JetElement> createByPredicate(
+        inline fun <reified TElement : KtElement> createByPredicate(
                 noinline predicate: (TElement) -> Boolean,
                 noinline taskProcessor: (TElement) -> Unit,
                 name: String
@@ -138,7 +138,7 @@ internal class JetWholeProjectForEachElementOfTypeFix<TTask : Any> private const
                 name = name
         )
 
-        inline fun <reified TElement : JetElement, TTask : Any> createByTaskFactory(
+        inline fun <reified TElement : KtElement, TTask : Any> createByTaskFactory(
                 noinline taskFactory: (TElement) -> TTask?,
                 noinline taskProcessor: (TTask) -> Unit,
                 name: String
@@ -148,7 +148,7 @@ internal class JetWholeProjectForEachElementOfTypeFix<TTask : Any> private const
                 name = name
         )
 
-        inline fun <reified TElement : JetElement, TTask : Any> createForMultiTaskOnElement(
+        inline fun <reified TElement : KtElement, TTask : Any> createForMultiTaskOnElement(
                 noinline tasksFactory: (TElement) -> Collection<TTask>,
                 noinline tasksProcessor: (Collection<TTask>) -> Unit,
                 name: String
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinAddOrderEntryActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinAddOrderEntryActionFactory.kt
index aab988e5e3f..0132cb05299 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinAddOrderEntryActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinAddOrderEntryActionFactory.kt
@@ -24,19 +24,19 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiReference
 import com.intellij.psi.PsiReferenceBase
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference.ShorteningMode
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference.ShorteningMode
 import org.jetbrains.kotlin.idea.references.mainReference
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElement
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
 public object KotlinAddOrderEntryActionFactory : JetIntentionActionsFactory() {
     override fun doCreateActions(diagnostic: Diagnostic): List<IntentionAction> {
-        val simpleExpression = diagnostic.psiElement as? JetSimpleNameExpression ?: return emptyList()
+        val simpleExpression = diagnostic.psiElement as? KtSimpleNameExpression ?: return emptyList()
         val refElement = simpleExpression.getQualifiedElement()
 
-        val reference = object: PsiReferenceBase<JetElement>(refElement) {
+        val reference = object: PsiReferenceBase<KtElement>(refElement) {
             override fun resolve() = null
 
             override fun getVariants() = PsiReference.EMPTY_ARRAY
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinIntentionActionFactoryWithDelegate.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinIntentionActionFactoryWithDelegate.kt
index 009edfeb600..f3a45ea5d47 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinIntentionActionFactoryWithDelegate.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinIntentionActionFactoryWithDelegate.kt
@@ -22,11 +22,11 @@ import com.intellij.psi.SmartPsiElementPointer
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.psiUtil.createSmartPointer
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 
-abstract class KotlinSingleIntentionActionFactoryWithDelegate<E : JetElement, D : Any>(
+abstract class KotlinSingleIntentionActionFactoryWithDelegate<E : KtElement, D : Any>(
         private val actionPriority: IntentionActionPriority = IntentionActionPriority.NORMAL
 ) : KotlinIntentionActionFactoryWithDelegate<E, D>() {
 
@@ -51,7 +51,7 @@ abstract class KotlinSingleIntentionActionFactoryWithDelegate<E : JetElement, D
     }
 }
 
-abstract class KotlinIntentionActionFactoryWithDelegate<E : JetElement, D : Any> : JetIntentionActionsFactory() {
+abstract class KotlinIntentionActionFactoryWithDelegate<E : KtElement, D : Any> : JetIntentionActionsFactory() {
     protected abstract fun getElementOfInterest(diagnostic: Diagnostic): E?
 
     protected abstract fun createFixes(
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinQuickFixAction.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinQuickFixAction.kt
index 84e5e4d1849..b479e7c8f97 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinQuickFixAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinQuickFixAction.kt
@@ -22,22 +22,22 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
-import org.jetbrains.kotlin.psi.JetCodeFragment
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtCodeFragment
+import org.jetbrains.kotlin.psi.KtFile
 
 abstract class KotlinQuickFixAction<T : PsiElement>(protected val element: T) : IntentionAction {
 
     override fun isAvailable(project: Project, editor: Editor?, file: PsiFile): Boolean {
-        return element.isValid && (file.manager.isInProject(file) || file is JetCodeFragment) && (file is JetFile)
+        return element.isValid && (file.manager.isInProject(file) || file is KtCodeFragment) && (file is KtFile)
     }
 
     override final fun invoke(project: Project, editor: Editor?, file: PsiFile) {
-        if (file is JetFile && FileModificationService.getInstance().prepareFileForWrite(element.containingFile)) {
+        if (file is KtFile && FileModificationService.getInstance().prepareFileForWrite(element.containingFile)) {
             invoke(project, editor, file)
         }
     }
 
-    protected abstract fun invoke(project: Project, editor: Editor?, file: JetFile)
+    protected abstract fun invoke(project: Project, editor: Editor?, file: KtFile)
 
     override fun startInWriteAction() = true
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinReferenceImporter.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinReferenceImporter.kt
index 92a0a93142e..a7cf8087d47 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinReferenceImporter.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinReferenceImporter.kt
@@ -29,8 +29,8 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.targetDescriptors
 import org.jetbrains.kotlin.idea.imports.importableFqName
 import org.jetbrains.kotlin.idea.references.mainReference
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.psiUtil.collectDescendantsOfType
 import org.jetbrains.kotlin.psi.psiUtil.elementsInRange
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
@@ -41,9 +41,9 @@ public class KotlinReferenceImporter : ReferenceImporter {
             = autoImportReferenceAtCursor(editor, file, allowCaretNearRef = false)
 
     override fun autoImportReferenceAt(editor: Editor, file: PsiFile, offset: Int): Boolean {
-        if (file !is JetFile) return false
+        if (file !is KtFile) return false
 
-        val nameExpression = file.findElementAt(offset)?.parent as? JetSimpleNameExpression ?: return false
+        val nameExpression = file.findElementAt(offset)?.parent as? KtSimpleNameExpression ?: return false
 
         return nameExpression.autoImport(editor, file)
     }
@@ -52,7 +52,7 @@ public class KotlinReferenceImporter : ReferenceImporter {
 
         // TODO: use in table cell
         public fun autoImportReferenceAtCursor(editor: Editor, file: PsiFile, allowCaretNearRef: Boolean): Boolean {
-            if (file !is JetFile) return false
+            if (file !is KtFile) return false
 
             val caretOffset = editor.caretModel.offset
             val document = editor.document
@@ -61,7 +61,7 @@ public class KotlinReferenceImporter : ReferenceImporter {
             val endOffset = document.getLineEndOffset(lineNumber)
 
             val elements = file.elementsInRange(TextRange(startOffset, endOffset))
-                    .flatMap { it.collectDescendantsOfType<JetSimpleNameExpression>() }
+                    .flatMap { it.collectDescendantsOfType<KtSimpleNameExpression>() }
             for (element in elements) {
                 if (!allowCaretNearRef && element.endOffset == caretOffset) continue
 
@@ -73,13 +73,13 @@ public class KotlinReferenceImporter : ReferenceImporter {
             return false
         }
 
-        protected fun hasUnresolvedImportWhichCanImport(file: JetFile, name: String): Boolean {
+        protected fun hasUnresolvedImportWhichCanImport(file: KtFile, name: String): Boolean {
             return file.importDirectives.any {
                 it.targetDescriptors().isEmpty() && (it.isAllUnder || it.importPath?.importedName?.asString() == name)
             }
         }
 
-        private fun JetSimpleNameExpression.autoImport(editor: Editor, file: JetFile): Boolean {
+        private fun KtSimpleNameExpression.autoImport(editor: Editor, file: KtFile): Boolean {
             if (!CodeInsightSettings.getInstance().ADD_UNAMBIGIOUS_IMPORTS_ON_THE_FLY) return false
             if (!DaemonListeners.canChangeFileSilently(file)) return false
             if (hasUnresolvedImportWhichCanImport(file, getReferencedName())) return false
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeClassAnAnnotationClassFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeClassAnAnnotationClassFix.java
index 41b7a33cfee..0ebc4f415f6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeClassAnAnnotationClassFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeClassAnAnnotationClassFix.java
@@ -30,14 +30,14 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
 import org.jetbrains.kotlin.idea.references.ReferenceUtilKt;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 
-public class MakeClassAnAnnotationClassFix extends KotlinQuickFixAction<JetAnnotationEntry> {
-    private final JetAnnotationEntry annotationEntry;
-    private JetClass annotationClass;
+public class MakeClassAnAnnotationClassFix extends KotlinQuickFixAction<KtAnnotationEntry> {
+    private final KtAnnotationEntry annotationEntry;
+    private KtClass annotationClass;
 
-    public MakeClassAnAnnotationClassFix(@NotNull JetAnnotationEntry annotationEntry) {
+    public MakeClassAnAnnotationClassFix(@NotNull KtAnnotationEntry annotationEntry) {
         super(annotationEntry);
         this.annotationEntry = annotationEntry;
     }
@@ -48,20 +48,20 @@ public class MakeClassAnAnnotationClassFix extends KotlinQuickFixAction<JetAnnot
             return false;
         }
 
-        JetTypeReference typeReference = annotationEntry.getTypeReference();
+        KtTypeReference typeReference = annotationEntry.getTypeReference();
         if (typeReference == null) {
             return false;
         }
 
-        JetSimpleNameExpression referenceExpression = PsiTreeUtil.findChildOfType(typeReference, JetSimpleNameExpression.class);
+        KtSimpleNameExpression referenceExpression = PsiTreeUtil.findChildOfType(typeReference, KtSimpleNameExpression.class);
         if (referenceExpression == null) {
             return false;
         }
 
         PsiReference reference = ReferenceUtilKt.getMainReference(referenceExpression);
         PsiElement target = reference.resolve();
-        if (target instanceof JetClass) {
-            annotationClass = (JetClass) target;
+        if (target instanceof KtClass) {
+            annotationClass = (KtClass) target;
             return QuickFixUtil.canModifyElement(annotationClass);
         }
 
@@ -81,16 +81,16 @@ public class MakeClassAnAnnotationClassFix extends KotlinQuickFixAction<JetAnnot
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, @NotNull JetFile file) throws IncorrectOperationException {
-        JetPsiFactory factory = new JetPsiFactory(annotationClass.getProject());
-        JetModifierList list = annotationClass.getModifierList();
+    public void invoke(@NotNull Project project, Editor editor, @NotNull KtFile file) throws IncorrectOperationException {
+        KtPsiFactory factory = new KtPsiFactory(annotationClass.getProject());
+        KtModifierList list = annotationClass.getModifierList();
         PsiElement added;
         if (list == null) {
-            JetModifierList newModifierList = factory.createModifierList(JetTokens.ANNOTATION_KEYWORD);
+            KtModifierList newModifierList = factory.createModifierList(KtTokens.ANNOTATION_KEYWORD);
             added = annotationClass.addBefore(newModifierList, annotationClass.getClassOrInterfaceKeyword());
         }
         else {
-            PsiElement entry = factory.createModifier(JetTokens.ANNOTATION_KEYWORD);
+            PsiElement entry = factory.createModifier(KtTokens.ANNOTATION_KEYWORD);
             added = list.addBefore(entry, list.getFirstChild());
         }
         annotationClass.addAfter(factory.createWhiteSpace(), added);
@@ -102,7 +102,7 @@ public class MakeClassAnAnnotationClassFix extends KotlinQuickFixAction<JetAnnot
             @Nullable
             @Override
             public IntentionAction createAction(Diagnostic diagnostic) {
-                JetAnnotationEntry annotation = QuickFixUtil.getParentElementOfType(diagnostic, JetAnnotationEntry.class);
+                KtAnnotationEntry annotation = QuickFixUtil.getParentElementOfType(diagnostic, KtAnnotationEntry.class);
                 return annotation == null ? null : new MakeClassAnAnnotationClassFix(annotation);
             }
         };
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeOverriddenMemberOpenFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeOverriddenMemberOpenFix.kt
index 7eda82e7b6d..f4d0681b81f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeOverriddenMemberOpenFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeOverriddenMemberOpenFix.kt
@@ -28,20 +28,20 @@ import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYNTHESIZE
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
-import org.jetbrains.kotlin.lexer.JetTokens.OPEN_KEYWORD
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.lexer.KtTokens.OPEN_KEYWORD
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import java.util.*
 
-public class MakeOverriddenMemberOpenFix(declaration: JetDeclaration) : KotlinQuickFixAction<JetDeclaration>(declaration) {
-    private val overriddenNonOverridableMembers = ArrayList<JetCallableDeclaration>()
+public class MakeOverriddenMemberOpenFix(declaration: KtDeclaration) : KotlinQuickFixAction<KtDeclaration>(declaration) {
+    private val overriddenNonOverridableMembers = ArrayList<KtCallableDeclaration>()
     private val containingDeclarationsNames = ArrayList<String>()
 
     override fun isAvailable(project: Project, editor: Editor?, file: PsiFile): Boolean {
-        if (!super.isAvailable(project, editor, file) || file !is JetFile) {
+        if (!super.isAvailable(project, editor, file) || file !is KtFile) {
             return false
         }
 
@@ -56,7 +56,7 @@ public class MakeOverriddenMemberOpenFix(declaration: JetDeclaration) : KotlinQu
                 descriptor)) {
             assert(overriddenDescriptor.kind == DECLARATION) { "Can only be applied to declarations." }
             val overriddenMember = DescriptorToSourceUtils.descriptorToDeclaration(overriddenDescriptor)
-            if (overriddenMember == null || !QuickFixUtil.canModifyElement(overriddenMember) || overriddenMember !is JetCallableDeclaration) {
+            if (overriddenMember == null || !QuickFixUtil.canModifyElement(overriddenMember) || overriddenMember !is KtCallableDeclaration) {
                 return false
             }
             val containingDeclarationName = overriddenDescriptor.containingDeclaration.name.asString()
@@ -80,7 +80,7 @@ public class MakeOverriddenMemberOpenFix(declaration: JetDeclaration) : KotlinQu
 
     override fun getFamilyName(): String = "Add Modifier"
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         for (overriddenMember in overriddenNonOverridableMembers) {
             overriddenMember.addModifier(OPEN_KEYWORD)
         }
@@ -114,7 +114,7 @@ public class MakeOverriddenMemberOpenFix(declaration: JetDeclaration) : KotlinQu
         }
 
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-            val declaration = diagnostic.psiElement.getNonStrictParentOfType<JetDeclaration>()!!
+            val declaration = diagnostic.psiElement.getNonStrictParentOfType<KtDeclaration>()!!
             return MakeOverriddenMemberOpenFix(declaration)
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/MapPlatformClassToKotlinFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/MapPlatformClassToKotlinFix.kt
index 964bb8c57c3..e549622de7f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/MapPlatformClassToKotlinFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/MapPlatformClassToKotlinFix.kt
@@ -44,10 +44,10 @@ import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import java.util.*
 
 class MapPlatformClassToKotlinFix(
-        element: JetReferenceExpression,
+        element: KtReferenceExpression,
         private val platformClass: ClassDescriptor,
         private val possibleClasses: Collection<ClassDescriptor>
-) : KotlinQuickFixAction<JetReferenceExpression>(element) {
+) : KotlinQuickFixAction<KtReferenceExpression>(element) {
 
     override fun getText(): String {
         val platformClassQualifiedName = DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(platformClass.defaultType)
@@ -60,11 +60,11 @@ class MapPlatformClassToKotlinFix(
 
     override fun getFamilyName() = "Change to Kotlin class"
 
-    public override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    public override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         val bindingContext = file.analyzeFully()
 
-        val imports = ArrayList<JetImportDirective>()
-        val usages = ArrayList<JetUserType>()
+        val imports = ArrayList<KtImportDirective>()
+        val usages = ArrayList<KtUserType>()
 
         for (diagnostic in bindingContext.diagnostics) {
             if (diagnostic.factory !== Errors.PLATFORM_CLASS_MAPPED_TO_KOTLIN) continue
@@ -72,12 +72,12 @@ class MapPlatformClassToKotlinFix(
             val refExpr = getImportOrUsageFromDiagnostic(diagnostic) ?: continue
             if (resolveToClass(refExpr, bindingContext) != platformClass) continue
 
-            val import = refExpr.getStrictParentOfType<JetImportDirective>()
+            val import = refExpr.getStrictParentOfType<KtImportDirective>()
             if (import != null) {
                 imports.add(import)
             }
             else {
-                usages.add(refExpr.getStrictParentOfType<JetUserType>() ?: continue)
+                usages.add(refExpr.getStrictParentOfType<KtUserType>() ?: continue)
             }
         }
 
@@ -99,18 +99,18 @@ class MapPlatformClassToKotlinFix(
         }
     }
 
-    private fun replaceUsagesWithFirstClass(project: Project, usages: List<JetUserType>): List<PsiElement> {
+    private fun replaceUsagesWithFirstClass(project: Project, usages: List<KtUserType>): List<PsiElement> {
         val replacementClass = possibleClasses.first()
         val replacementClassName = replacementClass.name.asString()
         val replacedElements = ArrayList<PsiElement>()
         for (usage in usages) {
             val typeArguments = usage.typeArgumentList
             val typeArgumentsString = if (typeArguments == null) "" else typeArguments.text
-            val replacementType = JetPsiFactory(project).createType(replacementClassName + typeArgumentsString)
+            val replacementType = KtPsiFactory(project).createType(replacementClassName + typeArgumentsString)
             val replacementTypeElement = replacementType.typeElement!!
             val replacedElement = usage.replace(replacementTypeElement)
             val replacedExpression = replacedElement.firstChild
-            assert(replacedExpression is JetSimpleNameExpression) // assumption: the Kotlin class requires no imports
+            assert(replacedExpression is KtSimpleNameExpression) // assumption: the Kotlin class requires no imports
             replacedElements.add(replacedExpression)
         }
         return replacedElements
@@ -148,15 +148,15 @@ class MapPlatformClassToKotlinFix(
         })
     }
 
-    companion object : KotlinSingleIntentionActionFactoryWithDelegate<JetReferenceExpression, Data>() {
-        data class Data(val element: JetReferenceExpression,
+    companion object : KotlinSingleIntentionActionFactoryWithDelegate<KtReferenceExpression, Data>() {
+        data class Data(val element: KtReferenceExpression,
                         val platformClass: ClassDescriptor,
                         val possibleClasses: Collection<ClassDescriptor>)
 
-        override fun getElementOfInterest(diagnostic: Diagnostic): JetReferenceExpression?
+        override fun getElementOfInterest(diagnostic: Diagnostic): KtReferenceExpression?
                 = getImportOrUsageFromDiagnostic(diagnostic)
 
-        override fun extractFixData(element: JetReferenceExpression, diagnostic: Diagnostic): Data? {
+        override fun extractFixData(element: KtReferenceExpression, diagnostic: Diagnostic): Data? {
             val context = element.analyze(BodyResolveMode.PARTIAL)
             val platformClass = resolveToClass(element, context) ?: return null
             val possibleClasses = Errors.PLATFORM_CLASS_MAPPED_TO_KOTLIN.cast(diagnostic).a
@@ -167,17 +167,17 @@ class MapPlatformClassToKotlinFix(
             return MapPlatformClassToKotlinFix(data.element, data.platformClass, data.possibleClasses)
         }
 
-        private fun resolveToClass(referenceExpression: JetReferenceExpression, context: BindingContext): ClassDescriptor? {
+        private fun resolveToClass(referenceExpression: KtReferenceExpression, context: BindingContext): ClassDescriptor? {
             return referenceExpression.mainReference.resolveToDescriptors(context).firstIsInstanceOrNull<ClassDescriptor>()
         }
 
-        private fun getImportOrUsageFromDiagnostic(diagnostic: Diagnostic): JetReferenceExpression? {
-            val import = diagnostic.psiElement.getNonStrictParentOfType<JetImportDirective>()
+        private fun getImportOrUsageFromDiagnostic(diagnostic: Diagnostic): KtReferenceExpression? {
+            val import = diagnostic.psiElement.getNonStrictParentOfType<KtImportDirective>()
             return if (import != null) {
-                import.importedReference?.getQualifiedElementSelector() as? JetReferenceExpression
+                import.importedReference?.getQualifiedElementSelector() as? KtReferenceExpression
             }
             else {
-                (diagnostic.psiElement.getNonStrictParentOfType<JetUserType>() ?: return null).referenceExpression
+                (diagnostic.psiElement.getNonStrictParentOfType<KtUserType>() ?: return null).referenceExpression
             }
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/MigrateBackingFieldSyntaxFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/MigrateBackingFieldSyntaxFix.kt
index 6af6392fa56..eef73033432 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/MigrateBackingFieldSyntaxFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/MigrateBackingFieldSyntaxFix.kt
@@ -20,14 +20,14 @@ import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNameReferenceExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNameReferenceExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 
-public class MigrateBackingFieldSyntaxFix(expr: JetNameReferenceExpression)
-    : KotlinQuickFixAction<JetNameReferenceExpression>(expr), CleanupFix {
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
-        val replacement = JetPsiFactory(project).createExpression("field")
+public class MigrateBackingFieldSyntaxFix(expr: KtNameReferenceExpression)
+    : KotlinQuickFixAction<KtNameReferenceExpression>(expr), CleanupFix {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+        val replacement = KtPsiFactory(project).createExpression("field")
         element.replace(replacement)
     }
 
@@ -36,16 +36,16 @@ public class MigrateBackingFieldSyntaxFix(expr: JetNameReferenceExpression)
 
     companion object : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-            val element = diagnostic.psiElement as? JetNameReferenceExpression ?: return null
+            val element = diagnostic.psiElement as? KtNameReferenceExpression ?: return null
             return MigrateBackingFieldSyntaxFix(element)
         }
     }
 }
 
-public class MigrateBackingFieldUsageFix(expr: JetNameReferenceExpression)
-    : KotlinQuickFixAction<JetNameReferenceExpression>(expr) {
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
-        val replacement = JetPsiFactory(project).createExpression(element.text.substring(1))
+public class MigrateBackingFieldUsageFix(expr: KtNameReferenceExpression)
+    : KotlinQuickFixAction<KtNameReferenceExpression>(expr) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+        val replacement = KtPsiFactory(project).createExpression(element.text.substring(1))
         element.replace(replacement)
     }
 
@@ -54,7 +54,7 @@ public class MigrateBackingFieldUsageFix(expr: JetNameReferenceExpression)
 
     companion object : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-            val element = diagnostic.psiElement as? JetNameReferenceExpression ?: return null
+            val element = diagnostic.psiElement as? KtNameReferenceExpression ?: return null
             if (element.text.length() > 1) {
                 return MigrateBackingFieldUsageFix(element)
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/MissingConstructorKeywordFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/MissingConstructorKeywordFix.kt
index bc0364be88f..c42ea1c8b5a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/MissingConstructorKeywordFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/MissingConstructorKeywordFix.kt
@@ -22,15 +22,15 @@ import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.quickfix.quickfixUtil.createIntentionFactory
 import org.jetbrains.kotlin.idea.quickfix.quickfixUtil.createIntentionForFirstParentOfType
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetPrimaryConstructor
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtPrimaryConstructor
 import org.jetbrains.kotlin.idea.quickfix.quickfixUtil.addConstructorKeyword
 
-public class MissingConstructorKeywordFix(element: JetPrimaryConstructor) : KotlinQuickFixAction<JetPrimaryConstructor>(element), CleanupFix {
+public class MissingConstructorKeywordFix(element: KtPrimaryConstructor) : KotlinQuickFixAction<KtPrimaryConstructor>(element), CleanupFix {
     override fun getFamilyName(): String = getText()
     override fun getText(): String = "Add 'constructor' keyword"
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         element.addConstructorKeyword()
     }
 
@@ -39,7 +39,7 @@ public class MissingConstructorKeywordFix(element: JetPrimaryConstructor) : Kotl
                 diagnostic.createIntentionForFirstParentOfType(::MissingConstructorKeywordFix)
 
         public fun createWholeProjectFixFactory(): JetSingleIntentionActionFactory = createIntentionFactory {
-            JetWholeProjectForEachElementOfTypeFix.createByPredicate<JetPrimaryConstructor>(
+            JetWholeProjectForEachElementOfTypeFix.createByPredicate<KtPrimaryConstructor>(
                     predicate = { it.getModifierList() != null && !it.hasConstructorKeyword() },
                     taskProcessor = { it.addConstructorKeyword() },
                     name = "Add missing 'constructor' keyword in whole project"
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/MoveTypeParameterConstraintFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/MoveTypeParameterConstraintFix.kt
index c7bedfcfa2e..175f692607b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/MoveTypeParameterConstraintFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/MoveTypeParameterConstraintFix.kt
@@ -20,17 +20,17 @@ import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 
-class MoveTypeParameterConstraintFix(element: JetTypeParameter) : KotlinQuickFixAction<JetTypeParameter>(element), CleanupFix {
+class MoveTypeParameterConstraintFix(element: KtTypeParameter) : KotlinQuickFixAction<KtTypeParameter>(element), CleanupFix {
     override fun getText(): String = "Move type parameter constraint to 'where' clause"
     override fun getFamilyName(): String = text
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         val typeParameterName = element.nameAsName ?: return
-        val psiFactory = JetPsiFactory(file)
+        val psiFactory = KtPsiFactory(file)
         val templateClass = psiFactory.buildDeclaration {
             appendFixedText("class A<")
             appendName(typeParameterName)
@@ -38,22 +38,22 @@ class MoveTypeParameterConstraintFix(element: JetTypeParameter) : KotlinQuickFix
             appendName(typeParameterName)
             appendFixedText(":")
             appendTypeReference(element.extendsBound)
-        } as JetTypeParameterListOwner
+        } as KtTypeParameterListOwner
         val templateConstraintList = templateClass.typeConstraintList!!
 
-        val declaration = element.getStrictParentOfType<JetTypeParameterListOwner>() ?: return
+        val declaration = element.getStrictParentOfType<KtTypeParameterListOwner>() ?: return
         val constraintList = declaration.typeConstraintList ?: return
         constraintList.addAfter(psiFactory.createComma(), null)
         constraintList.addAfter(templateConstraintList.constraints[0], null)
 
         element.extendsBound?.delete()
-        val colon = element.node.findChildByType(JetTokens.COLON)
+        val colon = element.node.findChildByType(KtTokens.COLON)
         colon?.psi?.delete()
     }
 
     companion object : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-            val typeParameter = diagnostic.psiElement as? JetTypeParameter ?: return null
+            val typeParameter = diagnostic.psiElement as? KtTypeParameter ?: return null
             return MoveTypeParameterConstraintFix(typeParameter)
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/MoveWhenElseBranchFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/MoveWhenElseBranchFix.java
index 69c92662ca5..b7a616dbe8e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/MoveWhenElseBranchFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/MoveWhenElseBranchFix.java
@@ -29,8 +29,8 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.psi.*;
 
-public class MoveWhenElseBranchFix extends KotlinQuickFixAction<JetWhenExpression> {
-    public MoveWhenElseBranchFix(@NotNull JetWhenExpression element) {
+public class MoveWhenElseBranchFix extends KotlinQuickFixAction<KtWhenExpression> {
+    public MoveWhenElseBranchFix(@NotNull KtWhenExpression element) {
         super(element);
     }
 
@@ -51,14 +51,14 @@ public class MoveWhenElseBranchFix extends KotlinQuickFixAction<JetWhenExpressio
         if (!super.isAvailable(project, editor, file)) {
             return false;
         }
-        return JetPsiUtil.checkWhenExpressionHasSingleElse(getElement());
+        return KtPsiUtil.checkWhenExpressionHasSingleElse(getElement());
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetWhenEntry elseEntry = null;
-        JetWhenEntry lastEntry = null;
-        for (JetWhenEntry entry : getElement().getEntries()) {
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        KtWhenEntry elseEntry = null;
+        KtWhenEntry lastEntry = null;
+        for (KtWhenEntry entry : getElement().getEntries()) {
             if (entry.isElse()) {
                 elseEntry = entry;
             }
@@ -68,9 +68,9 @@ public class MoveWhenElseBranchFix extends KotlinQuickFixAction<JetWhenExpressio
         int cursorOffset = editor.getCaretModel().getOffset() - elseEntry.getTextOffset();
 
         PsiElement insertedBranch = getElement().addAfter(elseEntry, lastEntry);
-        getElement().addAfter(JetPsiFactoryKt.JetPsiFactory(file).createNewLine(), lastEntry);
+        getElement().addAfter(KtPsiFactoryKt.KtPsiFactory(file).createNewLine(), lastEntry);
         getElement().deleteChildRange(elseEntry, elseEntry);
-        JetWhenEntry insertedWhenEntry = (JetWhenEntry) CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(insertedBranch);
+        KtWhenEntry insertedWhenEntry = (KtWhenEntry) CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(insertedBranch);
 
         editor.getCaretModel().moveToOffset(insertedWhenEntry.getTextOffset() + cursorOffset);
     }
@@ -81,7 +81,7 @@ public class MoveWhenElseBranchFix extends KotlinQuickFixAction<JetWhenExpressio
             @Override
             public KotlinQuickFixAction createAction(Diagnostic diagnostic) {
                 PsiElement element = diagnostic.getPsiElement();
-                JetWhenExpression whenExpression = PsiTreeUtil.getParentOfType(element, JetWhenExpression.class, false);
+                KtWhenExpression whenExpression = PsiTreeUtil.getParentOfType(element, KtWhenExpression.class, false);
                 if (whenExpression == null) return null;
                 return new MoveWhenElseBranchFix(whenExpression);
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixFactoryForTypeMismatchError.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixFactoryForTypeMismatchError.java
index 0592492127b..f61e411cbfa 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixFactoryForTypeMismatchError.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixFactoryForTypeMismatchError.java
@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilsKt;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.typeUtil.TypeUtilsKt;
 
 import java.util.Collections;
@@ -54,31 +54,31 @@ public class QuickFixFactoryForTypeMismatchError extends JetIntentionActionsFact
     protected List<IntentionAction> doCreateActions(@NotNull Diagnostic diagnostic) {
         List<IntentionAction> actions = new LinkedList<IntentionAction>();
 
-        BindingContext context = ResolutionUtils.analyzeFully((JetFile) diagnostic.getPsiFile());
+        BindingContext context = ResolutionUtils.analyzeFully((KtFile) diagnostic.getPsiFile());
 
         PsiElement diagnosticElement = diagnostic.getPsiElement();
-        if (!(diagnosticElement instanceof JetExpression)) {
+        if (!(diagnosticElement instanceof KtExpression)) {
             LOG.error("Unexpected element: " + diagnosticElement.getText());
             return Collections.emptyList();
         }
 
-        JetExpression expression = (JetExpression) diagnosticElement;
+        KtExpression expression = (KtExpression) diagnosticElement;
 
-        JetType expectedType;
-        JetType expressionType;
+        KtType expectedType;
+        KtType expressionType;
         if (diagnostic.getFactory() == Errors.TYPE_MISMATCH) {
-            DiagnosticWithParameters2<JetExpression, JetType, JetType> diagnosticWithParameters = Errors.TYPE_MISMATCH.cast(diagnostic);
+            DiagnosticWithParameters2<KtExpression, KtType, KtType> diagnosticWithParameters = Errors.TYPE_MISMATCH.cast(diagnostic);
             expectedType = diagnosticWithParameters.getA();
             expressionType = diagnosticWithParameters.getB();
         }
         else if (diagnostic.getFactory() == Errors.NULL_FOR_NONNULL_TYPE) {
-            DiagnosticWithParameters1<JetConstantExpression, JetType> diagnosticWithParameters =
+            DiagnosticWithParameters1<KtConstantExpression, KtType> diagnosticWithParameters =
                     Errors.NULL_FOR_NONNULL_TYPE.cast(diagnostic);
             expectedType = diagnosticWithParameters.getA();
             expressionType = TypeUtilsKt.makeNullable(expectedType);
         }
         else if (diagnostic.getFactory() == Errors.CONSTANT_EXPECTED_TYPE_MISMATCH) {
-            DiagnosticWithParameters2<JetConstantExpression, String, JetType> diagnosticWithParameters =
+            DiagnosticWithParameters2<KtConstantExpression, String, KtType> diagnosticWithParameters =
                     Errors.CONSTANT_EXPECTED_TYPE_MISMATCH.cast(diagnostic);
             expectedType = diagnosticWithParameters.getB();
             expressionType = context.getType(expression);
@@ -93,19 +93,19 @@ public class QuickFixFactoryForTypeMismatchError extends JetIntentionActionsFact
         }
 
         // We don't want to cast a cast or type-asserted expression:
-        if (!(expression instanceof JetBinaryExpressionWithTypeRHS) && !(expression.getParent() instanceof  JetBinaryExpressionWithTypeRHS)) {
+        if (!(expression instanceof KtBinaryExpressionWithTypeRHS) && !(expression.getParent() instanceof KtBinaryExpressionWithTypeRHS)) {
             actions.add(new CastExpressionFix(expression, expectedType));
         }
 
         // Property initializer type mismatch property type:
-        JetProperty property = PsiTreeUtil.getParentOfType(expression, JetProperty.class);
+        KtProperty property = PsiTreeUtil.getParentOfType(expression, KtProperty.class);
         if (property != null) {
-            JetPropertyAccessor getter = property.getGetter();
-            JetExpression initializer = property.getInitializer();
+            KtPropertyAccessor getter = property.getGetter();
+            KtExpression initializer = property.getInitializer();
             if (QuickFixUtil.canEvaluateTo(initializer, expression) ||
                 (getter != null && QuickFixUtil.canFunctionOrGetterReturnExpression(property.getGetter(), expression))) {
                 LexicalScope scope = UtilsKt.getResolutionScope(property, context, ResolutionUtils.getResolutionFacade(property));
-                JetType typeToInsert = TypeUtils.approximateWithResolvableType(expressionType, scope, false);
+                KtType typeToInsert = TypeUtils.approximateWithResolvableType(expressionType, scope, false);
                 actions.add(new ChangeVariableTypeFix(property, typeToInsert));
             }
         }
@@ -114,20 +114,20 @@ public class QuickFixFactoryForTypeMismatchError extends JetIntentionActionsFact
 
         // Mismatch in returned expression:
 
-        JetCallableDeclaration function = expressionParent instanceof JetReturnExpression
-                               ? BindingContextUtilsKt.getTargetFunction((JetReturnExpression) expressionParent, context)
-                               : PsiTreeUtil.getParentOfType(expression, JetFunction.class, true);
-        if (function instanceof JetFunction && QuickFixUtil.canFunctionOrGetterReturnExpression(function, expression)) {
+        KtCallableDeclaration function = expressionParent instanceof KtReturnExpression
+                               ? BindingContextUtilsKt.getTargetFunction((KtReturnExpression) expressionParent, context)
+                               : PsiTreeUtil.getParentOfType(expression, KtFunction.class, true);
+        if (function instanceof KtFunction && QuickFixUtil.canFunctionOrGetterReturnExpression(function, expression)) {
             LexicalScope scope = UtilsKt.getResolutionScope(function, context, ResolutionUtils.getResolutionFacade(function));
-            JetType typeToInsert = TypeUtils.approximateWithResolvableType(expressionType, scope, false);
-            actions.add(new ChangeFunctionReturnTypeFix((JetFunction) function, typeToInsert));
+            KtType typeToInsert = TypeUtils.approximateWithResolvableType(expressionType, scope, false);
+            actions.add(new ChangeFunctionReturnTypeFix((KtFunction) function, typeToInsert));
         }
 
         // Fixing overloaded operators:
-        if (expression instanceof JetOperationExpression) {
+        if (expression instanceof KtOperationExpression) {
             ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(expression, context);
             if (resolvedCall != null) {
-                JetFunction declaration = getFunctionDeclaration(resolvedCall);
+                KtFunction declaration = getFunctionDeclaration(resolvedCall);
                 if (declaration != null) {
                     actions.add(new ChangeFunctionReturnTypeFix(declaration, expectedType));
                 }
@@ -135,10 +135,10 @@ public class QuickFixFactoryForTypeMismatchError extends JetIntentionActionsFact
         }
 
         // Change function return type when TYPE_MISMATCH is reported on call expression:
-        if (expression instanceof JetCallExpression) {
+        if (expression instanceof KtCallExpression) {
             ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(expression, context);
             if (resolvedCall != null) {
-                JetFunction declaration = getFunctionDeclaration(resolvedCall);
+                KtFunction declaration = getFunctionDeclaration(resolvedCall);
                 if (declaration != null) {
                     actions.add(new ChangeFunctionReturnTypeFix(declaration, expectedType));
                 }
@@ -149,19 +149,19 @@ public class QuickFixFactoryForTypeMismatchError extends JetIntentionActionsFact
         if (resolvedCall != null) {
             // to fix 'type mismatch' on 'if' branches
             // todo: the same with 'when'
-            JetExpression parentIf = QuickFixUtil.getParentIfForBranch(expression);
-            JetExpression argumentExpression = (parentIf != null) ? parentIf : expression;
+            KtExpression parentIf = QuickFixUtil.getParentIfForBranch(expression);
+            KtExpression argumentExpression = (parentIf != null) ? parentIf : expression;
             ValueArgument valueArgument = CallUtilKt.getValueArgumentForExpression(resolvedCall.getCall(), argumentExpression);
             if (valueArgument != null) {
-                JetParameter correspondingParameter = QuickFixUtil.getParameterDeclarationForValueArgument(resolvedCall, valueArgument);
-                JetType valueArgumentType = diagnostic.getFactory() == Errors.NULL_FOR_NONNULL_TYPE
+                KtParameter correspondingParameter = QuickFixUtil.getParameterDeclarationForValueArgument(resolvedCall, valueArgument);
+                KtType valueArgumentType = diagnostic.getFactory() == Errors.NULL_FOR_NONNULL_TYPE
                                             ? expressionType
                                             : context.getType(valueArgument.getArgumentExpression());
                 if (correspondingParameter != null && valueArgumentType != null) {
-                    JetCallableDeclaration callable = PsiTreeUtil.getParentOfType(correspondingParameter, JetCallableDeclaration.class, true);
+                    KtCallableDeclaration callable = PsiTreeUtil.getParentOfType(correspondingParameter, KtCallableDeclaration.class, true);
                     LexicalScope scope = callable != null ? UtilsKt.getResolutionScope(callable, context, ResolutionUtils
                             .getResolutionFacade(callable)) : null;
-                    JetType typeToInsert = TypeUtils.approximateWithResolvableType(valueArgumentType, scope, true);
+                    KtType typeToInsert = TypeUtils.approximateWithResolvableType(valueArgumentType, scope, true);
                     actions.add(new ChangeParameterTypeFix(correspondingParameter, typeToInsert));
                 }
             }
@@ -170,10 +170,10 @@ public class QuickFixFactoryForTypeMismatchError extends JetIntentionActionsFact
     }
 
     @Nullable
-    private static JetFunction getFunctionDeclaration(@NotNull ResolvedCall<?> resolvedCall) {
+    private static KtFunction getFunctionDeclaration(@NotNull ResolvedCall<?> resolvedCall) {
         PsiElement result = QuickFixUtil.safeGetDeclaration(resolvedCall.getResultingDescriptor());
-        if (result instanceof JetFunction) {
-            return (JetFunction) result;
+        if (result instanceof KtFunction) {
+            return (KtFunction) result;
         }
         return null;
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt
index e516b20af48..943a3c11aa0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt
@@ -34,9 +34,9 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createVariable.CreateP
 import org.jetbrains.kotlin.idea.quickfix.migration.MigrateTypeParameterListFix
 import org.jetbrains.kotlin.idea.quickfix.replaceWith.DeprecatedSymbolUsageFix
 import org.jetbrains.kotlin.idea.quickfix.replaceWith.DeprecatedSymbolUsageInWholeProjectFix
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.lexer.JetTokens.*
-import org.jetbrains.kotlin.psi.JetClass
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.lexer.KtTokens.*
+import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.NO_REFLECTION_IN_CLASS_PATH
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.POSITIONED_VALUE_ARGUMENT_FOR_JAVA_ANNOTATION
@@ -68,7 +68,7 @@ public class QuickFixRegistrar : QuickFixContributor {
         ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED.registerFactory(addAbstractModifierFactory)
 
         val removeFinalModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(FINAL_KEYWORD)
-        val addAbstractToClassFactory = AddModifierFix.createFactory(ABSTRACT_KEYWORD, javaClass<JetClass>())
+        val addAbstractToClassFactory = AddModifierFix.createFactory(ABSTRACT_KEYWORD, javaClass<KtClass>())
         ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS.registerFactory(removeAbstractModifierFactory, addAbstractToClassFactory)
 
         ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.registerFactory(removeAbstractModifierFactory, addAbstractToClassFactory)
@@ -110,7 +110,7 @@ public class QuickFixRegistrar : QuickFixContributor {
         VARIANCE_ON_TYPE_PARAMETER_OF_FUNCTION_OR_PROPERTY.registerFactory(RemoveModifierFix.createRemoveVarianceFactory())
 
         val removeOpenModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OPEN_KEYWORD)
-        NON_FINAL_MEMBER_IN_FINAL_CLASS.registerFactory(AddModifierFix.createFactory(OPEN_KEYWORD, javaClass<JetClass>()),
+        NON_FINAL_MEMBER_IN_FINAL_CLASS.registerFactory(AddModifierFix.createFactory(OPEN_KEYWORD, javaClass<KtClass>()),
                                                    removeOpenModifierFactory)
 
         val removeModifierFactory = RemoveModifierFix.createRemoveModifierFactory()
@@ -190,7 +190,7 @@ public class QuickFixRegistrar : QuickFixContributor {
         UNCHECKED_CAST.registerFactory(changeToStarProjectionFactory)
         CANNOT_CHECK_FOR_ERASED.registerFactory(changeToStarProjectionFactory)
 
-        INACCESSIBLE_OUTER_CLASS_EXPRESSION.registerFactory(AddModifierFix.createFactory(INNER_KEYWORD, javaClass<JetClass>()))
+        INACCESSIBLE_OUTER_CLASS_EXPRESSION.registerFactory(AddModifierFix.createFactory(INNER_KEYWORD, javaClass<KtClass>()))
 
         val addOpenModifierToClassDeclarationFix = AddOpenModifierToClassDeclarationFix.createFactory()
         FINAL_SUPERTYPE.registerFactory(addOpenModifierToClassDeclarationFix)
@@ -327,8 +327,8 @@ public class QuickFixRegistrar : QuickFixContributor {
         BACKING_FIELD_USAGE_FORBIDDEN.registerFactory(MigrateBackingFieldUsageFix)
         BACKING_FIELD_USAGE_FORBIDDEN.registerFactory(IntroduceBackingPropertyFix)
 
-        OPERATOR_MODIFIER_REQUIRED.registerFactory(AddModifierFixFactory(JetTokens.OPERATOR_KEYWORD))
-        INFIX_MODIFIER_REQUIRED.registerFactory(AddModifierFixFactory(JetTokens.INFIX_KEYWORD))
+        OPERATOR_MODIFIER_REQUIRED.registerFactory(AddModifierFixFactory(KtTokens.OPERATOR_KEYWORD))
+        INFIX_MODIFIER_REQUIRED.registerFactory(AddModifierFixFactory(KtTokens.INFIX_KEYWORD))
 
         UNDERSCORE_IS_RESERVED.registerFactory(RenameUnderscoreFix)
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveFunctionBodyFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveFunctionBodyFix.java
index 815d78d2ba2..aff13eb5e1c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveFunctionBodyFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveFunctionBodyFix.java
@@ -28,14 +28,14 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
-import org.jetbrains.kotlin.lexer.JetTokens;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetFunction;
+import org.jetbrains.kotlin.lexer.KtTokens;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtFunction;
 
-public class RemoveFunctionBodyFix extends KotlinQuickFixAction<JetFunction> {
+public class RemoveFunctionBodyFix extends KotlinQuickFixAction<KtFunction> {
 
-    public RemoveFunctionBodyFix(@NotNull JetFunction element) {
+    public RemoveFunctionBodyFix(@NotNull KtFunction element) {
         super(element);
     }
 
@@ -57,11 +57,11 @@ public class RemoveFunctionBodyFix extends KotlinQuickFixAction<JetFunction> {
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetFunction function = (JetFunction) getElement().copy();
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        KtFunction function = (KtFunction) getElement().copy();
         assert function instanceof ASTDelegatePsiElement;
         ASTDelegatePsiElement functionElementWithAst = (ASTDelegatePsiElement) function;
-        JetExpression bodyExpression = function.getBodyExpression();
+        KtExpression bodyExpression = function.getBodyExpression();
         assert bodyExpression != null;
         if (function.hasBlockBody()) {
             PsiElement prevElement = bodyExpression.getPrevSibling();
@@ -80,7 +80,7 @@ public class RemoveFunctionBodyFix extends KotlinQuickFixAction<JetFunction> {
     }
 
     private static boolean removePossiblyEquationSign(@NotNull ASTDelegatePsiElement element, @Nullable PsiElement possiblyEq) {
-        if (possiblyEq instanceof LeafPsiElement && ((LeafPsiElement)possiblyEq).getElementType() == JetTokens.EQ) {
+        if (possiblyEq instanceof LeafPsiElement && ((LeafPsiElement)possiblyEq).getElementType() == KtTokens.EQ) {
             QuickFixUtil.removePossiblyWhiteSpace(element, possiblyEq.getNextSibling());
             element.deleteChildInternal(possiblyEq.getNode());
             return true;
@@ -91,8 +91,8 @@ public class RemoveFunctionBodyFix extends KotlinQuickFixAction<JetFunction> {
     public static JetSingleIntentionActionFactory createFactory() {
         return new JetSingleIntentionActionFactory() {
             @Override
-            public KotlinQuickFixAction<JetFunction> createAction(Diagnostic diagnostic) {
-                JetFunction function = QuickFixUtil.getParentElementOfType(diagnostic, JetFunction.class);
+            public KotlinQuickFixAction<KtFunction> createAction(Diagnostic diagnostic) {
+                KtFunction function = QuickFixUtil.getParentElementOfType(diagnostic, KtFunction.class);
                 if (function == null) return null;
                 return new RemoveFunctionBodyFix(function);
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveModifierFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveModifierFix.kt
index a961bbb91e9..50b94375e94 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveModifierFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveModifierFix.kt
@@ -21,27 +21,27 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetModifierListOwner
-import org.jetbrains.kotlin.psi.JetTypeParameter
-import org.jetbrains.kotlin.psi.JetTypeProjection
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtModifierListOwner
+import org.jetbrains.kotlin.psi.KtTypeParameter
+import org.jetbrains.kotlin.psi.KtTypeProjection
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.types.Variance
 
 public class RemoveModifierFix(
-        element: JetModifierListOwner,
-        private val modifier: JetModifierKeywordToken,
+        element: KtModifierListOwner,
+        private val modifier: KtModifierKeywordToken,
         private val isRedundant: Boolean
-) : KotlinQuickFixAction<JetModifierListOwner>(element) {
+) : KotlinQuickFixAction<KtModifierListOwner>(element) {
 
     private val text = run {
         val modifierText = modifier.value
         when {
             isRedundant ->
                 "Remove redundant '$modifierText' modifier"
-            modifier === JetTokens.ABSTRACT_KEYWORD || modifier === JetTokens.OPEN_KEYWORD ->
+            modifier === KtTokens.ABSTRACT_KEYWORD || modifier === KtTokens.OPEN_KEYWORD ->
                 "Make ${AddModifierFix.getElementName(element)} not $modifierText"
             else ->
                 "Remove '$modifierText' modifier"
@@ -55,22 +55,22 @@ public class RemoveModifierFix(
     override fun isAvailable(project: Project, editor: Editor?, file: PsiFile)
             = super.isAvailable(project, editor, file) && element.hasModifier(modifier)
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         invoke()
     }
 
     public fun invoke() {
         //TODO: without this copy&replace we get bad formatting on removing last modifier
-        val newElement = element.copy() as JetModifierListOwner
+        val newElement = element.copy() as KtModifierListOwner
         newElement.removeModifier(modifier)
         element.replace(newElement)
     }
 
     companion object {
-        public fun createRemoveModifierFromListOwnerFactory(modifier: JetModifierKeywordToken, isRedundant: Boolean = false): JetSingleIntentionActionFactory {
+        public fun createRemoveModifierFromListOwnerFactory(modifier: KtModifierKeywordToken, isRedundant: Boolean = false): JetSingleIntentionActionFactory {
             return object : JetSingleIntentionActionFactory() {
-                override fun createAction(diagnostic: Diagnostic): KotlinQuickFixAction<JetModifierListOwner>? {
-                    val modifierListOwner = QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetModifierListOwner>()) ?: return null
+                override fun createAction(diagnostic: Diagnostic): KotlinQuickFixAction<KtModifierListOwner>? {
+                    val modifierListOwner = QuickFixUtil.getParentElementOfType(diagnostic, javaClass<KtModifierListOwner>()) ?: return null
                     return RemoveModifierFix(modifierListOwner, modifier, isRedundant)
                 }
             }
@@ -78,10 +78,10 @@ public class RemoveModifierFix(
 
         public fun createRemoveModifierFactory(isRedundant: Boolean = false): JetSingleIntentionActionFactory {
             return object : JetSingleIntentionActionFactory() {
-                override fun createAction(diagnostic: Diagnostic): KotlinQuickFixAction<JetModifierListOwner>? {
+                override fun createAction(diagnostic: Diagnostic): KotlinQuickFixAction<KtModifierListOwner>? {
                     val psiElement = diagnostic.psiElement
-                    val elementType = psiElement.node.elementType as? JetModifierKeywordToken ?: return null
-                    val modifierListOwner = psiElement.getStrictParentOfType<JetModifierListOwner>() ?: return null
+                    val elementType = psiElement.node.elementType as? KtModifierKeywordToken ?: return null
+                    val modifierListOwner = psiElement.getStrictParentOfType<KtModifierListOwner>() ?: return null
                     return RemoveModifierFix(modifierListOwner, elementType, isRedundant)
                 }
             }
@@ -89,9 +89,9 @@ public class RemoveModifierFix(
 
         public fun createRemoveProjectionFactory(isRedundant: Boolean): JetSingleIntentionActionFactory {
             return object : JetSingleIntentionActionFactory() {
-                override fun createAction(diagnostic: Diagnostic): KotlinQuickFixAction<JetModifierListOwner>? {
-                    val projection = diagnostic.psiElement as JetTypeProjection
-                    val elementType = projection.projectionToken?.node?.elementType as? JetModifierKeywordToken ?: return null
+                override fun createAction(diagnostic: Diagnostic): KotlinQuickFixAction<KtModifierListOwner>? {
+                    val projection = diagnostic.psiElement as KtTypeProjection
+                    val elementType = projection.projectionToken?.node?.elementType as? KtModifierKeywordToken ?: return null
                     return RemoveModifierFix(projection, elementType, isRedundant)
                 }
             }
@@ -99,11 +99,11 @@ public class RemoveModifierFix(
 
         public fun createRemoveVarianceFactory(): JetSingleIntentionActionFactory {
             return object : JetSingleIntentionActionFactory() {
-                override fun createAction(diagnostic: Diagnostic): KotlinQuickFixAction<JetModifierListOwner>? {
-                    val psiElement = diagnostic.psiElement as JetTypeParameter
+                override fun createAction(diagnostic: Diagnostic): KotlinQuickFixAction<KtModifierListOwner>? {
+                    val psiElement = diagnostic.psiElement as KtTypeParameter
                     val modifier = when (psiElement.variance) {
-                        Variance.IN_VARIANCE -> JetTokens.IN_KEYWORD
-                        Variance.OUT_VARIANCE -> JetTokens.OUT_KEYWORD
+                        Variance.IN_VARIANCE -> KtTokens.IN_KEYWORD
+                        Variance.OUT_VARIANCE -> KtTokens.OUT_KEYWORD
                         else -> return null
                     }
                     return RemoveModifierFix(psiElement, modifier, isRedundant = false)
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveNameFromFunctionExpressionFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveNameFromFunctionExpressionFix.kt
index 04ea575996b..bb03995d342 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveNameFromFunctionExpressionFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveNameFromFunctionExpressionFix.kt
@@ -25,22 +25,22 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.forEachDescendantOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 
-public class RemoveNameFromFunctionExpressionFix(element: JetNamedFunction) : KotlinQuickFixAction<JetNamedFunction>(element), CleanupFix {
+public class RemoveNameFromFunctionExpressionFix(element: KtNamedFunction) : KotlinQuickFixAction<KtNamedFunction>(element), CleanupFix {
     override fun getText(): String = "Remove identifier from function expression"
     override fun getFamilyName(): String = getText()
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) = removeNameFromFunction(element)
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) = removeNameFromFunction(element)
 
     companion object : JetSingleIntentionActionFactory() {
 
         override fun createAction(diagnostic: Diagnostic) =
                 diagnostic.createIntentionForFirstParentOfType(::RemoveNameFromFunctionExpressionFix)
 
-        private fun removeNameFromFunction(function: JetNamedFunction) {
+        private fun removeNameFromFunction(function: KtNamedFunction) {
             var wereAutoLabelUsages = false
             val name = function.getNameAsName() ?: return
 
-            function.forEachDescendantOfType<JetReturnExpression> {
+            function.forEachDescendantOfType<KtReturnExpression> {
                 if (!wereAutoLabelUsages && it.getLabelNameAsName() == name) {
                     wereAutoLabelUsages = it.analyze().get(BindingContext.LABEL_TARGET, it.getTargetLabel()) == function
                 }
@@ -49,7 +49,7 @@ public class RemoveNameFromFunctionExpressionFix(element: JetNamedFunction) : Ko
             function.getNameIdentifier()?.delete()
 
             if (wereAutoLabelUsages) {
-                val psiFactory = JetPsiFactory(function)
+                val psiFactory = KtPsiFactory(function)
                 val newFunction = psiFactory.createExpressionByPattern("$0@ $1", name, function)
                 function.replace(newFunction)
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveNullableFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveNullableFix.java
index cd0e5fa5b1b..20d9d935ead 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveNullableFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveNullableFix.java
@@ -23,17 +23,17 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetNullableType;
-import org.jetbrains.kotlin.psi.JetTypeElement;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtNullableType;
+import org.jetbrains.kotlin.psi.KtTypeElement;
 
-public class RemoveNullableFix extends KotlinQuickFixAction<JetNullableType> {
+public class RemoveNullableFix extends KotlinQuickFixAction<KtNullableType> {
     public enum NullableKind {
         REDUNDANT, SUPERTYPE, USELESS
     }
     private final NullableKind typeOfError;
 
-    public RemoveNullableFix(@NotNull JetNullableType element, @NotNull NullableKind type) {
+    public RemoveNullableFix(@NotNull KtNullableType element, @NotNull NullableKind type) {
         super(element);
         typeOfError = type;
     }
@@ -58,8 +58,8 @@ public class RemoveNullableFix extends KotlinQuickFixAction<JetNullableType> {
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetTypeElement type = super.getElement().getInnerType();
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        KtTypeElement type = super.getElement().getInnerType();
         assert type != null : "No inner type " + getElement().getText() + ", should have been rejected in createFactory()";
         super.getElement().replace(type);
     }
@@ -67,8 +67,8 @@ public class RemoveNullableFix extends KotlinQuickFixAction<JetNullableType> {
     public static JetSingleIntentionActionFactory createFactory(final NullableKind typeOfError) {
         return new JetSingleIntentionActionFactory() {
             @Override
-            public KotlinQuickFixAction<JetNullableType> createAction(Diagnostic diagnostic) {
-                JetNullableType nullType = QuickFixUtil.getParentElementOfType(diagnostic, JetNullableType.class);
+            public KotlinQuickFixAction<KtNullableType> createAction(Diagnostic diagnostic) {
+                KtNullableType nullType = QuickFixUtil.getParentElementOfType(diagnostic, KtNullableType.class);
                 if (nullType == null || nullType.getInnerType() == null) return null;
                 return new RemoveNullableFix(nullType, typeOfError);
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemovePartsFromPropertyFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemovePartsFromPropertyFix.java
index 663276ec7e0..8fed1c34696 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemovePartsFromPropertyFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemovePartsFromPropertyFix.java
@@ -28,21 +28,21 @@ import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
 import org.jetbrains.kotlin.idea.intentions.SpecifyTypeExplicitlyIntention;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
-public class RemovePartsFromPropertyFix extends KotlinQuickFixAction<JetProperty> {
+public class RemovePartsFromPropertyFix extends KotlinQuickFixAction<KtProperty> {
     private final boolean removeInitializer;
     private final boolean removeGetter;
     private final boolean removeSetter;
 
-    private RemovePartsFromPropertyFix(@NotNull JetProperty element, boolean removeInitializer, boolean removeGetter, boolean removeSetter) {
+    private RemovePartsFromPropertyFix(@NotNull KtProperty element, boolean removeInitializer, boolean removeGetter, boolean removeSetter) {
         super(element);
         this.removeInitializer = removeInitializer;
         this.removeGetter = removeGetter;
         this.removeSetter = removeSetter;
     }
 
-    private RemovePartsFromPropertyFix(@NotNull JetProperty element) {
+    private RemovePartsFromPropertyFix(@NotNull KtProperty element) {
         this(element, element.hasInitializer(),
              element.getGetter() != null && element.getGetter().getBodyExpression() != null,
              element.getSetter() != null && element.getSetter().getBodyExpression() != null);
@@ -85,24 +85,24 @@ public class RemovePartsFromPropertyFix extends KotlinQuickFixAction<JetProperty
 
     @Override
     public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
-        JetType type = QuickFixUtil.getDeclarationReturnType(getElement());
+        KtType type = QuickFixUtil.getDeclarationReturnType(getElement());
         return super.isAvailable(project, editor, file) && type != null && !type.isError();
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetType type = QuickFixUtil.getDeclarationReturnType(getElement());
-        JetProperty newElement = (JetProperty) getElement().copy();
-        JetPropertyAccessor getter = newElement.getGetter();
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        KtType type = QuickFixUtil.getDeclarationReturnType(getElement());
+        KtProperty newElement = (KtProperty) getElement().copy();
+        KtPropertyAccessor getter = newElement.getGetter();
         if (removeGetter && getter != null) {
             newElement.deleteChildInternal(getter.getNode());
         }
-        JetPropertyAccessor setter = newElement.getSetter();
+        KtPropertyAccessor setter = newElement.getSetter();
         if (removeSetter && setter != null) {
             newElement.deleteChildInternal(setter.getNode());
         }
-        JetExpression initializer = newElement.getInitializer();
-        JetType typeToAdd = null;
+        KtExpression initializer = newElement.getInitializer();
+        KtType typeToAdd = null;
         if (removeInitializer && initializer != null) {
             PsiElement nameIdentifier = newElement.getNameIdentifier();
             assert nameIdentifier != null;
@@ -114,7 +114,7 @@ public class RemovePartsFromPropertyFix extends KotlinQuickFixAction<JetProperty
                 typeToAdd = type;
             }
         }
-        newElement = (JetProperty) getElement().replace(newElement);
+        newElement = (KtProperty) getElement().replace(newElement);
         if (typeToAdd != null) {
             SpecifyTypeExplicitlyIntention.Companion.addTypeAnnotation(editor, newElement, typeToAdd);
         }
@@ -123,10 +123,10 @@ public class RemovePartsFromPropertyFix extends KotlinQuickFixAction<JetProperty
     public static JetSingleIntentionActionFactory createFactory() {
         return new JetSingleIntentionActionFactory() {
             @Override
-            public KotlinQuickFixAction<JetProperty> createAction(Diagnostic diagnostic) {
+            public KotlinQuickFixAction<KtProperty> createAction(Diagnostic diagnostic) {
                 PsiElement element = diagnostic.getPsiElement();
-                assert element instanceof JetElement;
-                JetProperty property = PsiTreeUtil.getParentOfType(element, JetProperty.class);
+                assert element instanceof KtElement;
+                KtProperty property = PsiTreeUtil.getParentOfType(element, KtProperty.class);
                 if (property == null) return null;
                 return new RemovePartsFromPropertyFix(property);
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemovePsiElementSimpleFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemovePsiElementSimpleFix.java
index cdba5899db7..fecddce264e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemovePsiElementSimpleFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemovePsiElementSimpleFix.java
@@ -25,7 +25,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 
 public class RemovePsiElementSimpleFix extends KotlinQuickFixAction<PsiElement> {
@@ -53,7 +53,7 @@ public class RemovePsiElementSimpleFix extends KotlinQuickFixAction<PsiElement>
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
         element.delete();
     }
 
@@ -61,10 +61,10 @@ public class RemovePsiElementSimpleFix extends KotlinQuickFixAction<PsiElement>
         return new JetSingleIntentionActionFactory() {
             @Override
             public KotlinQuickFixAction<PsiElement> createAction(Diagnostic diagnostic) {
-                JetImportDirective directive = QuickFixUtil.getParentElementOfType(diagnostic, JetImportDirective.class);
+                KtImportDirective directive = QuickFixUtil.getParentElementOfType(diagnostic, KtImportDirective.class);
                 if (directive == null) return null;
                 else {
-                    JetExpression exp = directive.getImportedReference();
+                    KtExpression exp = directive.getImportedReference();
                     if (exp != null) {
                         return new RemovePsiElementSimpleFix(directive,
                                                              JetBundle.message("remove.conflicting.import", exp.getText()));
@@ -81,7 +81,7 @@ public class RemovePsiElementSimpleFix extends KotlinQuickFixAction<PsiElement>
             @Override
             public KotlinQuickFixAction<PsiElement> createAction(Diagnostic diagnostic) {
                 PsiElement element = diagnostic.getPsiElement();
-                if ((element instanceof LeafPsiElement) && ((LeafPsiElement) element).getElementType() == JetTokens.MUL) {
+                if ((element instanceof LeafPsiElement) && ((LeafPsiElement) element).getElementType() == KtTokens.MUL) {
                     return new RemovePsiElementSimpleFix(element, JetBundle.message("remove.spread.sign"));
                 }
                 else return null;
@@ -93,7 +93,7 @@ public class RemovePsiElementSimpleFix extends KotlinQuickFixAction<PsiElement>
         return new JetSingleIntentionActionFactory() {
             @Override
             public KotlinQuickFixAction<PsiElement> createAction(Diagnostic diagnostic) {
-                JetTypeArgumentList element = QuickFixUtil.getParentElementOfType(diagnostic, JetTypeArgumentList.class);
+                KtTypeArgumentList element = QuickFixUtil.getParentElementOfType(diagnostic, KtTypeArgumentList.class);
                 if (element == null) return null;
                 return new RemovePsiElementSimpleFix(element,
                                                      JetBundle.message("remove.type.arguments"));
@@ -105,13 +105,13 @@ public class RemovePsiElementSimpleFix extends KotlinQuickFixAction<PsiElement>
         return new JetSingleIntentionActionFactory() {
             @Override
             public KotlinQuickFixAction<PsiElement> createAction(Diagnostic diagnostic) {
-                final JetProperty expression = QuickFixUtil.getParentElementOfType(diagnostic, JetProperty.class);
+                final KtProperty expression = QuickFixUtil.getParentElementOfType(diagnostic, KtProperty.class);
                 if (expression == null) return null;
                 return new RemovePsiElementSimpleFix(expression,
                                                      JetBundle.message("remove.variable.action", (expression.getName()))) {
                     @Override
-                    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-                        JetExpression initializer = expression.getInitializer();
+                    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+                        KtExpression initializer = expression.getInitializer();
                         if (initializer != null) {
                             expression.replace(initializer);
                         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveRightPartOfBinaryExpressionFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveRightPartOfBinaryExpressionFix.java
index 3ad1a4a3dc8..5d0b7ce2cf0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveRightPartOfBinaryExpressionFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveRightPartOfBinaryExpressionFix.java
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
 import org.jetbrains.kotlin.psi.*;
 
-public class RemoveRightPartOfBinaryExpressionFix<T extends JetExpression> extends KotlinQuickFixAction<T> implements CleanupFix {
+public class RemoveRightPartOfBinaryExpressionFix<T extends KtExpression> extends KotlinQuickFixAction<T> implements CleanupFix {
     private final String message;
     
     public RemoveRightPartOfBinaryExpressionFix(@NotNull T element, String message) {
@@ -46,25 +46,25 @@ public class RemoveRightPartOfBinaryExpressionFix<T extends JetExpression> exten
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
         invoke();
     }
 
     @NotNull
-    public JetExpression invoke() throws IncorrectOperationException {
-        JetExpression newExpression = null;
+    public KtExpression invoke() throws IncorrectOperationException {
+        KtExpression newExpression = null;
 
-        if (getElement() instanceof JetBinaryExpression) {
+        if (getElement() instanceof KtBinaryExpression) {
             //noinspection ConstantConditions
-            newExpression = (JetExpression) getElement().replace(((JetBinaryExpression) getElement().copy()).getLeft());
+            newExpression = (KtExpression) getElement().replace(((KtBinaryExpression) getElement().copy()).getLeft());
         }
-        else if (getElement() instanceof JetBinaryExpressionWithTypeRHS) {
-            newExpression = (JetExpression) getElement().replace(((JetBinaryExpressionWithTypeRHS) getElement().copy()).getLeft());
+        else if (getElement() instanceof KtBinaryExpressionWithTypeRHS) {
+            newExpression = (KtExpression) getElement().replace(((KtBinaryExpressionWithTypeRHS) getElement().copy()).getLeft());
         }
 
         PsiElement parent = newExpression != null ? newExpression.getParent() : null;
-        if (parent instanceof JetParenthesizedExpression && JetPsiUtil.areParenthesesUseless((JetParenthesizedExpression) parent)) {
-            newExpression = (JetExpression) parent.replace(newExpression);
+        if (parent instanceof KtParenthesizedExpression && KtPsiUtil.areParenthesesUseless((KtParenthesizedExpression) parent)) {
+            newExpression = (KtExpression) parent.replace(newExpression);
         }
 
         return newExpression;
@@ -73,10 +73,10 @@ public class RemoveRightPartOfBinaryExpressionFix<T extends JetExpression> exten
     public static JetSingleIntentionActionFactory createRemoveTypeFromBinaryExpressionFactory(final String message) {
         return new JetSingleIntentionActionFactory() {
             @Override
-            public KotlinQuickFixAction<JetBinaryExpressionWithTypeRHS> createAction(Diagnostic diagnostic) {
-                JetBinaryExpressionWithTypeRHS expression = QuickFixUtil.getParentElementOfType(diagnostic, JetBinaryExpressionWithTypeRHS.class);
+            public KotlinQuickFixAction<KtBinaryExpressionWithTypeRHS> createAction(Diagnostic diagnostic) {
+                KtBinaryExpressionWithTypeRHS expression = QuickFixUtil.getParentElementOfType(diagnostic, KtBinaryExpressionWithTypeRHS.class);
                 if (expression == null) return null;
-                return new RemoveRightPartOfBinaryExpressionFix<JetBinaryExpressionWithTypeRHS>(expression, message);
+                return new RemoveRightPartOfBinaryExpressionFix<KtBinaryExpressionWithTypeRHS>(expression, message);
             }
         };
     }
@@ -84,9 +84,9 @@ public class RemoveRightPartOfBinaryExpressionFix<T extends JetExpression> exten
     public static JetSingleIntentionActionFactory createRemoveElvisOperatorFactory() {
         return new JetSingleIntentionActionFactory() {
             @Override
-            public KotlinQuickFixAction<JetBinaryExpression> createAction(Diagnostic diagnostic) {
-                JetBinaryExpression expression = (JetBinaryExpression) diagnostic.getPsiElement();
-                return new RemoveRightPartOfBinaryExpressionFix<JetBinaryExpression>(expression, JetBundle.message("remove.elvis.operator"));
+            public KotlinQuickFixAction<KtBinaryExpression> createAction(Diagnostic diagnostic) {
+                KtBinaryExpression expression = (KtBinaryExpression) diagnostic.getPsiElement();
+                return new RemoveRightPartOfBinaryExpressionFix<KtBinaryExpression>(expression, JetBundle.message("remove.elvis.operator"));
             }
         };
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveSupertypeFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveSupertypeFix.java
index fb04f5209bb..d3e3a12c8c2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveSupertypeFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveSupertypeFix.java
@@ -26,14 +26,14 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
-import org.jetbrains.kotlin.lexer.JetTokens;
-import org.jetbrains.kotlin.psi.JetDelegationSpecifier;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.lexer.KtTokens;
+import org.jetbrains.kotlin.psi.KtDelegationSpecifier;
+import org.jetbrains.kotlin.psi.KtFile;
 
-public class RemoveSupertypeFix extends KotlinQuickFixAction<JetDelegationSpecifier> {
-    private final JetDelegationSpecifier superClass;
+public class RemoveSupertypeFix extends KotlinQuickFixAction<KtDelegationSpecifier> {
+    private final KtDelegationSpecifier superClass;
 
-    public RemoveSupertypeFix(@NotNull JetDelegationSpecifier superClass) {
+    public RemoveSupertypeFix(@NotNull KtDelegationSpecifier superClass) {
         super(superClass);
         this.superClass = superClass;
     }
@@ -51,14 +51,14 @@ public class RemoveSupertypeFix extends KotlinQuickFixAction<JetDelegationSpecif
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
         // Find the preceding comma and delete it as well.
         // We must ignore whitespaces and comments when looking for the comma.
         PsiElement prevSibling = superClass.getPrevSibling();
         assert prevSibling != null: "A PSI element should exist before supertype declaration";
         ASTNode prev = PsiImplUtil.skipWhitespaceAndCommentsBack(prevSibling.getNode());
         assert prev != null: "A non-whitespace element should exist before supertype declaration";
-        if (prev.getElementType() == JetTokens.COMMA) {
+        if (prev.getElementType() == KtTokens.COMMA) {
             prev.getPsi().delete();
         }
         superClass.delete();
@@ -67,8 +67,8 @@ public class RemoveSupertypeFix extends KotlinQuickFixAction<JetDelegationSpecif
     public static JetSingleIntentionActionFactory createFactory() {
         return new JetSingleIntentionActionFactory() {
             @Override
-            public KotlinQuickFixAction<JetDelegationSpecifier> createAction(Diagnostic diagnostic) {
-                JetDelegationSpecifier superClass = QuickFixUtil.getParentElementOfType(diagnostic, JetDelegationSpecifier.class);
+            public KotlinQuickFixAction<KtDelegationSpecifier> createAction(Diagnostic diagnostic) {
+                KtDelegationSpecifier superClass = QuickFixUtil.getParentElementOfType(diagnostic, KtDelegationSpecifier.class);
                 if (superClass == null) return null;
                 return new RemoveSupertypeFix(superClass);
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveUnusedFunctionParameterFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveUnusedFunctionParameterFix.kt
index 0e73f6e7a56..31a249e8a65 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveUnusedFunctionParameterFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveUnusedFunctionParameterFix.kt
@@ -22,21 +22,21 @@ import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetParameter
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtParameter
 
-class RemoveUnusedFunctionParameterFix(parameter: JetParameter) : KotlinQuickFixAction<JetParameter>(parameter) {
+class RemoveUnusedFunctionParameterFix(parameter: KtParameter) : KotlinQuickFixAction<KtParameter>(parameter) {
     override fun getFamilyName() = ChangeFunctionSignatureFix.FAMILY_NAME
 
     override fun getText() = "Remove parameter '${element.name}'"
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         val parameterDescriptor = element.resolveToDescriptor() as ValueParameterDescriptor
         ChangeFunctionSignatureFix.runRemoveParameter(parameterDescriptor, element)
     }
 
     companion object : JetSingleIntentionActionFactory() {
-        override fun createAction(diagnostic: Diagnostic): KotlinQuickFixAction<JetParameter> {
+        override fun createAction(diagnostic: Diagnostic): KotlinQuickFixAction<KtParameter> {
             return RemoveUnusedFunctionParameterFix(Errors.UNUSED_PARAMETER.cast(diagnostic).psiElement)
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveValVarFromParameterFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveValVarFromParameterFix.java
index 0997a7d66e9..668cb5d77dc 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveValVarFromParameterFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveValVarFromParameterFix.java
@@ -25,14 +25,14 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetParameter;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtParameter;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt;
 
-public class RemoveValVarFromParameterFix extends KotlinQuickFixAction<JetParameter> {
+public class RemoveValVarFromParameterFix extends KotlinQuickFixAction<KtParameter> {
     private final String varOrVal;
 
-    public RemoveValVarFromParameterFix(@NotNull JetParameter element) {
+    public RemoveValVarFromParameterFix(@NotNull KtParameter element) {
         super(element);
         PsiElement valOrVarNode = element.getValOrVarKeyword();
         assert valOrVarNode != null : "Val or var node not found for " + PsiUtilsKt.getElementTextWithContext(element);
@@ -52,7 +52,7 @@ public class RemoveValVarFromParameterFix extends KotlinQuickFixAction<JetParame
     }
 
     @Override
-    protected void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
+    protected void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
         PsiElement keyword = getElement().getValOrVarKeyword();
         if (keyword == null) return;
         keyword.delete();
@@ -64,7 +64,7 @@ public class RemoveValVarFromParameterFix extends KotlinQuickFixAction<JetParame
             @Nullable
             @Override
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
-                return new RemoveValVarFromParameterFix((JetParameter) diagnostic.getPsiElement().getParent());
+                return new RemoveValVarFromParameterFix((KtParameter) diagnostic.getPsiElement().getParent());
             }
         };
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RenameParameterToMatchOverriddenMethodFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/RenameParameterToMatchOverriddenMethodFix.java
index 6a98ba4b55e..6594af7dc4a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/RenameParameterToMatchOverriddenMethodFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/RenameParameterToMatchOverriddenMethodFix.java
@@ -30,15 +30,15 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetParameter;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtParameter;
 import org.jetbrains.kotlin.resolve.BindingContext;
 
-public class RenameParameterToMatchOverriddenMethodFix extends KotlinQuickFixAction<JetParameter>{
-    private final JetParameter parameter;
+public class RenameParameterToMatchOverriddenMethodFix extends KotlinQuickFixAction<KtParameter>{
+    private final KtParameter parameter;
     private String parameterFromSuperclassName;
 
-    public RenameParameterToMatchOverriddenMethodFix(@NotNull JetParameter parameter) {
+    public RenameParameterToMatchOverriddenMethodFix(@NotNull KtParameter parameter) {
         super(parameter);
         this.parameter = parameter;
     }
@@ -79,7 +79,7 @@ public class RenameParameterToMatchOverriddenMethodFix extends KotlinQuickFixAct
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
         new RenameProcessor(project, parameter, parameterFromSuperclassName, false, false).run();
     }
 
@@ -89,7 +89,7 @@ public class RenameParameterToMatchOverriddenMethodFix extends KotlinQuickFixAct
             @Nullable
             @Override
             public IntentionAction createAction(Diagnostic diagnostic) {
-                JetParameter parameter = QuickFixUtil.getParentElementOfType(diagnostic, JetParameter.class);
+                KtParameter parameter = QuickFixUtil.getParentElementOfType(diagnostic, KtParameter.class);
                 return parameter == null ? null : new RenameParameterToMatchOverriddenMethodFix(parameter);
             }
         };
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RenameUnderscoreFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/RenameUnderscoreFix.kt
index b866d24ece6..2b8fcf1237a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/RenameUnderscoreFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/RenameUnderscoreFix.kt
@@ -24,12 +24,12 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiNameIdentifierOwner
 import com.intellij.refactoring.rename.RenameHandlerRegistry
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-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.psi.psiUtil.getNonStrictParentOfType
 
-class RenameUnderscoreFix(declaration: JetDeclaration) : KotlinQuickFixAction<JetDeclaration>(declaration) {
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+class RenameUnderscoreFix(declaration: KtDeclaration) : KotlinQuickFixAction<KtDeclaration>(declaration) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         if (editor == null) return
         val dataContext = DataManager.getInstance().getDataContext(editor.component)
         val renameHandler = RenameHandlerRegistry.getInstance().getRenameHandler(dataContext)
@@ -45,7 +45,7 @@ class RenameUnderscoreFix(declaration: JetDeclaration) : KotlinQuickFixAction<Je
 
     companion object : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-            val declaration = diagnostic.psiElement.getNonStrictParentOfType<JetDeclaration>() ?: return null
+            val declaration = diagnostic.psiElement.getNonStrictParentOfType<KtDeclaration>() ?: return null
             if (diagnostic.psiElement == (declaration as? PsiNameIdentifierOwner)?.nameIdentifier) {
                 return RenameUnderscoreFix(declaration)
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceCallFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceCallFix.kt
index 8bf9ed24a8a..b254619eb27 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceCallFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceCallFix.kt
@@ -31,7 +31,7 @@ public abstract class ReplaceCallFix protected constructor(val psiElement: PsiEl
     override fun getFamilyName(): String = getText()
 
     override fun isAvailable(project: Project, editor: Editor?, file: PsiFile): Boolean {
-        if (file is JetFile) {
+        if (file is KtFile) {
             return getCallExpression() != null
         }
         return false
@@ -42,8 +42,8 @@ public abstract class ReplaceCallFix protected constructor(val psiElement: PsiEl
 
         val selector = callExpression.getSelectorExpression()
         if (selector != null) {
-            val newElement = JetPsiFactory(callExpression).createExpression(
-                    callExpression.getReceiverExpression().getText() + operation + selector.getText()) as JetQualifiedExpression
+            val newElement = KtPsiFactory(callExpression).createExpression(
+                    callExpression.getReceiverExpression().getText() + operation + selector.getText()) as KtQualifiedExpression
 
             callExpression.replace(newElement)
         }
@@ -51,18 +51,18 @@ public abstract class ReplaceCallFix protected constructor(val psiElement: PsiEl
 
     override fun startInWriteAction(): Boolean = true
 
-    private fun getCallExpression(): JetQualifiedExpression? {
+    private fun getCallExpression(): KtQualifiedExpression? {
         return PsiTreeUtil.getParentOfType(psiElement, classToReplace)
     }
 
     abstract val operation: String
-    abstract val classToReplace: Class<out JetQualifiedExpression>
+    abstract val classToReplace: Class<out KtQualifiedExpression>
 }
 
 public class ReplaceWithSafeCallFix(psiElement: PsiElement): ReplaceCallFix(psiElement) {
     override fun getText(): String = "Replace with safe (?.) call"
     override val operation: String get() = "?."
-    override val classToReplace: Class<out JetQualifiedExpression> get() = javaClass<JetDotQualifiedExpression>()
+    override val classToReplace: Class<out KtQualifiedExpression> get() = javaClass<KtDotQualifiedExpression>()
 
     companion object : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction
@@ -73,7 +73,7 @@ public class ReplaceWithSafeCallFix(psiElement: PsiElement): ReplaceCallFix(psiE
 public class ReplaceWithDotCallFix(psiElement: PsiElement): ReplaceCallFix(psiElement), CleanupFix {
     override fun getText(): String = JetBundle.message("replace.with.dot.call")
     override val operation: String get() = "."
-    override val classToReplace: Class<out JetQualifiedExpression> get() = javaClass<JetSafeQualifiedExpression>()
+    override val classToReplace: Class<out KtQualifiedExpression> get() = javaClass<KtSafeQualifiedExpression>()
 
     companion object : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceInfixCallFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceInfixCallFix.kt
index 4bb83c58ee3..fa8767df622 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceInfixCallFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceInfixCallFix.kt
@@ -20,20 +20,20 @@ import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.createExpressionByPattern
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 
-public class ReplaceInfixCallFix(element: JetBinaryExpression) : KotlinQuickFixAction<JetBinaryExpression>(element) {
+public class ReplaceInfixCallFix(element: KtBinaryExpression) : KotlinQuickFixAction<KtBinaryExpression>(element) {
 
     override fun getText() = "Replace with safe (?.) call"
 
     override fun getFamilyName() = text
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
-        val newExpression = JetPsiFactory(file).createExpressionByPattern(
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+        val newExpression = KtPsiFactory(file).createExpressionByPattern(
                 "$0?.$1($2)", element.left!!, element.operationReference, element.right!!)
         element.replace(newExpression)
     }
@@ -42,7 +42,7 @@ public class ReplaceInfixCallFix(element: JetBinaryExpression) : KotlinQuickFixA
 
     companion object : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-            val expression = diagnostic.psiElement.getNonStrictParentOfType<JetBinaryExpression>()!!
+            val expression = diagnostic.psiElement.getNonStrictParentOfType<KtBinaryExpression>()!!
             if (expression.left == null || expression.right == null) return null
             return ReplaceInfixCallFix(expression)
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceJavaAnnotationPositionedArgumentsFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceJavaAnnotationPositionedArgumentsFix.kt
index 26aebb7516d..9415165d732 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceJavaAnnotationPositionedArgumentsFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceJavaAnnotationPositionedArgumentsFix.kt
@@ -23,20 +23,20 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.quickfix.quickfixUtil.createIntentionForFirstParentOfType
 import org.jetbrains.kotlin.load.kotlin.getJavaAnnotationCallValueArgumentsThatShouldBeNamed
-import org.jetbrains.kotlin.psi.JetAnnotationEntry
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtAnnotationEntry
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument
 
-public class ReplaceJavaAnnotationPositionedArgumentsFix(element: JetAnnotationEntry)
-: KotlinQuickFixAction<JetAnnotationEntry>(element), CleanupFix {
+public class ReplaceJavaAnnotationPositionedArgumentsFix(element: KtAnnotationEntry)
+: KotlinQuickFixAction<KtAnnotationEntry>(element), CleanupFix {
     override fun getText(): String  = "Replace invalid positioned arguments for annotation"
     override fun getFamilyName(): String = getText()
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         val resolvedCall = element.getResolvedCall(element.analyze()) ?: return
-        val psiFactory = JetPsiFactory(project)
+        val psiFactory = KtPsiFactory(project)
 
         getJavaAnnotationCallValueArgumentsThatShouldBeNamed(resolvedCall).forEach argumentProcessor@{
             argument ->
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceObsoleteLabelSyntaxFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceObsoleteLabelSyntaxFix.kt
index 21b17b41c88..3705710dfe2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceObsoleteLabelSyntaxFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceObsoleteLabelSyntaxFix.kt
@@ -29,15 +29,15 @@ import org.jetbrains.kotlin.psi.psiUtil.anyDescendantOfType
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 
-public class ReplaceObsoleteLabelSyntaxFix(element: JetAnnotationEntry) : KotlinQuickFixAction<JetAnnotationEntry>(element), CleanupFix {
+public class ReplaceObsoleteLabelSyntaxFix(element: KtAnnotationEntry) : KotlinQuickFixAction<KtAnnotationEntry>(element), CleanupFix {
     override fun getFamilyName(): String = "Update obsolete label syntax"
     override fun getText(): String = "Replace with label ${element.getCalleeExpression()?.getText() ?: ""}@"
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) = replaceWithLabel(element)
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) = replaceWithLabel(element)
 
     companion object : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-            val annotationEntry = diagnostic.getPsiElement().getNonStrictParentOfType<JetAnnotationEntry>() ?: return null
+            val annotationEntry = diagnostic.getPsiElement().getNonStrictParentOfType<KtAnnotationEntry>() ?: return null
 
             if (!looksLikeObsoleteLabel(annotationEntry)) return null
 
@@ -47,44 +47,44 @@ public class ReplaceObsoleteLabelSyntaxFix(element: JetAnnotationEntry) : Kotlin
         public fun createWholeProjectFixFactory(): JetSingleIntentionActionFactory = createIntentionFactory factory@ {
             diagnostic ->
 
-            if (!(diagnostic.getPsiElement().getNonStrictParentOfType<JetAnnotationEntry>()?.looksLikeObsoleteLabelWithReferencesInCode()
+            if (!(diagnostic.getPsiElement().getNonStrictParentOfType<KtAnnotationEntry>()?.looksLikeObsoleteLabelWithReferencesInCode()
                 ?: false)) return@factory null
 
-            JetWholeProjectForEachElementOfTypeFix.createForMultiTaskOnElement<JetAnnotatedExpression, JetAnnotationEntry>(
+            JetWholeProjectForEachElementOfTypeFix.createForMultiTaskOnElement<KtAnnotatedExpression, KtAnnotationEntry>(
                     tasksFactory = { collectTasks(it) },
                     tasksProcessor ={ it.forEach { ann -> replaceWithLabel(ann) } },
                     name = "Update obsolete label syntax in whole project"
             )
         }
 
-        private fun collectTasks(expression: JetAnnotatedExpression) =
+        private fun collectTasks(expression: KtAnnotatedExpression) =
                 expression.getAnnotationEntries().filter { it.looksLikeObsoleteLabelWithReferencesInCode() }
 
-        private fun JetAnnotationEntry.looksLikeObsoleteLabelWithReferencesInCode(): Boolean {
+        private fun KtAnnotationEntry.looksLikeObsoleteLabelWithReferencesInCode(): Boolean {
             if (!looksLikeObsoleteLabel(this)) return false
 
-            val baseExpression = (getParent() as? JetAnnotatedExpression)?.getBaseExpression() ?: return false
+            val baseExpression = (getParent() as? KtAnnotatedExpression)?.getBaseExpression() ?: return false
 
             val nameExpression = getCalleeExpression()?.getConstructorReferenceExpression() ?: return false
             val labelName = nameExpression.getReferencedName()
 
-            return baseExpression.anyDescendantOfType<JetExpressionWithLabel> {
-                (it is JetBreakExpression || it is JetContinueExpression || it is JetReturnExpression) &&
+            return baseExpression.anyDescendantOfType<KtExpressionWithLabel> {
+                (it is KtBreakExpression || it is KtContinueExpression || it is KtReturnExpression) &&
                 it.getLabelName() == labelName &&
                 it.getTargetLabel()?.analyze()?.get(BindingContext.LABEL_TARGET, it.getTargetLabel()) == null
             } && analyze().getDiagnostics().forElement(nameExpression).any { it.getFactory() == Errors.UNRESOLVED_REFERENCE }
         }
 
-        public fun looksLikeObsoleteLabel(entry: JetAnnotationEntry): Boolean =
+        public fun looksLikeObsoleteLabel(entry: KtAnnotationEntry): Boolean =
                 entry.getAtSymbol() != null &&
-                entry.getParent() is JetAnnotatedExpression &&
-                (entry.getParent() as JetAnnotatedExpression).getAnnotationEntries().size() == 1 &&
+                entry.getParent() is KtAnnotatedExpression &&
+                (entry.getParent() as KtAnnotatedExpression).getAnnotationEntries().size() == 1 &&
                 entry.getValueArgumentList() == null &&
                 entry.getCalleeExpression()?.getConstructorReferenceExpression()?.getIdentifier() != null
 
-        private fun replaceWithLabel(annotation: JetAnnotationEntry) {
+        private fun replaceWithLabel(annotation: KtAnnotationEntry) {
             val labelName = annotation.getCalleeExpression()?.getConstructorReferenceExpression()?.getReferencedName() ?: return
-            val annotatedExpression = annotation.getParent() as? JetAnnotatedExpression ?: return
+            val annotatedExpression = annotation.getParent() as? KtAnnotatedExpression ?: return
             val expression = annotatedExpression.getBaseExpression() ?: return
 
             if (annotatedExpression.getAnnotationEntries().size() != 1) return
@@ -94,7 +94,7 @@ public class ReplaceObsoleteLabelSyntaxFix(element: JetAnnotationEntry) : Kotlin
             val textRangeToRetain = TextRange(annotation.getTextRange().getEndOffset(), baseExpressionStart)
             val textToRetain = textRangeToRetain.substring(annotation.getContainingFile().getText())
 
-            val labeledExpression = JetPsiFactory(annotation).createExpressionByPattern("$0@$1$2", labelName, textToRetain, expression)
+            val labeledExpression = KtPsiFactory(annotation).createExpressionByPattern("$0@$1$2", labelName, textToRetain, expression)
 
             annotatedExpression.replace(labeledExpression)
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceOperationInBinaryExpressionFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceOperationInBinaryExpressionFix.java
index 8609043ad58..c923ad0d197 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceOperationInBinaryExpressionFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceOperationInBinaryExpressionFix.java
@@ -23,7 +23,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.psi.*;
 
-public abstract class ReplaceOperationInBinaryExpressionFix<T extends JetExpression> extends KotlinQuickFixAction<T> {
+public abstract class ReplaceOperationInBinaryExpressionFix<T extends KtExpression> extends KotlinQuickFixAction<T> {
     private final String operation;
 
     public ReplaceOperationInBinaryExpressionFix(@NotNull T element, String operation) {
@@ -38,12 +38,12 @@ public abstract class ReplaceOperationInBinaryExpressionFix<T extends JetExpress
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        if (getElement() instanceof JetBinaryExpressionWithTypeRHS) {
-            JetExpression left = ((JetBinaryExpressionWithTypeRHS) getElement()).getLeft();
-            JetTypeReference right = ((JetBinaryExpressionWithTypeRHS) getElement()).getRight();
+    public void invoke(@NotNull Project project, Editor editor, KtFile file) throws IncorrectOperationException {
+        if (getElement() instanceof KtBinaryExpressionWithTypeRHS) {
+            KtExpression left = ((KtBinaryExpressionWithTypeRHS) getElement()).getLeft();
+            KtTypeReference right = ((KtBinaryExpressionWithTypeRHS) getElement()).getRight();
             if (right != null) {
-                JetExpression expression = JetPsiFactoryKt.JetPsiFactory(file).createExpression(left.getText() + operation + right.getText());
+                KtExpression expression = KtPsiFactoryKt.KtPsiFactory(file).createExpression(left.getText() + operation + right.getText());
                 getElement().replace(expression);
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/SpecifyTypeExplicitlyFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/SpecifyTypeExplicitlyFix.kt
index 6d66050614f..a8f32d383da 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/SpecifyTypeExplicitlyFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/SpecifyTypeExplicitlyFix.kt
@@ -22,9 +22,9 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.idea.intentions.SpecifyTypeExplicitlyIntention
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 
 public class SpecifyTypeExplicitlyFix : PsiElementBaseIntentionAction() {
@@ -38,10 +38,10 @@ public class SpecifyTypeExplicitlyFix : PsiElementBaseIntentionAction() {
 
     override fun isAvailable(project: Project, editor: Editor, element: PsiElement): Boolean {
         val declaration = declarationByElement(element)
-        if (declaration is JetProperty) {
+        if (declaration is KtProperty) {
             setText("Specify type explicitly")
         }
-        else if (declaration is JetNamedFunction) {
+        else if (declaration is KtNamedFunction) {
             setText("Specify return type explicitly")
         }
         else {
@@ -51,7 +51,7 @@ public class SpecifyTypeExplicitlyFix : PsiElementBaseIntentionAction() {
         return !SpecifyTypeExplicitlyIntention.getTypeForDeclaration(declaration).isError()
     }
 
-    private fun declarationByElement(element: PsiElement): JetCallableDeclaration? {
-        return PsiTreeUtil.getParentOfType(element, javaClass<JetProperty>(), javaClass<JetNamedFunction>()) as JetCallableDeclaration?
+    private fun declarationByElement(element: PsiElement): KtCallableDeclaration? {
+        return PsiTreeUtil.getParentOfType(element, javaClass<KtProperty>(), javaClass<KtNamedFunction>()) as KtCallableDeclaration?
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/SuperClassNotInitialized.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/SuperClassNotInitialized.kt
index 858f818c0e8..36a4169e937 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/SuperClassNotInitialized.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/SuperClassNotInitialized.kt
@@ -40,7 +40,7 @@ import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.render
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.types.IndexedParametersSubstitution
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
 import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.*
@@ -49,8 +49,8 @@ public object SuperClassNotInitialized : JetIntentionActionsFactory() {
     private val DISPLAY_MAX_PARAMS = 5
 
     override fun doCreateActions(diagnostic: Diagnostic): List<IntentionAction> {
-        val delegator = diagnostic.getPsiElement() as JetDelegatorToSuperClass
-        val classOrObjectDeclaration = delegator.getParent().getParent() as? JetClassOrObject ?: return emptyList()
+        val delegator = diagnostic.getPsiElement() as KtDelegatorToSuperClass
+        val classOrObjectDeclaration = delegator.getParent().getParent() as? KtClassOrObject ?: return emptyList()
 
         val typeRef = delegator.getTypeReference() ?: return emptyList()
         val type = typeRef.analyze()[BindingContext.TYPE, typeRef] ?: return emptyList()
@@ -65,7 +65,7 @@ public object SuperClassNotInitialized : JetIntentionActionsFactory() {
 
         fixes.add(AddParenthesisFix(delegator, putCaretIntoParenthesis = constructors.singleOrNull()?.getValueParameters()?.isNotEmpty() ?: true))
 
-        if (classOrObjectDeclaration is JetClass) {
+        if (classOrObjectDeclaration is KtClass) {
             val superType = classDescriptor.getTypeConstructor().getSupertypes().firstOrNull { it.getConstructor().getDeclarationDescriptor() == superClass }
             if (superType != null) {
                 val substitutor = IndexedParametersSubstitution(superClass.typeConstructor, superType.arguments).buildSubstitutor()
@@ -75,7 +75,7 @@ public object SuperClassNotInitialized : JetIntentionActionsFactory() {
                         .map { it.substitute(substitutor) as ConstructorDescriptor }
 
                 if (substitutedConstructors.isNotEmpty()) {
-                    val parameterTypes: List<List<JetType>> = substitutedConstructors.map {
+                    val parameterTypes: List<List<KtType>> = substitutedConstructors.map {
                         it.getValueParameters().map { it.getType() }
                     }
 
@@ -103,16 +103,16 @@ public object SuperClassNotInitialized : JetIntentionActionsFactory() {
     }
 
     private class AddParenthesisFix(
-            element: JetDelegatorToSuperClass,
+            element: KtDelegatorToSuperClass,
             val putCaretIntoParenthesis: Boolean
-    ) : KotlinQuickFixAction<JetDelegatorToSuperClass>(element), HighPriorityAction {
+    ) : KotlinQuickFixAction<KtDelegatorToSuperClass>(element), HighPriorityAction {
 
         override fun getFamilyName() = "Change to constructor invocation" //TODO?
 
         override fun getText() = getFamilyName()
 
-        override fun invoke(project: Project, editor: Editor?, file: JetFile) {
-            val newSpecifier = element.replaced(JetPsiFactory(project).createDelegatorToSuperCall(element.getText() + "()"))
+        override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+            val newSpecifier = element.replaced(KtPsiFactory(project).createDelegatorToSuperCall(element.getText() + "()"))
 
             if (putCaretIntoParenthesis) {
                 if (editor != null) {
@@ -127,17 +127,17 @@ public object SuperClassNotInitialized : JetIntentionActionsFactory() {
     }
 
     private class AddParametersFix(
-            element: JetDelegatorToSuperClass,
-            private val classDeclaration: JetClass,
-            private val parametersToAdd: Collection<JetParameter>,
+            element: KtDelegatorToSuperClass,
+            private val classDeclaration: KtClass,
+            private val parametersToAdd: Collection<KtParameter>,
             private val argumentText: String,
             private val text: String
-    ) : KotlinQuickFixAction<JetDelegatorToSuperClass>(element) {
+    ) : KotlinQuickFixAction<KtDelegatorToSuperClass>(element) {
 
         companion object {
             fun create(
-                    element: JetDelegatorToSuperClass,
-                    classDeclaration: JetClass,
+                    element: KtDelegatorToSuperClass,
+                    classDeclaration: KtClass,
                     superConstructor: ConstructorDescriptor,
                     text: String
             ): AddParametersFix? {
@@ -148,7 +148,7 @@ public object SuperClassNotInitialized : JetIntentionActionsFactory() {
 
                 val argumentText = StringBuilder()
                 val oldParameters = classDeclaration.getPrimaryConstructorParameters()
-                val parametersToAdd = ArrayList<JetParameter>()
+                val parametersToAdd = ArrayList<KtParameter>()
                 for (parameter in superParameters) {
                     val nameRendered = parameter.name.render()
                     val varargElementType = parameter.varargElementType
@@ -169,7 +169,7 @@ public object SuperClassNotInitialized : JetIntentionActionsFactory() {
                         "vararg " + nameRendered + ":" + IdeDescriptorRenderers.SOURCE_CODE.renderType(varargElementType)
                     else
                         nameRendered + ":" + IdeDescriptorRenderers.SOURCE_CODE.renderType(parameter.type)
-                    parametersToAdd.add(JetPsiFactory(element).createParameter(parameterText))
+                    parametersToAdd.add(KtPsiFactory(element).createParameter(parameterText))
                 }
 
                 return AddParametersFix(element, classDeclaration, parametersToAdd, argumentText.toString(), text)
@@ -180,10 +180,10 @@ public object SuperClassNotInitialized : JetIntentionActionsFactory() {
 
         override fun getText() = text
 
-        override fun invoke(project: Project, editor: Editor?, file: JetFile) {
-            val factory = JetPsiFactory(project)
+        override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+            val factory = KtPsiFactory(project)
 
-            val typeRefsToShorten = ArrayList<JetTypeReference>()
+            val typeRefsToShorten = ArrayList<KtTypeReference>()
             val parameterList = classDeclaration.createPrimaryConstructorParameterListIfAbsent()
 
             for (parameter in parametersToAdd) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/CreateFromUsageFixBase.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/CreateFromUsageFixBase.kt
index 0f4f0fab2b3..5895b42b1bb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/CreateFromUsageFixBase.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/CreateFromUsageFixBase.kt
@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.idea.quickfix.createFromUsage
 
 import org.jetbrains.kotlin.idea.JetBundle
 import org.jetbrains.kotlin.idea.quickfix.KotlinQuickFixAction
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 
-public abstract class CreateFromUsageFixBase<T: JetElement>(element: T) : KotlinQuickFixAction<T>(element) {
+public abstract class CreateFromUsageFixBase<T: KtElement>(element: T) : KotlinQuickFixAction<T>(element) {
     override fun getFamilyName(): String = JetBundle.message("create.from.usage.family")
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt
index fe086994319..eff7e088f50 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt
@@ -55,7 +55,7 @@ import org.jetbrains.kotlin.idea.util.ShortenReferences
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -66,10 +66,10 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.scopes.*
 import org.jetbrains.kotlin.resolve.scopes.utils.asJetScope
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeProjectionImpl
 import org.jetbrains.kotlin.types.Variance
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.typeUtil.isAnyOrNullableAny
 import org.jetbrains.kotlin.types.typeUtil.isUnit
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
@@ -83,7 +83,7 @@ private val ATTRIBUTE_FUNCTION_NAME = "FUNCTION_NAME"
 /**
  * Represents a single choice for a type (e.g. parameter type or return type).
  */
-class TypeCandidate(val theType: JetType, scope: JetScope? = null) {
+class TypeCandidate(val theType: KtType, scope: KtScope? = null) {
     public val typeParameters: Array<TypeParameterDescriptor>
     var renderedType: String? = null
         private set
@@ -117,13 +117,13 @@ data class RenderedTypeParameter(
         val text: String
 )
 
-fun List<TypeCandidate>.getTypeByRenderedType(renderedType: String): JetType? =
+fun List<TypeCandidate>.getTypeByRenderedType(renderedType: String): KtType? =
         firstOrNull { it.renderedType == renderedType }?.theType
 
 class CallableBuilderConfiguration(
         val callableInfos: List<CallableInfo>,
-        val originalElement: JetElement,
-        val currentFile: JetFile,
+        val originalElement: KtElement,
+        val currentFile: KtFile,
         val currentEditor: Editor?,
         val isExtension: Boolean = false,
         val enableSubstitutions: Boolean = true
@@ -152,7 +152,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
 
     public var placement: CallablePlacement by Delegates.notNull()
 
-    private val elementsToShorten = ArrayList<JetElement>()
+    private val elementsToShorten = ArrayList<KtElement>()
 
     fun computeTypeCandidates(typeInfo: TypeInfo): List<TypeCandidate> =
             typeCandidates.getOrPut(typeInfo) { typeInfo.getPossibleTypes(this).map { TypeCandidate(it) } }
@@ -160,15 +160,15 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
     fun computeTypeCandidates(
             typeInfo: TypeInfo,
             substitutions: List<JetTypeSubstitution>,
-            scope: JetScope): List<TypeCandidate> {
+            scope: KtScope): List<TypeCandidate> {
         if (!typeInfo.substitutionsAllowed) return computeTypeCandidates(typeInfo)
         return typeCandidates.getOrPut(typeInfo) {
             val types = typeInfo.getPossibleTypes(this).asReversed()
 
             // We have to use semantic equality here
-            data class EqWrapper(val _type: JetType) {
+            data class EqWrapper(val _type: KtType) {
                 override fun equals(other: Any?) = this === other
-                                                   || other is EqWrapper && JetTypeChecker.DEFAULT.equalTypes(_type, other._type)
+                                                   || other is EqWrapper && KotlinTypeChecker.DEFAULT.equalTypes(_type, other._type)
                 override fun hashCode() = 0 // no good way to compute hashCode() that would agree with our equals()
             }
 
@@ -215,7 +215,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
 
     private inner class Context(val callableInfo: CallableInfo) {
         val skipReturnType: Boolean
-        val jetFileToEdit: JetFile
+        val jetFileToEdit: KtFile
         val containingFileEditor: Editor
         val containingElement: PsiElement
         val dialogWithEditor: DialogWithEditor?
@@ -235,7 +235,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                     containingElement = placement.containingElement
                     receiverClassDescriptor = with (placement.containingElement) {
                         when (this) {
-                            is JetClassOrObject -> currentFileContext[BindingContext.CLASS, this]
+                            is KtClassOrObject -> currentFileContext[BindingContext.CLASS, this]
                             is PsiClass -> getJavaClassDescriptor()
                             else -> null
                         }
@@ -257,7 +257,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 NavigationUtil.activateFileWithPsiElement(containingElement)
             }
 
-            if (containingElement is JetElement) {
+            if (containingElement is KtElement) {
                 jetFileToEdit = containingElement.getContainingJetFile()
                 if (jetFileToEdit != config.currentFile) {
                     containingFileEditor = FileEditorManager.getInstance(project).getSelectedTextEditor()!!
@@ -280,7 +280,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                     setAdditionalColumnsCount(config.currentEditor!!.getSettings().getRightMargin(project))
                     setAdditionalLinesCount(5)
                 }
-                jetFileToEdit = PsiDocumentManager.getInstance(project).getPsiFile(containingFileEditor.getDocument()) as JetFile
+                jetFileToEdit = PsiDocumentManager.getInstance(project).getPsiFile(containingFileEditor.getDocument()) as KtFile
                 jetFileToEdit.analysisContext = config.currentFile
                 dialogWithEditor = dialog
             }
@@ -291,7 +291,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
 
             val fakeFunction: FunctionDescriptor?
             // figure out type substitutions for type parameters
-            val substitutionMap = LinkedHashMap<JetType, JetType>()
+            val substitutionMap = LinkedHashMap<KtType, KtType>()
             if (config.enableSubstitutions) {
                 collectSubstitutionsForReceiverTypeParameters(receiverType, substitutionMap)
                 val typeArgumentsForFakeFunction = callableInfo.typeParameterInfos
@@ -322,7 +322,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 CallableKind.CLASS_WITH_PRIMARY_CONSTRUCTOR ->
                     callableInfo.returnTypeInfo == TypeInfo.Empty || returnTypeCandidate?.theType?.isAnyOrNullableAny() ?: false
                 CallableKind.SECONDARY_CONSTRUCTOR -> true
-                CallableKind.PROPERTY -> containingElement is JetBlockExpression
+                CallableKind.PROPERTY -> containingElement is KtBlockExpression
             }
 
             // figure out type parameter renames to avoid conflicts
@@ -335,7 +335,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
             mandatoryTypeParametersAsCandidates.forEach { it.render(typeParameterNameMap, fakeFunction) }
         }
 
-        private fun getDeclarationScope(): JetScope {
+        private fun getDeclarationScope(): KtScope {
             if (config.isExtension || receiverClassDescriptor == null) {
                 return currentFileModule.getPackage(config.currentFile.getPackageFqName()).memberScope
             }
@@ -348,7 +348,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
 
             val typeParamScope = with(
                     WritableScopeImpl(
-                            JetScope.Empty,
+                            KtScope.Empty,
                             receiverClassDescriptor,
                             RedeclarationHandler.DO_NOTHING,
                             "Scope with type parameters for ${receiverClassDescriptor.getName()}"
@@ -372,8 +372,8 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
         }
 
         private fun collectSubstitutionsForReceiverTypeParameters(
-                receiverType: JetType?,
-                result: MutableMap<JetType, JetType>
+                receiverType: KtType?,
+                result: MutableMap<KtType, KtType>
         ) {
             if (placement is CallablePlacement.NoReceiver) return
 
@@ -386,14 +386,14 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
 
         private fun collectSubstitutionsForCallableTypeParameters(
                 fakeFunction: FunctionDescriptor,
-                typeArguments: Set<JetType>,
-                result: MutableMap<JetType, JetType>) {
+                typeArguments: Set<KtType>,
+                result: MutableMap<KtType, KtType>) {
             for ((typeArgument, typeParameter) in typeArguments zip fakeFunction.getTypeParameters()) {
                 result[typeArgument] = typeParameter.getDefaultType()
             }
         }
 
-        private fun createFakeFunctionDescriptor(scope: JetScope, typeParameterCount: Int): FunctionDescriptor {
+        private fun createFakeFunctionDescriptor(scope: KtScope, typeParameterCount: Int): FunctionDescriptor {
             val fakeFunction = SimpleFunctionDescriptorImpl.create(
                     MutablePackageFragmentDescriptor(currentFileModule, FqName("fake")),
                     Annotations.EMPTY,
@@ -427,11 +427,11 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
             typeCandidates[typeInfo]?.forEach { it.render(typeParameterNameMap, fakeFunction) }
         }
 
-        private fun createDeclarationSkeleton(): JetNamedDeclaration {
+        private fun createDeclarationSkeleton(): KtNamedDeclaration {
             with (config) {
                 val assignmentToReplace =
-                        if (containingElement is JetBlockExpression && (callableInfo as? PropertyInfo)?.writable ?: false) {
-                            originalElement as JetBinaryExpression
+                        if (containingElement is KtBlockExpression && (callableInfo as? PropertyInfo)?.writable ?: false) {
+                            originalElement as KtBinaryExpression
                         }
                         else null
 
@@ -457,19 +457,19 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 val returnTypeString = if (skipReturnType || assignmentToReplace != null) "" else ": Any"
                 val header = "$ownerTypeString${callableInfo.name.quoteIfNeeded()}$paramList$returnTypeString"
 
-                val psiFactory = JetPsiFactory(currentFile)
+                val psiFactory = KtPsiFactory(currentFile)
 
                 val modifiers =
-                        if (containingElement is JetClassOrObject
+                        if (containingElement is KtClassOrObject
                             && containingElement.isAncestor(config.originalElement)
                             && callableInfo.kind != CallableKind.SECONDARY_CONSTRUCTOR)
                             "private "
                         else ""
 
-                val declaration : JetNamedDeclaration = when (callableInfo.kind) {
+                val declaration : KtNamedDeclaration = when (callableInfo.kind) {
                     CallableKind.FUNCTION, CallableKind.SECONDARY_CONSTRUCTOR -> {
                         val body = when {
-                            containingElement is JetClass && containingElement.isInterface() && !config.isExtension -> ""
+                            containingElement is KtClass && containingElement.isInterface() && !config.isExtension -> ""
                             else -> "{}"
                         }
                         if (callableInfo is FunctionInfo) {
@@ -489,7 +489,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                             val safeName = name.quoteIfNeeded()
                             when (kind) {
                                 ClassKind.ENUM_ENTRY -> {
-                                    if (!(targetParent is JetClass && targetParent.isEnum())) throw AssertionError("Enum class expected: ${targetParent.getText()}")
+                                    if (!(targetParent is KtClass && targetParent.isEnum())) throw AssertionError("Enum class expected: ${targetParent.getText()}")
                                     val hasParameters = targetParent.getPrimaryConstructorParameters().isNotEmpty()
                                     psiFactory.createEnumEntry("$safeName${if (hasParameters) "()" else " "}")
                                 }
@@ -500,7 +500,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                                         ClassKind.PLAIN_CLASS, ClassKind.INTERFACE -> "<>"
                                         else -> ""
                                     }
-                                    psiFactory.createDeclaration<JetClassOrObject>(
+                                    psiFactory.createDeclaration<KtClassOrObject>(
                                             "$openMod$innerMod${kind.keyword} $safeName$typeParamList$paramList$returnTypeString $classBody"
                                     )
                                 }
@@ -514,13 +514,13 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 }
 
                 if (assignmentToReplace != null) {
-                    (declaration as JetProperty).setInitializer(assignmentToReplace.getRight())
-                    return assignmentToReplace.replace(declaration) as JetCallableDeclaration
+                    (declaration as KtProperty).setInitializer(assignmentToReplace.getRight())
+                    return assignmentToReplace.replace(declaration) as KtCallableDeclaration
                 }
 
                 val newLine = psiFactory.createNewLine()
 
-                fun calcNecessaryEmptyLines(decl: JetDeclaration, after: Boolean): Int {
+                fun calcNecessaryEmptyLines(decl: KtDeclaration, after: Boolean): Int {
                     var lineBreaksPresent: Int = 0
                     var neighbor: PsiElement? = null
 
@@ -537,54 +537,54 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
 
                     val neighborType = neighbor?.getNode()?.getElementType()
                     val lineBreaksNeeded = when {
-                        neighborType == JetTokens.LBRACE, neighborType == JetTokens.RBRACE -> 1
-                        neighbor is JetDeclaration && (neighbor !is JetProperty || decl !is JetProperty) -> 2
+                        neighborType == KtTokens.LBRACE, neighborType == KtTokens.RBRACE -> 1
+                        neighbor is KtDeclaration && (neighbor !is KtProperty || decl !is KtProperty) -> 2
                         else -> 1
                     }
 
                     return Math.max(lineBreaksNeeded - lineBreaksPresent, 0)
                 }
 
-                fun addNextToOriginalElementContainer(addBefore: Boolean): JetNamedDeclaration {
-                    val actualContainer = (containingElement as? JetClassOrObject)?.getBody() ?: containingElement
+                fun addNextToOriginalElementContainer(addBefore: Boolean): KtNamedDeclaration {
+                    val actualContainer = (containingElement as? KtClassOrObject)?.getBody() ?: containingElement
                     val sibling = config.originalElement.parentsWithSelf.first { it.getParent() == actualContainer }
                     return if (addBefore) {
                         actualContainer.addBefore(declaration, sibling)
                     }
                     else {
                         actualContainer.addAfter(declaration, sibling)
-                    } as JetNamedDeclaration
+                    } as KtNamedDeclaration
                 }
 
                 val declarationInPlace = when {
                     containingElement.isAncestor(config.originalElement, true) -> {
-                        val insertToBlock = containingElement is JetBlockExpression
+                        val insertToBlock = containingElement is KtBlockExpression
                         if (insertToBlock) {
                             val parent = containingElement.getParent()
-                            if (parent is JetFunctionLiteral) {
+                            if (parent is KtFunctionLiteral) {
                                 if (!parent.isMultiLine()) {
                                     parent.addBefore(newLine, containingElement)
                                     parent.addAfter(newLine, containingElement)
                                 }
                             }
                         }
-                        addNextToOriginalElementContainer(insertToBlock || declaration is JetProperty)
+                        addNextToOriginalElementContainer(insertToBlock || declaration is KtProperty)
                     }
 
-                    containingElement is JetFile -> containingElement.add(declaration) as JetNamedDeclaration
+                    containingElement is KtFile -> containingElement.add(declaration) as KtNamedDeclaration
 
                     containingElement is PsiClass -> {
-                        if (declaration is JetSecondaryConstructor) {
+                        if (declaration is KtSecondaryConstructor) {
                             val wrappingClass = psiFactory.createClass("class ${containingElement.getName()} {\n}")
                             addDeclarationToClassOrObject(wrappingClass, declaration)
-                            (jetFileToEdit.add(wrappingClass) as JetClass).getDeclarations().first() as JetNamedDeclaration
+                            (jetFileToEdit.add(wrappingClass) as KtClass).getDeclarations().first() as KtNamedDeclaration
                         }
                         else {
-                            jetFileToEdit.add(declaration) as JetNamedDeclaration
+                            jetFileToEdit.add(declaration) as KtNamedDeclaration
                         }
                     }
 
-                    containingElement is JetClassOrObject -> {
+                    containingElement is KtClassOrObject -> {
                         addDeclarationToClassOrObject(containingElement, declaration)
                     }
                     else -> throw AssertionError("Invalid containing element: ${containingElement.getText()}")
@@ -602,20 +602,20 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
             }
         }
 
-        private fun addDeclarationToClassOrObject(classOrObject: JetClassOrObject,
-                                                  declaration: JetNamedDeclaration): JetNamedDeclaration {
+        private fun addDeclarationToClassOrObject(classOrObject: KtClassOrObject,
+                                                  declaration: KtNamedDeclaration): KtNamedDeclaration {
             val classBody = classOrObject.getOrCreateBody()
-            return if (declaration is JetNamedFunction) {
+            return if (declaration is KtNamedFunction) {
                 val anchor = PsiTreeUtil.skipSiblingsBackward(
                         classBody.getRBrace() ?: classBody.getLastChild()!!,
                         javaClass<PsiWhiteSpace>()
                 )
-                classBody.addAfter(declaration, anchor) as JetNamedDeclaration
+                classBody.addAfter(declaration, anchor) as KtNamedDeclaration
             }
-            else classBody.addAfter(declaration, classBody.getLBrace()!!) as JetNamedDeclaration
+            else classBody.addAfter(declaration, classBody.getLBrace()!!) as KtNamedDeclaration
         }
 
-        private fun getTypeParameterRenames(scope: JetScope): Map<TypeParameterDescriptor, String> {
+        private fun getTypeParameterRenames(scope: KtScope): Map<TypeParameterDescriptor, String> {
             val allTypeParametersNotInScope = LinkedHashSet<TypeParameterDescriptor>()
 
             mandatoryTypeParametersAsCandidates.asSequence()
@@ -635,15 +635,15 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
             return allTypeParametersNotInScope.zip(typeParameterNames).toMap()
         }
 
-        private fun setupTypeReferencesForShortening(declaration: JetNamedDeclaration,
-                                                     parameterTypeExpressions: List<TypeExpression>): List<JetElement> {
-            val typeRefsToShorten = ArrayList<JetElement>()
+        private fun setupTypeReferencesForShortening(declaration: KtNamedDeclaration,
+                                                     parameterTypeExpressions: List<TypeExpression>): List<KtElement> {
+            val typeRefsToShorten = ArrayList<KtElement>()
 
             if (config.isExtension) {
-                val receiverTypeRef = JetPsiFactory(declaration).createType(receiverTypeCandidate!!.theType.renderLong(typeParameterNameMap))
+                val receiverTypeRef = KtPsiFactory(declaration).createType(receiverTypeCandidate!!.theType.renderLong(typeParameterNameMap))
                 replaceWithLongerName(receiverTypeRef, receiverTypeCandidate.theType)
 
-                val funcReceiverTypeRef = (declaration as? JetCallableDeclaration)?.getReceiverTypeReference()
+                val funcReceiverTypeRef = (declaration as? KtCallableDeclaration)?.getReceiverTypeReference()
                 if (funcReceiverTypeRef != null) {
                     typeRefsToShorten.add(funcReceiverTypeRef)
                 }
@@ -687,12 +687,12 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
             return typeRefsToShorten
         }
 
-        private fun setupFunctionBody(func: JetFunction) {
+        private fun setupFunctionBody(func: KtFunction) {
             val oldBody = func.getBodyExpression() ?: return
 
             val templateName = when (func) {
-                is JetSecondaryConstructor -> TEMPLATE_FROM_USAGE_SECONDARY_CONSTRUCTOR_BODY
-                is JetNamedFunction -> TEMPLATE_FROM_USAGE_FUNCTION_BODY
+                is KtSecondaryConstructor -> TEMPLATE_FROM_USAGE_SECONDARY_CONSTRUCTOR_BODY
+                is KtNamedFunction -> TEMPLATE_FROM_USAGE_FUNCTION_BODY
                 else -> throw AssertionError("Unexpected declaration: " + func.getElementTextWithContext())
             }
             val fileTemplate = FileTemplateManager.getInstance(func.getProject())!!.getCodeTemplate(templateName)
@@ -718,10 +718,10 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 throw IncorrectOperationException("Failed to parse file template", e)
             }
 
-            oldBody.replace(JetPsiFactory(func).createBlock(bodyText))
+            oldBody.replace(KtPsiFactory(func).createBlock(bodyText))
         }
 
-        private fun setupCallTypeArguments(callElement: JetCallElement, typeParameters: List<TypeParameterDescriptor>) {
+        private fun setupCallTypeArguments(callElement: KtCallElement, typeParameters: List<TypeParameterDescriptor>) {
             val oldTypeArgumentList = callElement.getTypeArgumentList() ?: return
             val renderedTypeArgs = typeParameters.map { typeParameter ->
                 val type = substitutions.first { it.byType.getConstructor().getDeclarationDescriptor() == typeParameter }.forType
@@ -731,23 +731,23 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 oldTypeArgumentList.delete()
             }
             else {
-                oldTypeArgumentList.replace(JetPsiFactory(callElement).createTypeArguments(renderedTypeArgs.joinToString(", ", "<", ">")))
+                oldTypeArgumentList.replace(KtPsiFactory(callElement).createTypeArguments(renderedTypeArgs.joinToString(", ", "<", ">")))
                 elementsToShorten.add(callElement.getTypeArgumentList()!!)
             }
         }
 
-        private fun setupReturnTypeTemplate(builder: TemplateBuilder, declaration: JetNamedDeclaration): TypeExpression? {
+        private fun setupReturnTypeTemplate(builder: TemplateBuilder, declaration: KtNamedDeclaration): TypeExpression? {
             val candidates = typeCandidates[callableInfo.returnTypeInfo]!!
             if (candidates.isEmpty()) return null
 
-            val elementToReplace: JetElement?
+            val elementToReplace: KtElement?
             val expression: TypeExpression
             when (declaration) {
-                is JetCallableDeclaration -> {
+                is KtCallableDeclaration -> {
                     elementToReplace = declaration.getTypeReference()
                     expression = TypeExpression.ForTypeReference(candidates)
                 }
-                is JetClassOrObject -> {
+                is KtClassOrObject -> {
                     elementToReplace = declaration.getDelegationSpecifiers().firstOrNull()
                     expression = TypeExpression.ForDelegationSpecifier(candidates)
                 }
@@ -764,7 +764,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
             return expression
         }
 
-        private fun setupValVarTemplate(builder: TemplateBuilder, property: JetProperty) {
+        private fun setupValVarTemplate(builder: TemplateBuilder, property: KtProperty) {
             if (!(callableInfo as PropertyInfo).writable) {
                 builder.replaceElement(property.getValOrVarKeyword(), ValVarExpression)
             }
@@ -772,14 +772,14 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
 
         private fun setupTypeParameterListTemplate(
                 builder: TemplateBuilderImpl,
-                declaration: JetNamedDeclaration
+                declaration: KtNamedDeclaration
         ): TypeParameterListExpression? {
             when (declaration) {
-                is JetObjectDeclaration -> return null
-                !is JetTypeParameterListOwner -> throw AssertionError("Unexpected declaration kind: ${declaration.getText()}")
+                is KtObjectDeclaration -> return null
+                !is KtTypeParameterListOwner -> throw AssertionError("Unexpected declaration kind: ${declaration.getText()}")
             }
 
-            val typeParameterList = (declaration as JetTypeParameterListOwner).getTypeParameterList() ?: return null
+            val typeParameterList = (declaration as KtTypeParameterListOwner).getTypeParameterList() ?: return null
 
             val typeParameterMap = HashMap<String, List<RenderedTypeParameter>>()
 
@@ -806,7 +806,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
             return expression
         }
 
-        private fun setupParameterTypeTemplates(builder: TemplateBuilder, parameterList: List<JetParameter>): List<TypeExpression> {
+        private fun setupParameterTypeTemplates(builder: TemplateBuilder, parameterList: List<KtParameter>): List<TypeExpression> {
             assert(parameterList.size() == callableInfo.parameterInfos.size())
 
             val typeParameters = ArrayList<TypeExpression>()
@@ -842,36 +842,36 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
             return typeParameters
         }
 
-        private fun replaceWithLongerName(typeRef: JetTypeReference, theType: JetType) {
-            val fullyQualifiedReceiverTypeRef = JetPsiFactory(typeRef).createType(theType.renderLong(typeParameterNameMap))
+        private fun replaceWithLongerName(typeRef: KtTypeReference, theType: KtType) {
+            val fullyQualifiedReceiverTypeRef = KtPsiFactory(typeRef).createType(theType.renderLong(typeParameterNameMap))
             typeRef.replace(fullyQualifiedReceiverTypeRef)
         }
 
-        private fun transformToJavaMemberIfApplicable(declaration: JetNamedDeclaration): Boolean {
+        private fun transformToJavaMemberIfApplicable(declaration: KtNamedDeclaration): Boolean {
             fun convertToJava(targetClass: PsiClass): PsiMember? {
-                val psiFactory = JetPsiFactory(declaration)
+                val psiFactory = KtPsiFactory(declaration)
 
                 psiFactory.createPackageDirectiveIfNeeded(config.currentFile.getPackageFqName())?.let {
                     declaration.getContainingFile().addBefore(it, null)
                 }
 
                 val adjustedDeclaration = when (declaration) {
-                    is JetNamedFunction, is JetProperty -> {
+                    is KtNamedFunction, is KtProperty -> {
                         val klass = psiFactory.createClass("class Foo {}")
                         klass.getBody()!!.add(declaration)
-                        (declaration.replace(klass) as JetClass).getBody()!!.getDeclarations().first()
+                        (declaration.replace(klass) as KtClass).getBody()!!.getDeclarations().first()
                     }
                     else -> declaration
                 }
 
                 return when (adjustedDeclaration) {
-                    is JetNamedFunction, is JetSecondaryConstructor -> {
-                        createJavaMethod(adjustedDeclaration as JetFunction, targetClass)
+                    is KtNamedFunction, is KtSecondaryConstructor -> {
+                        createJavaMethod(adjustedDeclaration as KtFunction, targetClass)
                     }
-                    is JetProperty -> {
+                    is KtProperty -> {
                         createJavaField(adjustedDeclaration, targetClass)
                     }
-                    is JetClass -> {
+                    is KtClass -> {
                         createJavaClass(adjustedDeclaration, targetClass)
                     }
                     else -> null
@@ -926,11 +926,11 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
             return true
         }
 
-        private fun setupEditor(declaration: JetNamedDeclaration) {
-            if (declaration is JetProperty && !declaration.hasInitializer() && containingElement is JetBlockExpression) {
+        private fun setupEditor(declaration: KtNamedDeclaration) {
+            if (declaration is KtProperty && !declaration.hasInitializer() && containingElement is KtBlockExpression) {
                 val defaultValueType = typeCandidates[callableInfo.returnTypeInfo]!!.firstOrNull()?.theType
                 val defaultValue = defaultValueType?.let { CodeInsightUtils.defaultInitializer(it) } ?: "null"
-                val initializer = declaration.setInitializer(JetPsiFactory(declaration).createExpression(defaultValue))!!
+                val initializer = declaration.setInitializer(KtPsiFactory(declaration).createExpression(defaultValue))!!
                 val range = initializer.getTextRange()
                 containingFileEditor.getSelectionModel().setSelection(range.getStartOffset(), range.getEndOffset())
                 return
@@ -954,7 +954,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
             val declaration = declarationPointer.getElement()!!
 
             val builder = TemplateBuilderImpl(jetFileToEdit)
-            if (declaration is JetProperty) {
+            if (declaration is KtProperty) {
                 setupValVarTemplate(builder, declaration)
             }
             if (!skipReturnType) {
@@ -1001,11 +1001,11 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
 
                         runWriteAction {
                             // file templates
-                            if (newDeclaration is JetNamedFunction || newDeclaration is JetSecondaryConstructor) {
-                                setupFunctionBody(newDeclaration as JetFunction)
+                            if (newDeclaration is KtNamedFunction || newDeclaration is KtSecondaryConstructor) {
+                                setupFunctionBody(newDeclaration as KtFunction)
                             }
 
-                            val callElement = config.originalElement as? JetCallElement
+                            val callElement = config.originalElement as? KtCallElement
                             if (callElement != null) {
                                 setupCallTypeArguments(callElement, expression?.currentTypeParameters ?: Collections.emptyList())
                             }
@@ -1042,10 +1042,10 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
     }
 }
 
-internal fun JetNamedDeclaration.getReturnTypeReference(): JetTypeReference? {
+internal fun KtNamedDeclaration.getReturnTypeReference(): KtTypeReference? {
     return when (this) {
-        is JetCallableDeclaration -> getTypeReference()
-        is JetClassOrObject -> getDelegationSpecifiers().firstOrNull()?.getTypeReference()
+        is KtCallableDeclaration -> getTypeReference()
+        is KtClassOrObject -> getDelegationSpecifiers().firstOrNull()?.getTypeReference()
         else -> throw AssertionError("Unexpected declaration kind: ${getText()}")
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableInfo.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableInfo.kt
index 4298ac2124d..2b093271730 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableInfo.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableInfo.kt
@@ -21,12 +21,12 @@ import com.intellij.util.ArrayUtil
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.ClassInfo
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetTypeReference
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtTypeReference
 import org.jetbrains.kotlin.resolve.BindingContext
 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 org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import org.jetbrains.kotlin.types.typeUtil.supertypes
@@ -37,15 +37,15 @@ import java.util.*
  */
 abstract class TypeInfo(val variance: Variance) {
     object Empty: TypeInfo(Variance.INVARIANT) {
-        override fun getPossibleTypes(builder: CallableBuilder): List<JetType> = Collections.emptyList()
+        override fun getPossibleTypes(builder: CallableBuilder): List<KtType> = Collections.emptyList()
     }
 
-    class ByExpression(val expression: JetExpression, variance: Variance): TypeInfo(variance) {
+    class ByExpression(val expression: KtExpression, variance: Variance): TypeInfo(variance) {
         override val possibleNamesFromExpression: Array<String> by lazy {
             KotlinNameSuggester.suggestNamesByExpressionOnly(expression, { true }).toTypedArray()
         }
 
-        override fun getPossibleTypes(builder: CallableBuilder): List<JetType> =
+        override fun getPossibleTypes(builder: CallableBuilder): List<KtType> =
                 expression.guessTypes(
                         context = builder.currentFileContext,
                         module = builder.currentFileModule,
@@ -53,25 +53,25 @@ abstract class TypeInfo(val variance: Variance) {
                 ).flatMap { it.getPossibleSupertypes(variance, builder) }
     }
 
-    class ByTypeReference(val typeReference: JetTypeReference, variance: Variance): TypeInfo(variance) {
-        override fun getPossibleTypes(builder: CallableBuilder): List<JetType> =
+    class ByTypeReference(val typeReference: KtTypeReference, variance: Variance): TypeInfo(variance) {
+        override fun getPossibleTypes(builder: CallableBuilder): List<KtType> =
                 builder.currentFileContext[BindingContext.TYPE, typeReference].getPossibleSupertypes(variance, builder)
     }
 
-    class ByType(val theType: JetType, variance: Variance): TypeInfo(variance) {
-        override fun getPossibleTypes(builder: CallableBuilder): List<JetType> =
+    class ByType(val theType: KtType, variance: Variance): TypeInfo(variance) {
+        override fun getPossibleTypes(builder: CallableBuilder): List<KtType> =
                 theType.getPossibleSupertypes(variance, builder)
     }
 
     class ByReceiverType(variance: Variance): TypeInfo(variance) {
-        override fun getPossibleTypes(builder: CallableBuilder): List<JetType> =
+        override fun getPossibleTypes(builder: CallableBuilder): List<KtType> =
                 (builder.placement as CallablePlacement.WithReceiver).receiverTypeCandidate.theType.getPossibleSupertypes(variance, builder)
     }
 
     abstract class DelegatingTypeInfo(val delegate: TypeInfo): TypeInfo(delegate.variance) {
         override val substitutionsAllowed: Boolean = delegate.substitutionsAllowed
         override val possibleNamesFromExpression: Array<String> get() = delegate.possibleNamesFromExpression
-        override fun getPossibleTypes(builder: CallableBuilder): List<JetType> = delegate.getPossibleTypes(builder)
+        override fun getPossibleTypes(builder: CallableBuilder): List<KtType> = delegate.getPossibleTypes(builder)
     }
 
     class NoSubstitutions(delegate: TypeInfo): DelegatingTypeInfo(delegate) {
@@ -85,9 +85,9 @@ abstract class TypeInfo(val variance: Variance) {
     open val substitutionsAllowed: Boolean = true
     open val staticContextRequired: Boolean = false
     open val possibleNamesFromExpression: Array<String> get() = ArrayUtil.EMPTY_STRING_ARRAY
-    abstract fun getPossibleTypes(builder: CallableBuilder): List<JetType>
+    abstract fun getPossibleTypes(builder: CallableBuilder): List<KtType>
 
-    protected fun JetType?.getPossibleSupertypes(variance: Variance, callableBuilder: CallableBuilder): List<JetType> {
+    protected fun KtType?.getPossibleSupertypes(variance: Variance, callableBuilder: CallableBuilder): List<KtType> {
         if (this == null || ErrorUtils.containsErrorType(this)) {
             return Collections.singletonList(callableBuilder.currentFileModule.builtIns.anyType)
         }
@@ -99,15 +99,15 @@ abstract class TypeInfo(val variance: Variance) {
     }
 }
 
-fun TypeInfo(expressionOfType: JetExpression, variance: Variance): TypeInfo = TypeInfo.ByExpression(expressionOfType, variance)
-fun TypeInfo(typeReference: JetTypeReference, variance: Variance): TypeInfo = TypeInfo.ByTypeReference(typeReference, variance)
-fun TypeInfo(theType: JetType, variance: Variance): TypeInfo = TypeInfo.ByType(theType, variance)
+fun TypeInfo(expressionOfType: KtExpression, variance: Variance): TypeInfo = TypeInfo.ByExpression(expressionOfType, variance)
+fun TypeInfo(typeReference: KtTypeReference, variance: Variance): TypeInfo = TypeInfo.ByTypeReference(typeReference, variance)
+fun TypeInfo(theType: KtType, variance: Variance): TypeInfo = TypeInfo.ByType(theType, variance)
 
 fun TypeInfo.noSubstitutions(): TypeInfo = (this as? TypeInfo.NoSubstitutions) ?: TypeInfo.NoSubstitutions(this)
 
 fun TypeInfo.forceNotNull(): TypeInfo {
     class ForcedNotNull(delegate: TypeInfo): TypeInfo.DelegatingTypeInfo(delegate) {
-        override fun getPossibleTypes(builder: CallableBuilder): List<JetType> =
+        override fun getPossibleTypes(builder: CallableBuilder): List<KtType> =
                 super.getPossibleTypes(builder).map { it.makeNotNullable() }
     }
 
@@ -133,7 +133,7 @@ abstract class CallableInfo (
         val name: String,
         val receiverTypeInfo: TypeInfo,
         val returnTypeInfo: TypeInfo,
-        val possibleContainers: List<JetElement>,
+        val possibleContainers: List<KtElement>,
         val typeParameterInfos: List<TypeInfo>
 ) {
     abstract val kind: CallableKind
@@ -143,7 +143,7 @@ abstract class CallableInfo (
 class FunctionInfo(name: String,
                    receiverTypeInfo: TypeInfo,
                    returnTypeInfo: TypeInfo,
-                   possibleContainers: List<JetElement> = Collections.emptyList(),
+                   possibleContainers: List<KtElement> = Collections.emptyList(),
                    override val parameterInfos: List<ParameterInfo> = Collections.emptyList(),
                    typeParameterInfos: List<TypeInfo> = Collections.emptyList(),
                    val isOperator: Boolean = false
@@ -169,7 +169,7 @@ class PropertyInfo(name: String,
                    receiverTypeInfo: TypeInfo,
                    returnTypeInfo: TypeInfo,
                    val writable: Boolean,
-                   possibleContainers: List<JetElement> = Collections.emptyList(),
+                   possibleContainers: List<KtElement> = Collections.emptyList(),
                    typeParameterInfos: List<TypeInfo> = Collections.emptyList()
 ) : CallableInfo(name, receiverTypeInfo, returnTypeInfo, possibleContainers, typeParameterInfos) {
     override val kind: CallableKind get() = CallableKind.PROPERTY
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/generationUtils.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/generationUtils.kt
index 6b311b94e44..e4535c0b01b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/generationUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/generationUtils.kt
@@ -25,11 +25,11 @@ import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.siblings
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
-public fun setupEditorSelection(editor: Editor, declaration: JetNamedDeclaration) {
+public fun setupEditorSelection(editor: Editor, declaration: KtNamedDeclaration) {
     val caretModel = editor.caretModel
     val selectionModel = editor.selectionModel
 
-    if (declaration is JetSecondaryConstructor) {
+    if (declaration is KtSecondaryConstructor) {
         caretModel.moveToOffset(declaration.getConstructorKeyword().endOffset)
     }
     else {
@@ -46,15 +46,15 @@ public fun setupEditorSelection(editor: Editor, declaration: JetNamedDeclaration
     }
 
     when (declaration) {
-        is JetNamedFunction, is JetSecondaryConstructor -> {
-            ((declaration as JetFunction).bodyExpression as? JetBlockExpression)?.let {
+        is KtNamedFunction, is KtSecondaryConstructor -> {
+            ((declaration as KtFunction).bodyExpression as? KtBlockExpression)?.let {
                 positionBetween(it.lBrace!!, it.rBrace!!)
             }
         }
-        is JetClassOrObject -> {
+        is KtClassOrObject -> {
             caretModel.moveToOffset(declaration.startOffset)
         }
-        is JetProperty -> {
+        is KtProperty -> {
             caretModel.moveToOffset(declaration.endOffset)
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/templateExpressions.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/templateExpressions.kt
index 3c904923fd2..399380e33fb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/templateExpressions.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/templateExpressions.kt
@@ -62,17 +62,17 @@ internal class ParameterNameExpression(
         val offset = context.getStartOffset()
         PsiDocumentManager.getInstance(project).commitAllDocuments()
         val editor = context.getEditor()!!
-        val file = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument()) as JetFile
+        val file = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument()) as KtFile
         val elementAt = file.findElementAt(offset)
-        val declaration = PsiTreeUtil.getParentOfType(elementAt, javaClass<JetFunction>(), javaClass<JetClass>()) ?: return arrayOf()
+        val declaration = PsiTreeUtil.getParentOfType(elementAt, javaClass<KtFunction>(), javaClass<KtClass>()) ?: return arrayOf()
         val parameterList = when (declaration) {
-            is JetFunction -> declaration.getValueParameterList()!!
-            is JetClass -> declaration.getPrimaryConstructorParameterList()!!
+            is KtFunction -> declaration.getValueParameterList()!!
+            is KtClass -> declaration.getPrimaryConstructorParameterList()!!
             else -> throw AssertionError("Unexpected declaration: ${declaration.getText()}")
         }
 
         // add names based on selected type
-        val parameter = elementAt?.getStrictParentOfType<JetParameter>()
+        val parameter = elementAt?.getStrictParentOfType<KtParameter>()
         if (parameter != null) {
             val parameterTypeRef = parameter.getTypeReference()
             if (parameterTypeRef != null) {
@@ -147,9 +147,9 @@ internal class TypeParameterListExpression(private val mandatoryTypeParameters:
 
         PsiDocumentManager.getInstance(project).commitAllDocuments()
         val editor = context.getEditor()!!
-        val file = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument()) as JetFile
+        val file = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument()) as KtFile
         val elementAt = file.findElementAt(offset)
-        val declaration = elementAt?.getStrictParentOfType<JetNamedDeclaration>() ?: return TextResult("")
+        val declaration = elementAt?.getStrictParentOfType<KtNamedDeclaration>() ?: return TextResult("")
 
         val renderedTypeParameters = LinkedHashSet<RenderedTypeParameter>()
         renderedTypeParameters.addAll(mandatoryTypeParameters)
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt
index a2867a5860a..c90c2e66b8a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.idea.project.platform
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.FqName
@@ -34,17 +34,17 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.bindingContextUtil.isUsedAsStatement
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
 import org.jetbrains.kotlin.resolve.descriptorUtil.resolveTopLevelClass
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import java.util.*
 
-internal fun JetType.contains(inner: JetType): Boolean {
-    return JetTypeChecker.DEFAULT.equalTypes(this, inner) || getArguments().any { inner in it.getType() }
+internal fun KtType.contains(inner: KtType): Boolean {
+    return KotlinTypeChecker.DEFAULT.equalTypes(this, inner) || getArguments().any { inner in it.getType() }
 }
 
-private fun JetType.render(typeParameterNameMap: Map<TypeParameterDescriptor, String>, fq: Boolean): String {
+private fun KtType.render(typeParameterNameMap: Map<TypeParameterDescriptor, String>, fq: Boolean): String {
     val substitution = typeParameterNameMap
             .mapValues {
                 val name = Name.identifier(it.value)
@@ -63,7 +63,7 @@ private fun JetType.render(typeParameterNameMap: Map<TypeParameterDescriptor, St
                     override fun getDeclarationDescriptor() = wrappingTypeParameter
                 }
 
-                val wrappingType = object : JetType by typeParameter.defaultType {
+                val wrappingType = object : KtType by typeParameter.defaultType {
                     override fun getConstructor() = wrappingTypeConstructor
                 }
 
@@ -76,23 +76,23 @@ private fun JetType.render(typeParameterNameMap: Map<TypeParameterDescriptor, St
     return renderer.renderType(typeToRender)
 }
 
-internal fun JetType.renderShort(typeParameterNameMap: Map<TypeParameterDescriptor, String>) = render(typeParameterNameMap, false)
-internal fun JetType.renderLong(typeParameterNameMap: Map<TypeParameterDescriptor, String>) = render(typeParameterNameMap, true)
+internal fun KtType.renderShort(typeParameterNameMap: Map<TypeParameterDescriptor, String>) = render(typeParameterNameMap, false)
+internal fun KtType.renderLong(typeParameterNameMap: Map<TypeParameterDescriptor, String>) = render(typeParameterNameMap, true)
 
-internal fun getTypeParameterNamesNotInScope(typeParameters: Collection<TypeParameterDescriptor>, scope: JetScope): List<TypeParameterDescriptor> {
+internal fun getTypeParameterNamesNotInScope(typeParameters: Collection<TypeParameterDescriptor>, scope: KtScope): List<TypeParameterDescriptor> {
     return typeParameters.filter { typeParameter ->
         val classifier = scope.getClassifier(typeParameter.name, NoLookupLocation.FROM_IDE)
         classifier == null || classifier != typeParameter
     }
 }
 
-fun JetType.containsStarProjections(): Boolean = arguments.any { it.isStarProjection || it.type.containsStarProjections() }
+fun KtType.containsStarProjections(): Boolean = arguments.any { it.isStarProjection || it.type.containsStarProjections() }
 
-fun JetType.getTypeParameters(): Set<TypeParameterDescriptor> {
-    val visitedTypes = HashSet<JetType>()
+fun KtType.getTypeParameters(): Set<TypeParameterDescriptor> {
+    val visitedTypes = HashSet<KtType>()
     val typeParameters = LinkedHashSet<TypeParameterDescriptor>()
 
-    fun traverseTypes(type: JetType) {
+    fun traverseTypes(type: KtType) {
         if (!visitedTypes.add(type)) return
 
         val arguments = type.arguments
@@ -111,16 +111,16 @@ fun JetType.getTypeParameters(): Set<TypeParameterDescriptor> {
     return typeParameters
 }
 
-fun JetExpression.guessTypes(
+fun KtExpression.guessTypes(
         context: BindingContext,
         module: ModuleDescriptor,
         pseudocode: Pseudocode? = null,
         coerceUnusedToUnit: Boolean = true
-): Array<JetType> {
+): Array<KtType> {
     if (coerceUnusedToUnit
-        && this !is JetDeclaration
+        && this !is KtDeclaration
         && isUsedAsStatement(context)
-        && getNonStrictParentOfType<JetAnnotationEntry>() == null) return arrayOf(module.builtIns.getUnitType())
+        && getNonStrictParentOfType<KtAnnotationEntry>() == null) return arrayOf(module.builtIns.getUnitType())
 
     // if we know the actual type of the expression
     val theType1 = context.getType(this)
@@ -136,17 +136,17 @@ fun JetExpression.guessTypes(
 
     val parent = getParent()
     return when {
-        this is JetTypeConstraint -> {
+        this is KtTypeConstraint -> {
             // expression itself is a type assertion
             val constraint = this
             arrayOf(context[BindingContext.TYPE, constraint.getBoundTypeReference()]!!)
         }
-        parent is JetTypeConstraint -> {
+        parent is KtTypeConstraint -> {
             // expression is on the left side of a type assertion
             val constraint = parent
             arrayOf(context[BindingContext.TYPE, constraint.getBoundTypeReference()]!!)
         }
-        this is JetMultiDeclarationEntry -> {
+        this is KtMultiDeclarationEntry -> {
             // expression is on the lhs of a multi-declaration
             val typeRef = getTypeReference()
             if (typeRef != null) {
@@ -158,7 +158,7 @@ fun JetExpression.guessTypes(
                 guessType(context)
             }
         }
-        this is JetParameter -> {
+        this is KtParameter -> {
             // expression is a parameter (e.g. declared in a for-loop)
             val typeRef = getTypeReference()
             if (typeRef != null) {
@@ -170,7 +170,7 @@ fun JetExpression.guessTypes(
                 guessType(context)
             }
         }
-        parent is JetProperty && parent.isLocal() -> {
+        parent is KtProperty && parent.isLocal() -> {
             // the expression is the RHS of a variable assignment with a specified type
             val variable = parent
             val typeRef = variable.getTypeReference()
@@ -183,8 +183,8 @@ fun JetExpression.guessTypes(
                 variable.guessType(context)
             }
         }
-        parent is JetPropertyDelegate -> {
-            val variableDescriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, parent.getParent() as JetProperty] as VariableDescriptor
+        parent is KtPropertyDelegate -> {
+            val variableDescriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, parent.getParent() as KtProperty] as VariableDescriptor
             val delegateClassName = if (variableDescriptor.isVar()) "ReadWriteProperty" else "ReadOnlyProperty"
             val delegateClass = module.resolveTopLevelClass(FqName("kotlin.properties.$delegateClassName"), NoLookupLocation.FROM_IDE)
                                 ?: return arrayOf(module.builtIns.getAnyType())
@@ -193,7 +193,7 @@ fun JetExpression.guessTypes(
             val typeArguments = listOf(TypeProjectionImpl(receiverType), TypeProjectionImpl(variableDescriptor.getType()))
             arrayOf(TypeUtils.substituteProjectionsForParameters(delegateClass, typeArguments))
         }
-        parent is JetStringTemplateEntryWithExpression && parent.getExpression() == this -> {
+        parent is KtStringTemplateEntryWithExpression && parent.getExpression() == this -> {
             arrayOf(module.builtIns.getStringType())
         }
         else -> {
@@ -204,20 +204,20 @@ fun JetExpression.guessTypes(
     }
 }
 
-private fun JetNamedDeclaration.guessType(context: BindingContext): Array<JetType> {
+private fun KtNamedDeclaration.guessType(context: BindingContext): Array<KtType> {
     val expectedTypes = SearchUtils.findAllReferences(this, getUseScope())!!.asSequence().map { ref ->
-        if (ref is JetSimpleNameReference) {
+        if (ref is KtSimpleNameReference) {
             context[BindingContext.EXPECTED_EXPRESSION_TYPE, ref.expression]
         }
         else {
             null
         }
-    }.filterNotNullTo(HashSet<JetType>())
+    }.filterNotNullTo(HashSet<KtType>())
 
     if (expectedTypes.isEmpty() || expectedTypes.any { expectedType -> ErrorUtils.containsErrorType(expectedType) }) {
         return arrayOf()
     }
-    val theType = TypeIntersector.intersectTypes(JetTypeChecker.DEFAULT, expectedTypes)
+    val theType = TypeIntersector.intersectTypes(KotlinTypeChecker.DEFAULT, expectedTypes)
     if (theType != null) {
         return arrayOf(theType)
     }
@@ -228,18 +228,18 @@ private fun JetNamedDeclaration.guessType(context: BindingContext): Array<JetTyp
 }
 
 /**
- * Encapsulates a single type substitution of a <code>JetType</code> by another <code>JetType</code>.
+ * Encapsulates a single type substitution of a <code>KtType</code> by another <code>KtType</code>.
  */
-internal class JetTypeSubstitution(public val forType: JetType, public val byType: JetType)
+internal class JetTypeSubstitution(public val forType: KtType, public val byType: KtType)
 
-internal fun JetType.substitute(substitution: JetTypeSubstitution, variance: Variance): JetType {
+internal fun KtType.substitute(substitution: JetTypeSubstitution, variance: Variance): KtType {
     val nullable = isMarkedNullable()
     val currentType = makeNotNullable()
 
     if (when (variance) {
-        Variance.INVARIANT      -> JetTypeChecker.DEFAULT.equalTypes(currentType, substitution.forType)
-        Variance.IN_VARIANCE    -> JetTypeChecker.DEFAULT.isSubtypeOf(currentType, substitution.forType)
-        Variance.OUT_VARIANCE   -> JetTypeChecker.DEFAULT.isSubtypeOf(substitution.forType, currentType)
+        Variance.INVARIANT      -> KotlinTypeChecker.DEFAULT.equalTypes(currentType, substitution.forType)
+        Variance.IN_VARIANCE    -> KotlinTypeChecker.DEFAULT.isSubtypeOf(currentType, substitution.forType)
+        Variance.OUT_VARIANCE   -> KotlinTypeChecker.DEFAULT.isSubtypeOf(substitution.forType, currentType)
     }) {
         return TypeUtils.makeNullableAsSpecified(substitution.byType, nullable)
     }
@@ -248,17 +248,17 @@ internal fun JetType.substitute(substitution: JetTypeSubstitution, variance: Var
             val (projection, typeParameter) = pair
             TypeProjectionImpl(Variance.INVARIANT, projection.getType().substitute(substitution, typeParameter.getVariance()))
         }
-        return JetTypeImpl.create(getAnnotations(), getConstructor(), isMarkedNullable(), newArguments, getMemberScope())
+        return KtTypeImpl.create(getAnnotations(), getConstructor(), isMarkedNullable(), newArguments, getMemberScope())
     }
 }
 
-fun JetExpression.getExpressionForTypeGuess() = getAssignmentByLHS()?.getRight() ?: this
+fun KtExpression.getExpressionForTypeGuess() = getAssignmentByLHS()?.getRight() ?: this
 
-fun JetCallElement.getTypeInfoForTypeArguments(): List<TypeInfo> {
+fun KtCallElement.getTypeInfoForTypeArguments(): List<TypeInfo> {
     return getTypeArguments().map { it.getTypeReference()?.let { TypeInfo(it, Variance.INVARIANT) } }.filterNotNull()
 }
 
-fun JetCallExpression.getParameterInfos(): List<ParameterInfo> {
+fun KtCallExpression.getParameterInfos(): List<ParameterInfo> {
     val anyType = this.platform.builtIns.nullableAnyType
     return valueArguments.map {
         ParameterInfo(
@@ -268,7 +268,7 @@ fun JetCallExpression.getParameterInfos(): List<ParameterInfo> {
     }
 }
 
-private fun TypePredicate.getRepresentativeTypes(): Set<JetType> {
+private fun TypePredicate.getRepresentativeTypes(): Set<KtType> {
     return when (this) {
         is SingleType -> Collections.singleton(targetType)
         is AllSubtypes -> Collections.singleton(upperBound)
@@ -276,7 +276,7 @@ private fun TypePredicate.getRepresentativeTypes(): Set<JetType> {
             if (typeSets.isEmpty()) AllTypes.getRepresentativeTypes()
             else typeSets.map { it.getRepresentativeTypes() }.reduce { a, b -> a intersect b }
         }
-        is ForSomeType -> typeSets.flatMapTo(LinkedHashSet<JetType>()) { it.getRepresentativeTypes() }
+        is ForSomeType -> typeSets.flatMapTo(LinkedHashSet<KtType>()) { it.getRepresentativeTypes() }
         is AllTypes -> emptySet()
         else -> throw AssertionError("Invalid type predicate: ${this}")
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateBinaryOperationActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateBinaryOperationActionFactory.kt
index 4979e98da12..7a5e440e11e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateBinaryOperationActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateBinaryOperationActionFactory.kt
@@ -19,22 +19,22 @@ package org.jetbrains.kotlin.idea.quickfix.createFromUsage.createCallable
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.project.platform
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
-import org.jetbrains.kotlin.lexer.JetToken
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetBinaryExpression
+import org.jetbrains.kotlin.lexer.KtToken
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtBinaryExpression
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import java.util.*
 
-public object CreateBinaryOperationActionFactory: CreateCallableMemberFromUsageFactory<JetBinaryExpression>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetBinaryExpression? {
-        return diagnostic.psiElement.parent as? JetBinaryExpression
+public object CreateBinaryOperationActionFactory: CreateCallableMemberFromUsageFactory<KtBinaryExpression>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtBinaryExpression? {
+        return diagnostic.psiElement.parent as? KtBinaryExpression
     }
 
-    override fun createCallableInfo(element: JetBinaryExpression, diagnostic: Diagnostic): CallableInfo? {
-        val token = element.operationToken as JetToken
+    override fun createCallableInfo(element: KtBinaryExpression, diagnostic: Diagnostic): CallableInfo? {
+        val token = element.operationToken as KtToken
         val operationName = when (token) {
-                                JetTokens.IDENTIFIER -> element.operationReference.getReferencedName()
+                                KtTokens.IDENTIFIER -> element.operationReference.getReferencedName()
                                 else -> OperatorConventions.getNameForOperationSymbol(token, false, true)?.asString()
                             } ?: return null
         val inOperation = token in OperatorConventions.IN_OPERATIONS
@@ -55,6 +55,6 @@ public object CreateBinaryOperationActionFactory: CreateCallableMemberFromUsageF
         }
         val parameters = Collections.singletonList(ParameterInfo(TypeInfo(argumentExpr, Variance.IN_VARIANCE)))
         return FunctionInfo(operationName, receiverType, returnType, parameterInfos = parameters,
-                            isOperator = token != JetTokens.IDENTIFIER)
+                            isOperator = token != KtTokens.IDENTIFIER)
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromCallActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromCallActionFactory.kt
index 190642a77d9..51bbc58c353 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromCallActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromCallActionFactory.kt
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.core.refactoring.getExtractionContainers
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getAssignmentByLHS
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
 import java.util.*
 
-sealed class CreateCallableFromCallActionFactory<E : JetExpression>(
+sealed class CreateCallableFromCallActionFactory<E : KtExpression>(
         extensionsEnabled: Boolean = true
 ) : CreateCallableMemberFromUsageFactory<E>(extensionsEnabled) {
     protected abstract fun doCreateCallableInfo(
@@ -53,39 +53,39 @@ sealed class CreateCallableFromCallActionFactory<E : JetExpression>(
             context: BindingContext,
             name: String,
             receiverType: TypeInfo,
-            possibleContainers: List<JetElement>
+            possibleContainers: List<KtElement>
     ): CallableInfo?
 
-    protected fun getExpressionOfInterest(diagnostic: Diagnostic): JetExpression? {
+    protected fun getExpressionOfInterest(diagnostic: Diagnostic): KtExpression? {
         val diagElement = diagnostic.psiElement
         if (PsiTreeUtil.getParentOfType(
                 diagElement,
-                javaClass<JetTypeReference>(), javaClass<JetAnnotationEntry>(), javaClass<JetImportDirective>()
+                javaClass<KtTypeReference>(), javaClass<KtAnnotationEntry>(), javaClass<KtImportDirective>()
         ) != null) return null
 
         return when (diagnostic.factory) {
             in Errors.UNRESOLVED_REFERENCE_DIAGNOSTICS, Errors.EXPRESSION_EXPECTED_PACKAGE_FOUND -> {
                 val parent = diagElement.parent
-                if (parent is JetCallExpression && parent.calleeExpression == diagElement) parent else diagElement
+                if (parent is KtCallExpression && parent.calleeExpression == diagElement) parent else diagElement
             }
 
             Errors.NO_VALUE_FOR_PARAMETER,
-            Errors.TOO_MANY_ARGUMENTS -> diagElement.getNonStrictParentOfType<JetCallExpression>()
+            Errors.TOO_MANY_ARGUMENTS -> diagElement.getNonStrictParentOfType<KtCallExpression>()
 
             else -> throw AssertionError("Unexpected diagnostic: ${diagnostic.factory}")
-        } as? JetExpression
+        } as? KtExpression
     }
 
     override fun createCallableInfo(element: E, diagnostic: Diagnostic): CallableInfo? {
         val project = element.project
 
         val calleeExpr = when (element) {
-                             is JetCallExpression -> element.calleeExpression
-                             is JetSimpleNameExpression -> element
+                             is KtCallExpression -> element.calleeExpression
+                             is KtSimpleNameExpression -> element
                              else -> null
-                         } as? JetSimpleNameExpression ?: return null
+                         } as? KtSimpleNameExpression ?: return null
 
-        if (calleeExpr.getReferencedNameElementType() != JetTokens.IDENTIFIER) return null
+        if (calleeExpr.getReferencedNameElementType() != KtTokens.IDENTIFIER) return null
 
         val context = calleeExpr.analyze()
         val receiver = element.getCall(context)?.explicitReceiver ?: ReceiverValue.NO_RECEIVER
@@ -94,7 +94,7 @@ sealed class CreateCallableFromCallActionFactory<E : JetExpression>(
         val possibleContainers =
                 if (receiverType is TypeInfo.Empty) {
                     val containers = with(element.getQualifiedExpressionForSelectorOrThis().getExtractionContainers()) {
-                        if (element is JetCallExpression) this else filter { it is JetClassBody || it is JetFile }
+                        if (element is KtCallExpression) this else filter { it is KtClassBody || it is KtFile }
                     }
                     if (containers.isNotEmpty()) containers else return null
                 }
@@ -119,17 +119,17 @@ sealed class CreateCallableFromCallActionFactory<E : JetExpression>(
         }
     }
 
-    object Property: CreateCallableFromCallActionFactory<JetSimpleNameExpression>() {
-        override fun getElementOfInterest(diagnostic: Diagnostic): JetSimpleNameExpression? {
-            return getExpressionOfInterest(diagnostic) as? JetSimpleNameExpression
+    object Property: CreateCallableFromCallActionFactory<KtSimpleNameExpression>() {
+        override fun getElementOfInterest(diagnostic: Diagnostic): KtSimpleNameExpression? {
+            return getExpressionOfInterest(diagnostic) as? KtSimpleNameExpression
         }
 
         override fun doCreateCallableInfo(
-                expression: JetSimpleNameExpression,
+                expression: KtSimpleNameExpression,
                 context: BindingContext,
                 name: String,
                 receiverType: TypeInfo,
-                possibleContainers: List<JetElement>
+                possibleContainers: List<KtElement>
         ): CallableInfo? {
             val fullCallExpr = expression.getQualifiedExpressionForSelectorOrThis()
             val varExpected = fullCallExpr.getAssignmentByLHS() != null
@@ -141,17 +141,17 @@ sealed class CreateCallableFromCallActionFactory<E : JetExpression>(
         }
     }
 
-    object Function: CreateCallableFromCallActionFactory<JetCallExpression>() {
-        override fun getElementOfInterest(diagnostic: Diagnostic): JetCallExpression? {
-            return getExpressionOfInterest(diagnostic) as? JetCallExpression
+    object Function: CreateCallableFromCallActionFactory<KtCallExpression>() {
+        override fun getElementOfInterest(diagnostic: Diagnostic): KtCallExpression? {
+            return getExpressionOfInterest(diagnostic) as? KtCallExpression
         }
 
         override fun doCreateCallableInfo(
-                expression: JetCallExpression,
+                expression: KtCallExpression,
                 context: BindingContext,
                 name: String,
                 receiverType: TypeInfo,
-                possibleContainers: List<JetElement>
+                possibleContainers: List<KtElement>
         ): CallableInfo? {
             val parameters = expression.getParameterInfos()
             val typeParameters = expression.getTypeInfoForTypeArguments()
@@ -160,24 +160,24 @@ sealed class CreateCallableFromCallActionFactory<E : JetExpression>(
         }
     }
 
-    object Constructor: CreateCallableFromCallActionFactory<JetCallExpression>() {
-        override fun getElementOfInterest(diagnostic: Diagnostic): JetCallExpression? {
-            return getExpressionOfInterest(diagnostic) as? JetCallExpression
+    object Constructor: CreateCallableFromCallActionFactory<KtCallExpression>() {
+        override fun getElementOfInterest(diagnostic: Diagnostic): KtCallExpression? {
+            return getExpressionOfInterest(diagnostic) as? KtCallExpression
         }
 
         override fun doCreateCallableInfo(
-                expression: JetCallExpression,
+                expression: KtCallExpression,
                 context: BindingContext,
                 name: String,
                 receiverType: TypeInfo,
-                possibleContainers: List<JetElement>
+                possibleContainers: List<KtElement>
         ): CallableInfo? {
             if (expression.typeArguments.isNotEmpty()) return null
 
             val constructorDescriptor = expression.getResolvedCall(context)?.resultingDescriptor as? ConstructorDescriptor
             val classDescriptor = constructorDescriptor?.containingDeclaration as? ClassDescriptor
             val klass = classDescriptor?.source?.getPsi()
-            if ((klass !is JetClass && klass !is PsiClass) || !klass.canRefactor()) return null
+            if ((klass !is KtClass && klass !is PsiClass) || !klass.canRefactor()) return null
 
             val expectedType = context[BindingContext.EXPECTED_EXPRESSION_TYPE, expression.getQualifiedExpressionForSelectorOrThis()]
                                ?: classDescriptor!!.builtIns.nullableAnyType
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt
index f8fcb38e2b1..b102816a1ff 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt
@@ -35,17 +35,17 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import java.util.HashSet
 
-public class CreateCallableFromUsageFix<E : JetElement>(
+public class CreateCallableFromUsageFix<E : KtElement>(
         originalExpression: E,
         callableInfos: List<CallableInfo>
 ) : CreateCallableFromUsageFixBase<E>(originalExpression, callableInfos, false)
 
-public class CreateExtensionCallableFromUsageFix<E : JetElement>(
+public class CreateExtensionCallableFromUsageFix<E : KtElement>(
         originalExpression: E,
         callableInfos: List<CallableInfo>
 ) : CreateCallableFromUsageFixBase<E>(originalExpression, callableInfos, true), LowPriorityAction
 
-public abstract class CreateCallableFromUsageFixBase<E : JetElement>(
+public abstract class CreateCallableFromUsageFixBase<E : KtElement>(
         originalExpression: E,
         val callableInfos: List<CallableInfo>,
         val isExtension: Boolean
@@ -56,14 +56,14 @@ public abstract class CreateCallableFromUsageFixBase<E : JetElement>(
             val receiverSet = callableInfos.mapTo(HashSet<TypeInfo>()) { it.receiverTypeInfo }
             if (receiverSet.size() > 1) throw AssertionError("All functions must have common receiver: $receiverSet")
 
-            val possibleContainerSet = callableInfos.mapTo(HashSet<List<JetElement>>()) { it.possibleContainers }
+            val possibleContainerSet = callableInfos.mapTo(HashSet<List<KtElement>>()) { it.possibleContainers }
             if (possibleContainerSet.size() > 1) throw AssertionError("All functions must have common containers: $possibleContainerSet")
         }
     }
 
     private fun getDeclaration(descriptor: ClassifierDescriptor, project: Project): PsiElement? {
         if (descriptor is FunctionClassDescriptor) {
-            val psiFactory = JetPsiFactory(project)
+            val psiFactory = KtPsiFactory(project)
             val syntheticClass = psiFactory.createClass(IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.render(descriptor))
             return psiFactory.createAnalyzableFile("${descriptor.name.asString()}.kt", "", element).add(syntheticClass)
         }
@@ -73,7 +73,7 @@ public abstract class CreateCallableFromUsageFixBase<E : JetElement>(
     private fun getDeclarationIfApplicable(project: Project, candidate: TypeCandidate): PsiElement? {
         val descriptor = candidate.theType.constructor.declarationDescriptor ?: return null
         val declaration = getDeclaration(descriptor, project) ?: return null
-        if (declaration !is JetClassOrObject && declaration !is PsiClass) return null
+        if (declaration !is KtClassOrObject && declaration !is PsiClass) return null
         return if (isExtension || declaration.canRefactor()) declaration else null
     }
 
@@ -105,7 +105,7 @@ public abstract class CreateCallableFromUsageFixBase<E : JetElement>(
 
     override fun isAvailable(project: Project, editor: Editor?, file: PsiFile): Boolean {
         if (!super.isAvailable(project, editor, file)) return false
-        if (file !is JetFile) return false
+        if (file !is KtFile) return false
 
         val receiverInfo = callableInfos.first().receiverTypeInfo
 
@@ -131,11 +131,11 @@ public abstract class CreateCallableFromUsageFixBase<E : JetElement>(
         }
     }
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         val callableInfo = callableInfos.first()
 
         val callableBuilder =
-                CallableBuilderConfiguration(callableInfos, element as JetElement, file, editor!!, isExtension).createBuilder()
+                CallableBuilderConfiguration(callableInfos, element as KtElement, file, editor!!, isExtension).createBuilder()
 
         fun runBuilder(placement: CallablePlacement) {
             callableBuilder.placement = placement
@@ -164,7 +164,7 @@ public abstract class CreateCallableFromUsageFixBase<E : JetElement>(
             }
 
             chooseContainerElementIfNecessary(callableInfo.possibleContainers, editor, popupTitle, true, { it }) {
-                val container = if (it is JetClassBody) it.parent as JetClassOrObject else it
+                val container = if (it is KtClassBody) it.parent as KtClassOrObject else it
                 runBuilder(CallablePlacement.NoReceiver(container))
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableMemberFromUsageFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableMemberFromUsageFactory.kt
index 5258d1fc80b..353b030f851 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableMemberFromUsageFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableMemberFromUsageFactory.kt
@@ -22,10 +22,10 @@ import org.jetbrains.kotlin.idea.quickfix.KotlinIntentionActionFactoryWithDelega
 import org.jetbrains.kotlin.idea.quickfix.LowPriorityQuickFixWithDelegateFactory
 import org.jetbrains.kotlin.idea.quickfix.QuickFixWithDelegateFactory
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.CallableInfo
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
 
-public abstract class CreateCallableMemberFromUsageFactory<E : JetElement>(
+public abstract class CreateCallableMemberFromUsageFactory<E : KtElement>(
         val extensionsSupported: Boolean = true
 ) : KotlinIntentionActionFactoryWithDelegate<E, List<CallableInfo>>() {
     private fun newCallableQuickFix(
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateComponentFunctionActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateComponentFunctionActionFactory.kt
index 61934c89fb8..30a3140c7d8 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateComponentFunctionActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateComponentFunctionActionFactory.kt
@@ -22,19 +22,19 @@ import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.CallableInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
-import org.jetbrains.kotlin.psi.JetForExpression
-import org.jetbrains.kotlin.psi.JetMultiDeclaration
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtMultiDeclaration
 import org.jetbrains.kotlin.resolve.dataClassUtils.getComponentIndex
 import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike
 import org.jetbrains.kotlin.types.Variance
 
-object CreateComponentFunctionActionFactory : CreateCallableMemberFromUsageFactory<JetMultiDeclaration>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetMultiDeclaration? {
-        QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetMultiDeclaration>())?.let { return it }
-        return QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetForExpression>())?.multiParameter
+object CreateComponentFunctionActionFactory : CreateCallableMemberFromUsageFactory<KtMultiDeclaration>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtMultiDeclaration? {
+        QuickFixUtil.getParentElementOfType(diagnostic, javaClass<KtMultiDeclaration>())?.let { return it }
+        return QuickFixUtil.getParentElementOfType(diagnostic, javaClass<KtForExpression>())?.multiParameter
     }
 
-    override fun createCallableInfo(element: JetMultiDeclaration, diagnostic: Diagnostic): CallableInfo? {
+    override fun createCallableInfo(element: KtMultiDeclaration, diagnostic: Diagnostic): CallableInfo? {
         val diagnosticWithParameters = Errors.COMPONENT_FUNCTION_MISSING.cast(diagnostic)
 
         val name = diagnosticWithParameters.a
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateConstructorFromDelegationCallActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateConstructorFromDelegationCallActionFactory.kt
index d302e778328..3e31253241a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateConstructorFromDelegationCallActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateConstructorFromDelegationCallActionFactory.kt
@@ -28,21 +28,21 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Callab
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.ParameterInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.SecondaryConstructorInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetConstructorDelegationCall
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtConstructorDelegationCall
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.types.Variance
 
-object CreateConstructorFromDelegationCallActionFactory : CreateCallableMemberFromUsageFactory<JetConstructorDelegationCall>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetConstructorDelegationCall? {
-        return diagnostic.psiElement.getStrictParentOfType<JetConstructorDelegationCall>()
+object CreateConstructorFromDelegationCallActionFactory : CreateCallableMemberFromUsageFactory<KtConstructorDelegationCall>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtConstructorDelegationCall? {
+        return diagnostic.psiElement.getStrictParentOfType<KtConstructorDelegationCall>()
     }
 
-    override fun createCallableInfo(element: JetConstructorDelegationCall, diagnostic: Diagnostic): CallableInfo? {
+    override fun createCallableInfo(element: KtConstructorDelegationCall, diagnostic: Diagnostic): CallableInfo? {
         val calleeExpression = element.calleeExpression ?: return null
-        val currentClass = element.getStrictParentOfType<JetClass>() ?: return null
+        val currentClass = element.getStrictParentOfType<KtClass>() ?: return null
 
         val project = currentClass.project
 
@@ -56,7 +56,7 @@ object CreateConstructorFromDelegationCallActionFactory : CreateCallableMemberFr
                     DescriptorUtils.getSuperclassDescriptors(classDescriptor).singleOrNull { it.kind == ClassKind.CLASS } ?: return null
             DescriptorToSourceUtilsIde.getAnyDeclaration(project, superClassDescriptor) ?: return null
         }
-        if (!(targetClass.canRefactor() && (targetClass is JetClass || targetClass is PsiClass))) return null
+        if (!(targetClass.canRefactor() && (targetClass is KtClass || targetClass is PsiClass))) return null
 
         val anyType = classDescriptor.builtIns.nullableAnyType
         val parameters = element.valueArguments.map {
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateConstructorFromDelegatorToSuperCallActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateConstructorFromDelegatorToSuperCallActionFactory.kt
index 4466fdf1d3b..96f009ff325 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateConstructorFromDelegatorToSuperCallActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateConstructorFromDelegatorToSuperCallActionFactory.kt
@@ -28,19 +28,19 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Callab
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.ParameterInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.SecondaryConstructorInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetDelegatorToSuperCall
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtDelegatorToSuperCall
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.types.Variance
 
-object CreateConstructorFromDelegatorToSuperCallActionFactory : CreateCallableMemberFromUsageFactory<JetDelegatorToSuperCall>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetDelegatorToSuperCall? {
-        return diagnostic.psiElement.getStrictParentOfType<JetDelegatorToSuperCall>()
+object CreateConstructorFromDelegatorToSuperCallActionFactory : CreateCallableMemberFromUsageFactory<KtDelegatorToSuperCall>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtDelegatorToSuperCall? {
+        return diagnostic.psiElement.getStrictParentOfType<KtDelegatorToSuperCall>()
     }
 
-    override fun createCallableInfo(element: JetDelegatorToSuperCall, diagnostic: Diagnostic): CallableInfo? {
+    override fun createCallableInfo(element: KtDelegatorToSuperCall, diagnostic: Diagnostic): CallableInfo? {
         val typeReference = element.calleeExpression.typeReference ?: return null
 
         val project = element.project
@@ -49,7 +49,7 @@ object CreateConstructorFromDelegatorToSuperCallActionFactory : CreateCallableMe
         val superClassDescriptor = superType.constructor.declarationDescriptor as? ClassDescriptor ?: return null
         if (superClassDescriptor.kind != ClassKind.CLASS) return null
         val targetClass = DescriptorToSourceUtilsIde.getAnyDeclaration(project, superClassDescriptor) ?: return null
-        if (!(targetClass.canRefactor() && (targetClass is JetClass || targetClass is PsiClass))) return null
+        if (!(targetClass.canRefactor() && (targetClass is KtClass || targetClass is PsiClass))) return null
 
         val anyType = superClassDescriptor.builtIns.nullableAnyType
         val parameters = element.valueArguments.map {
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateGetFunctionActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateGetFunctionActionFactory.kt
index 94342f3084f..0f69e0df38e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateGetFunctionActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateGetFunctionActionFactory.kt
@@ -22,16 +22,16 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Callab
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.ParameterInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
-import org.jetbrains.kotlin.psi.JetArrayAccessExpression
+import org.jetbrains.kotlin.psi.KtArrayAccessExpression
 import org.jetbrains.kotlin.types.Variance
 import java.util.Collections
 
-object CreateGetFunctionActionFactory : CreateCallableMemberFromUsageFactory<JetArrayAccessExpression>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetArrayAccessExpression? {
-        return QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetArrayAccessExpression>())
+object CreateGetFunctionActionFactory : CreateCallableMemberFromUsageFactory<KtArrayAccessExpression>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtArrayAccessExpression? {
+        return QuickFixUtil.getParentElementOfType(diagnostic, javaClass<KtArrayAccessExpression>())
     }
 
-    override fun createCallableInfo(element: JetArrayAccessExpression, diagnostic: Diagnostic): CallableInfo? {
+    override fun createCallableInfo(element: KtArrayAccessExpression, diagnostic: Diagnostic): CallableInfo? {
         val arrayExpr = element.arrayExpression ?: return null
 
         val arrayType = TypeInfo(arrayExpr, Variance.IN_VARIANCE)
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateHasNextFunctionActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateHasNextFunctionActionFactory.kt
index 9a09c8ac5f4..b3c94343287 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateHasNextFunctionActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateHasNextFunctionActionFactory.kt
@@ -24,16 +24,16 @@ import org.jetbrains.kotlin.idea.project.platform
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.CallableInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
-import org.jetbrains.kotlin.psi.JetForExpression
+import org.jetbrains.kotlin.psi.KtForExpression
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
-object CreateHasNextFunctionActionFactory : CreateCallableMemberFromUsageFactory<JetForExpression>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetForExpression? {
-        return QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetForExpression>())
+object CreateHasNextFunctionActionFactory : CreateCallableMemberFromUsageFactory<KtForExpression>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtForExpression? {
+        return QuickFixUtil.getParentElementOfType(diagnostic, javaClass<KtForExpression>())
     }
 
-    override fun createCallableInfo(element: JetForExpression, diagnostic: Diagnostic): CallableInfo? {
+    override fun createCallableInfo(element: KtForExpression, diagnostic: Diagnostic): CallableInfo? {
         val diagnosticWithParameters =
                 DiagnosticFactory.cast(diagnostic, Errors.HAS_NEXT_MISSING, Errors.HAS_NEXT_FUNCTION_NONE_APPLICABLE)
         val ownerType = TypeInfo(diagnosticWithParameters.a, Variance.IN_VARIANCE)
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateInvokeFunctionActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateInvokeFunctionActionFactory.kt
index 49d62507829..0b1fabb35a8 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateInvokeFunctionActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateInvokeFunctionActionFactory.kt
@@ -23,16 +23,16 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Callab
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.ParameterInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
-import org.jetbrains.kotlin.psi.JetCallExpression
+import org.jetbrains.kotlin.psi.KtCallExpression
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
-object CreateInvokeFunctionActionFactory : CreateCallableMemberFromUsageFactory<JetCallExpression>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetCallExpression? {
-        return diagnostic.psiElement.parent as? JetCallExpression
+object CreateInvokeFunctionActionFactory : CreateCallableMemberFromUsageFactory<KtCallExpression>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtCallExpression? {
+        return diagnostic.psiElement.parent as? KtCallExpression
     }
 
-    override fun createCallableInfo(element: JetCallExpression, diagnostic: Diagnostic): CallableInfo? {
+    override fun createCallableInfo(element: KtCallExpression, diagnostic: Diagnostic): CallableInfo? {
         val expectedType = Errors.FUNCTION_EXPECTED.cast(diagnostic).b
         if (expectedType.isError) return null
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateIteratorFunctionActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateIteratorFunctionActionFactory.kt
index 32c148730fd..8af1b172aeb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateIteratorFunctionActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateIteratorFunctionActionFactory.kt
@@ -24,24 +24,24 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Callab
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.guessTypes
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetForExpression
-import org.jetbrains.kotlin.types.JetTypeImpl
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.types.KtTypeImpl
 import org.jetbrains.kotlin.types.TypeProjectionImpl
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.util.OperatorNameConventions
 import java.util.*
 
-object CreateIteratorFunctionActionFactory : CreateCallableMemberFromUsageFactory<JetForExpression>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetForExpression? {
-        return QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetForExpression>())
+object CreateIteratorFunctionActionFactory : CreateCallableMemberFromUsageFactory<KtForExpression>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtForExpression? {
+        return QuickFixUtil.getParentElementOfType(diagnostic, javaClass<KtForExpression>())
     }
 
-    override fun createCallableInfo(element: JetForExpression, diagnostic: Diagnostic): CallableInfo? {
-        val file = diagnostic.psiFile as? JetFile ?: return null
+    override fun createCallableInfo(element: KtForExpression, diagnostic: Diagnostic): CallableInfo? {
+        val file = diagnostic.psiFile as? KtFile ?: return null
         val iterableExpr = element.loopRange ?: return null
-        val variableExpr: JetExpression = ((element.loopParameter ?: element.multiParameter) ?: return null) as JetExpression
+        val variableExpr: KtExpression = ((element.loopParameter ?: element.multiParameter) ?: return null) as KtExpression
         val iterableType = TypeInfo(iterableExpr, Variance.IN_VARIANCE)
 
         val (bindingContext, moduleDescriptor) = file.analyzeFullyAndGetResult()
@@ -52,7 +52,7 @@ object CreateIteratorFunctionActionFactory : CreateCallableMemberFromUsageFactor
 
         val returnJetTypeParameterType = TypeProjectionImpl(returnJetTypeParameterTypes[0])
         val returnJetTypeArguments = Collections.singletonList(returnJetTypeParameterType)
-        val newReturnJetType = JetTypeImpl.create(returnJetType.annotations,
+        val newReturnJetType = KtTypeImpl.create(returnJetType.annotations,
                                            returnJetType.constructor,
                                            returnJetType.isMarkedNullable,
                                            returnJetTypeArguments,
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateNextFunctionActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateNextFunctionActionFactory.kt
index 7b739368871..2cfbd6882d1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateNextFunctionActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateNextFunctionActionFactory.kt
@@ -23,22 +23,22 @@ import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.CallableInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetForExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtForExpression
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
-object CreateNextFunctionActionFactory : CreateCallableMemberFromUsageFactory<JetForExpression>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetForExpression? {
-        return QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetForExpression>())
+object CreateNextFunctionActionFactory : CreateCallableMemberFromUsageFactory<KtForExpression>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtForExpression? {
+        return QuickFixUtil.getParentElementOfType(diagnostic, javaClass<KtForExpression>())
     }
 
-    override fun createCallableInfo(element: JetForExpression, diagnostic: Diagnostic): CallableInfo? {
+    override fun createCallableInfo(element: KtForExpression, diagnostic: Diagnostic): CallableInfo? {
         val diagnosticWithParameters = DiagnosticFactory.cast(diagnostic, Errors.NEXT_MISSING, Errors.NEXT_NONE_APPLICABLE)
         val ownerType = TypeInfo(diagnosticWithParameters.a, Variance.IN_VARIANCE)
 
         val variableExpr = element.loopParameter ?: element.multiParameter ?: return null
-        val returnType = TypeInfo(variableExpr as JetExpression, Variance.OUT_VARIANCE)
+        val returnType = TypeInfo(variableExpr as KtExpression, Variance.OUT_VARIANCE)
         return FunctionInfo(OperatorNameConventions.NEXT.asString(), ownerType, returnType, isOperator = true)
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreatePropertyDelegateAccessorsActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreatePropertyDelegateAccessorsActionFactory.kt
index 3ed47e26fdb..0dabdfe980d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreatePropertyDelegateAccessorsActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreatePropertyDelegateAccessorsActionFactory.kt
@@ -26,26 +26,26 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Callab
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.ParameterInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.types.Variance
 
-object CreatePropertyDelegateAccessorsActionFactory : CreateCallableMemberFromUsageFactory<JetExpression>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetExpression? {
-        return diagnostic.psiElement as? JetExpression
+object CreatePropertyDelegateAccessorsActionFactory : CreateCallableMemberFromUsageFactory<KtExpression>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtExpression? {
+        return diagnostic.psiElement as? KtExpression
     }
 
-    override fun extractFixData(element: JetExpression, diagnostic: Diagnostic): List<CallableInfo> {
+    override fun extractFixData(element: KtExpression, diagnostic: Diagnostic): List<CallableInfo> {
         val context = element.analyze()
 
         fun isApplicableForAccessor(accessor: PropertyAccessorDescriptor?): Boolean =
                 accessor != null && context[BindingContext.DELEGATED_PROPERTY_RESOLVED_CALL, accessor] == null
 
-        val property = element.getNonStrictParentOfType<JetProperty>() ?: return emptyList()
+        val property = element.getNonStrictParentOfType<KtProperty>() ?: return emptyList()
         val propertyDescriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, property] as? PropertyDescriptor
                                  ?: return emptyList()
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateSetFunctionActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateSetFunctionActionFactory.kt
index 2533d65af1f..be2a5e4d695 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateSetFunctionActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateSetFunctionActionFactory.kt
@@ -24,22 +24,22 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Callab
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.ParameterInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
-import org.jetbrains.kotlin.psi.JetArrayAccessExpression
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetOperationExpression
-import org.jetbrains.kotlin.psi.JetUnaryExpression
+import org.jetbrains.kotlin.psi.KtArrayAccessExpression
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtOperationExpression
+import org.jetbrains.kotlin.psi.KtUnaryExpression
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import java.util.*
 
-object CreateSetFunctionActionFactory : CreateCallableMemberFromUsageFactory<JetArrayAccessExpression>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetArrayAccessExpression? {
-        return QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetArrayAccessExpression>())
+object CreateSetFunctionActionFactory : CreateCallableMemberFromUsageFactory<KtArrayAccessExpression>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtArrayAccessExpression? {
+        return QuickFixUtil.getParentElementOfType(diagnostic, javaClass<KtArrayAccessExpression>())
     }
 
-    override fun createCallableInfo(element: JetArrayAccessExpression, diagnostic: Diagnostic): CallableInfo? {
+    override fun createCallableInfo(element: KtArrayAccessExpression, diagnostic: Diagnostic): CallableInfo? {
         val arrayExpr = element.arrayExpression ?: return null
         val arrayType = TypeInfo(arrayExpr, Variance.IN_VARIANCE)
 
@@ -48,12 +48,12 @@ object CreateSetFunctionActionFactory : CreateCallableMemberFromUsageFactory<Jet
         val parameters = element.indexExpressions.mapTo(ArrayList<ParameterInfo>()) {
             ParameterInfo(TypeInfo(it, Variance.IN_VARIANCE))
         }
-        val assignmentExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetOperationExpression>()) ?: return null
+        val assignmentExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass<KtOperationExpression>()) ?: return null
         val valType = when (assignmentExpr) {
-            is JetBinaryExpression -> {
+            is KtBinaryExpression -> {
                 TypeInfo(assignmentExpr.right ?: return null, Variance.IN_VARIANCE)
             }
-            is JetUnaryExpression -> {
+            is KtUnaryExpression -> {
                 if (assignmentExpr.operationToken !in OperatorConventions.INCREMENT_OPERATIONS) return null
 
                 val context = assignmentExpr.analyze()
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateUnaryOperationActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateUnaryOperationActionFactory.kt
index 201080395a3..68812b5b5b4 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateUnaryOperationActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateUnaryOperationActionFactory.kt
@@ -20,18 +20,18 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.CallableInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
-import org.jetbrains.kotlin.lexer.JetToken
-import org.jetbrains.kotlin.psi.JetUnaryExpression
+import org.jetbrains.kotlin.lexer.KtToken
+import org.jetbrains.kotlin.psi.KtUnaryExpression
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 
-public object CreateUnaryOperationActionFactory: CreateCallableMemberFromUsageFactory<JetUnaryExpression>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetUnaryExpression? {
-        return diagnostic.psiElement.parent as? JetUnaryExpression
+public object CreateUnaryOperationActionFactory: CreateCallableMemberFromUsageFactory<KtUnaryExpression>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtUnaryExpression? {
+        return diagnostic.psiElement.parent as? KtUnaryExpression
     }
 
-    override fun createCallableInfo(element: JetUnaryExpression, diagnostic: Diagnostic): CallableInfo? {
-        val token = element.operationToken as JetToken
+    override fun createCallableInfo(element: KtUnaryExpression, diagnostic: Diagnostic): CallableInfo? {
+        val token = element.operationToken as KtToken
         val operationName = OperatorConventions.getNameForOperationSymbol(token, true, false) ?: return null
         val incDec = token in OperatorConventions.INCREMENT_OPERATIONS
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromCallWithConstructorCalleeActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromCallWithConstructorCalleeActionFactory.kt
index 9400d53a0ca..0850cf16eec 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromCallWithConstructorCalleeActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromCallWithConstructorCalleeActionFactory.kt
@@ -30,34 +30,34 @@ import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.utils.addToStdlib.singletonList
 import java.util.Collections
 
-public object CreateClassFromCallWithConstructorCalleeActionFactory : CreateClassFromUsageFactory<JetCallElement>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetCallElement? {
+public object CreateClassFromCallWithConstructorCalleeActionFactory : CreateClassFromUsageFactory<KtCallElement>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtCallElement? {
         val diagElement = diagnostic.psiElement
 
         val callElement = PsiTreeUtil.getParentOfType(
                 diagElement,
-                javaClass<JetAnnotationEntry>(),
-                javaClass<JetDelegatorToSuperCall>()
-        ) as? JetCallElement ?: return null
+                javaClass<KtAnnotationEntry>(),
+                javaClass<KtDelegatorToSuperCall>()
+        ) as? KtCallElement ?: return null
 
-        val callee = callElement.calleeExpression as? JetConstructorCalleeExpression ?: return null
+        val callee = callElement.calleeExpression as? KtConstructorCalleeExpression ?: return null
         val calleeRef = callee.constructorReferenceExpression ?: return null
 
         if (!calleeRef.isAncestor(diagElement)) return null
         return callElement
     }
 
-    override fun getPossibleClassKinds(element: JetCallElement, diagnostic: Diagnostic): List<ClassKind> {
-        return (if (element is JetAnnotationEntry) ClassKind.ANNOTATION_CLASS else ClassKind.PLAIN_CLASS).singletonList()
+    override fun getPossibleClassKinds(element: KtCallElement, diagnostic: Diagnostic): List<ClassKind> {
+        return (if (element is KtAnnotationEntry) ClassKind.ANNOTATION_CLASS else ClassKind.PLAIN_CLASS).singletonList()
     }
 
-    override fun extractFixData(element: JetCallElement, diagnostic: Diagnostic): ClassInfo? {
-        val isAnnotation = element is JetAnnotationEntry
-        val callee = element.calleeExpression as? JetConstructorCalleeExpression ?: return null
+    override fun extractFixData(element: KtCallElement, diagnostic: Diagnostic): ClassInfo? {
+        val isAnnotation = element is KtAnnotationEntry
+        val callee = element.calleeExpression as? KtConstructorCalleeExpression ?: return null
         val calleeRef = callee.constructorReferenceExpression ?: return null
-        val file = element.containingFile as? JetFile ?: return null
+        val file = element.containingFile as? KtFile ?: return null
         val typeRef = callee.typeReference ?: return null
-        val userType = typeRef.typeElement as? JetUserType ?: return null
+        val userType = typeRef.typeElement as? KtUserType ?: return null
 
         val (context, module) = userType.analyzeAndGetResult()
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromConstructorCallActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromConstructorCallActionFactory.kt
index c494ad3eaf6..e9caef32271 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromConstructorCallActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromConstructorCallActionFactory.kt
@@ -30,20 +30,20 @@ import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.utils.addToStdlib.singletonList
 import java.util.Collections
 
-public object CreateClassFromConstructorCallActionFactory: CreateClassFromUsageFactory<JetCallExpression>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetCallExpression? {
+public object CreateClassFromConstructorCallActionFactory: CreateClassFromUsageFactory<KtCallExpression>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtCallExpression? {
         val diagElement = diagnostic.psiElement
-        if (diagElement.getNonStrictParentOfType<JetTypeReference>() != null) return null
+        if (diagElement.getNonStrictParentOfType<KtTypeReference>() != null) return null
 
-        val callExpr = diagElement.parent as? JetCallExpression ?: return null
+        val callExpr = diagElement.parent as? KtCallExpression ?: return null
         return if (callExpr.calleeExpression == diagElement) callExpr else null
     }
 
-    override fun getPossibleClassKinds(element: JetCallExpression, diagnostic: Diagnostic): List<ClassKind> {
-        val inAnnotationEntry = diagnostic.psiElement.getNonStrictParentOfType<JetAnnotationEntry>() != null
+    override fun getPossibleClassKinds(element: KtCallExpression, diagnostic: Diagnostic): List<ClassKind> {
+        val inAnnotationEntry = diagnostic.psiElement.getNonStrictParentOfType<KtAnnotationEntry>() != null
 
         val (context, moduleDescriptor) = element.analyzeFullyAndGetResult()
-        val file = element.containingFile as? JetFile ?: return emptyList()
+        val file = element.containingFile as? KtFile ?: return emptyList()
         val call = element.getCall(context) ?: return emptyList()
         val targetParent = getTargetParentByCall(call, file) ?: return emptyList()
 
@@ -54,25 +54,25 @@ public object CreateClassFromConstructorCallActionFactory: CreateClassFromUsageF
         return classKind.singletonList()
     }
 
-    override fun extractFixData(element: JetCallExpression, diagnostic: Diagnostic): ClassInfo? {
+    override fun extractFixData(element: KtCallExpression, diagnostic: Diagnostic): ClassInfo? {
         val diagElement = diagnostic.psiElement
-        if (diagElement.getNonStrictParentOfType<JetTypeReference>() != null) return null
+        if (diagElement.getNonStrictParentOfType<KtTypeReference>() != null) return null
 
-        val inAnnotationEntry = diagElement.getNonStrictParentOfType<JetAnnotationEntry>() != null
+        val inAnnotationEntry = diagElement.getNonStrictParentOfType<KtAnnotationEntry>() != null
 
-        val callExpr = diagElement.parent as? JetCallExpression ?: return null
+        val callExpr = diagElement.parent as? KtCallExpression ?: return null
         if (callExpr.calleeExpression != diagElement) return null
 
-        val calleeExpr = callExpr.calleeExpression as? JetSimpleNameExpression ?: return null
+        val calleeExpr = callExpr.calleeExpression as? KtSimpleNameExpression ?: return null
 
         val name = calleeExpr.getReferencedName()
         if (!inAnnotationEntry && !name.checkClassName()) return null
 
         val callParent = callExpr.parent
         val fullCallExpr =
-                if (callParent is JetQualifiedExpression && callParent.selectorExpression == callExpr) callParent else callExpr
+                if (callParent is KtQualifiedExpression && callParent.selectorExpression == callExpr) callParent else callExpr
 
-        val file = fullCallExpr.containingFile as? JetFile ?: return null
+        val file = fullCallExpr.containingFile as? KtFile ?: return null
 
         val (context, moduleDescriptor) = callExpr.analyzeFullyAndGetResult()
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromReferenceExpressionActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromReferenceExpressionActionFactory.kt
index 0d1717a0f0c..94976b1821a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromReferenceExpressionActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromReferenceExpressionActionFactory.kt
@@ -31,37 +31,37 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
 import java.util.Arrays
 import java.util.Collections
 
-public object CreateClassFromReferenceExpressionActionFactory : CreateClassFromUsageFactory<JetSimpleNameExpression>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetSimpleNameExpression? {
-        val refExpr = diagnostic.psiElement as? JetSimpleNameExpression ?: return null
-        if (refExpr.getNonStrictParentOfType<JetTypeReference>() != null) return null
+public object CreateClassFromReferenceExpressionActionFactory : CreateClassFromUsageFactory<KtSimpleNameExpression>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtSimpleNameExpression? {
+        val refExpr = diagnostic.psiElement as? KtSimpleNameExpression ?: return null
+        if (refExpr.getNonStrictParentOfType<KtTypeReference>() != null) return null
         return refExpr
     }
 
-    private fun getFullCallExpression(element: JetSimpleNameExpression): JetExpression? {
+    private fun getFullCallExpression(element: KtSimpleNameExpression): KtExpression? {
         return element.parent?.let {
             when {
-                it is JetCallExpression && it.calleeExpression == element -> return null
-                it is JetQualifiedExpression && it.selectorExpression == element -> it
+                it is KtCallExpression && it.calleeExpression == element -> return null
+                it is KtQualifiedExpression && it.selectorExpression == element -> it
                 else -> element
             }
-        } as? JetExpression
+        } as? KtExpression
     }
 
-    private fun isQualifierExpected(element: JetSimpleNameExpression) = element.isDotReceiver() || ((element.parent as? JetDotQualifiedExpression)?.isDotReceiver() ?: false)
+    private fun isQualifierExpected(element: KtSimpleNameExpression) = element.isDotReceiver() || ((element.parent as? KtDotQualifiedExpression)?.isDotReceiver() ?: false)
 
-    private fun isInsideOfImport(element: JetSimpleNameExpression) = element.getNonStrictParentOfType<JetImportDirective>() != null
+    private fun isInsideOfImport(element: KtSimpleNameExpression) = element.getNonStrictParentOfType<KtImportDirective>() != null
 
-    override fun getPossibleClassKinds(element: JetSimpleNameExpression, diagnostic: Diagnostic): List<ClassKind> {
+    override fun getPossibleClassKinds(element: KtSimpleNameExpression, diagnostic: Diagnostic): List<ClassKind> {
         fun isEnum(element: PsiElement): Boolean {
             return when (element) {
-                is JetClass -> element.isEnum()
+                is KtClass -> element.isEnum()
                 is PsiClass -> element.isEnum
                 else -> false
             }
         }
 
-        val file = element.containingFile as? JetFile ?: return Collections.emptyList()
+        val file = element.containingFile as? KtFile ?: return Collections.emptyList()
 
         val name = element.getReferencedName()
 
@@ -69,9 +69,9 @@ public object CreateClassFromReferenceExpressionActionFactory : CreateClassFromU
 
         val fullCallExpr = getFullCallExpression(element) ?: return Collections.emptyList()
 
-        val inImport = element.getNonStrictParentOfType<JetImportDirective>() != null
+        val inImport = element.getNonStrictParentOfType<KtImportDirective>() != null
         if (inImport || isQualifierExpected(element)) {
-            val receiverSelector = (fullCallExpr as? JetQualifiedExpression)?.receiverExpression?.getQualifiedElementSelector() as? JetReferenceExpression
+            val receiverSelector = (fullCallExpr as? KtQualifiedExpression)?.receiverExpression?.getQualifiedElementSelector() as? KtReferenceExpression
             val qualifierDescriptor = receiverSelector?.let { context[BindingContext.REFERENCE_TARGET, it] }
 
             val targetParent =
@@ -111,8 +111,8 @@ public object CreateClassFromReferenceExpressionActionFactory : CreateClassFromU
                 }
     }
 
-    override fun extractFixData(element: JetSimpleNameExpression, diagnostic: Diagnostic): ClassInfo? {
-        val file = element.containingFile as? JetFile ?: return null
+    override fun extractFixData(element: KtSimpleNameExpression, diagnostic: Diagnostic): ClassInfo? {
+        val file = element.containingFile as? KtFile ?: return null
 
         val name = element.getReferencedName()
 
@@ -121,7 +121,7 @@ public object CreateClassFromReferenceExpressionActionFactory : CreateClassFromU
         val fullCallExpr = getFullCallExpression(element) ?: return null
 
         if (isInsideOfImport(element) || isQualifierExpected(element)) {
-            val receiverSelector = (fullCallExpr as? JetQualifiedExpression)?.receiverExpression?.getQualifiedElementSelector() as? JetReferenceExpression
+            val receiverSelector = (fullCallExpr as? KtQualifiedExpression)?.receiverExpression?.getQualifiedElementSelector() as? KtReferenceExpression
             val qualifierDescriptor = receiverSelector?.let { context[BindingContext.REFERENCE_TARGET, it] }
 
             val targetParent =
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromTypeReferenceActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromTypeReferenceActionFactory.kt
index b5136049970..11eb29daf8d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromTypeReferenceActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromTypeReferenceActionFactory.kt
@@ -22,26 +22,26 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeAndGetResult
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
-import org.jetbrains.kotlin.psi.JetConstructorCalleeExpression
-import org.jetbrains.kotlin.psi.JetDelegatorToSuperClass
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetUserType
+import org.jetbrains.kotlin.psi.KtConstructorCalleeExpression
+import org.jetbrains.kotlin.psi.KtDelegatorToSuperClass
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtUserType
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.types.Variance
 import java.util.Collections
 
-public object CreateClassFromTypeReferenceActionFactory : CreateClassFromUsageFactory<JetUserType>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetUserType? {
-        return QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetUserType>())
+public object CreateClassFromTypeReferenceActionFactory : CreateClassFromUsageFactory<KtUserType>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtUserType? {
+        return QuickFixUtil.getParentElementOfType(diagnostic, javaClass<KtUserType>())
     }
 
-    override fun getPossibleClassKinds(element: JetUserType, diagnostic: Diagnostic): List<ClassKind> {
+    override fun getPossibleClassKinds(element: KtUserType, diagnostic: Diagnostic): List<ClassKind> {
         val typeRefParent = element.parent?.parent
-        if (typeRefParent is JetConstructorCalleeExpression) return Collections.emptyList()
+        if (typeRefParent is KtConstructorCalleeExpression) return Collections.emptyList()
 
-        val interfaceExpected = typeRefParent is JetDelegatorToSuperClass
+        val interfaceExpected = typeRefParent is KtDelegatorToSuperClass
 
-        val isQualifier = (element.parent as? JetUserType)?.let { it.qualifier == element } ?: false
+        val isQualifier = (element.parent as? KtUserType)?.let { it.qualifier == element } ?: false
 
         return when {
             interfaceExpected -> Collections.singletonList(ClassKind.INTERFACE)
@@ -58,11 +58,11 @@ public object CreateClassFromTypeReferenceActionFactory : CreateClassFromUsageFa
         }
     }
 
-    override fun extractFixData(element: JetUserType, diagnostic: Diagnostic): ClassInfo? {
+    override fun extractFixData(element: KtUserType, diagnostic: Diagnostic): ClassInfo? {
         val name = element.referenceExpression?.getReferencedName() ?: return null
-        if (element.parent?.parent is JetConstructorCalleeExpression) return null
+        if (element.parent?.parent is KtConstructorCalleeExpression) return null
 
-        val file = element.containingFile as? JetFile ?: return null
+        val file = element.containingFile as? KtFile ?: return null
 
         val (context, module) = element.analyzeAndGetResult()
         val qualifier = element.qualifier?.referenceExpression
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFactory.kt
index 0d79933e57b..ead2d4c8660 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFactory.kt
@@ -20,9 +20,9 @@ import com.intellij.psi.SmartPsiElementPointer
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.quickfix.KotlinIntentionActionFactoryWithDelegate
 import org.jetbrains.kotlin.idea.quickfix.QuickFixWithDelegateFactory
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 
-abstract class CreateClassFromUsageFactory<E : JetElement> : KotlinIntentionActionFactoryWithDelegate<E, ClassInfo>() {
+abstract class CreateClassFromUsageFactory<E : KtElement> : KotlinIntentionActionFactoryWithDelegate<E, ClassInfo>() {
     protected abstract fun getPossibleClassKinds(element: E, diagnostic: Diagnostic): List<ClassKind>
 
     override fun createFixes(
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFix.kt
index 60c1875330b..d1290d78e07 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFix.kt
@@ -25,7 +25,7 @@ import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiPackage
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
 import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.core.refactoring.getOrCreateKotlinFile
@@ -33,8 +33,8 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.CreateFromUsageFixBase
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.ClassKind.*
 import org.jetbrains.kotlin.idea.util.application.executeCommand
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
 import java.util.Collections
 import java.util.HashMap
 
@@ -59,7 +59,7 @@ public data class ClassInfo(
         val parameterInfos: List<ParameterInfo> = Collections.emptyList()
 )
 
-public class CreateClassFromUsageFix<E : JetElement>(
+public class CreateClassFromUsageFix<E : KtElement>(
         element: E,
         val classInfo: ClassInfo
 ): CreateFromUsageFixBase<E>(element) {
@@ -77,8 +77,8 @@ public class CreateClassFromUsageFix<E : JetElement>(
         return true
     }
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
-        fun createFileByPackage(psiPackage: PsiPackage): JetFile? {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+        fun createFileByPackage(psiPackage: PsiPackage): KtFile? {
             val directories = psiPackage.directories.filter { it.canRefactor() }
             assert (directories.isNotEmpty()) { "Package '${psiPackage.qualifiedName}' must be refactorable" }
 
@@ -94,7 +94,7 @@ public class CreateClassFromUsageFix<E : JetElement>(
                 preferredDirectory
             } ?: return null
 
-            val fileName = "${classInfo.name}.${JetFileType.INSTANCE.defaultExtension}"
+            val fileName = "${classInfo.name}.${KotlinFileType.INSTANCE.defaultExtension}"
             val targetFile = getOrCreateKotlinFile(fileName, targetDirectory)
             if (targetFile == null) {
                 val filePath = "${targetDirectory.virtualFile.path}/$fileName"
@@ -112,14 +112,14 @@ public class CreateClassFromUsageFix<E : JetElement>(
         with (classInfo) {
             val targetParent =
                     when (targetParent) {
-                        is JetElement, is PsiClass -> targetParent
+                        is KtElement, is PsiClass -> targetParent
                         is PsiPackage -> createFileByPackage(targetParent)
                         else -> throw AssertionError("Unexpected element: " + targetParent.text)
                     } ?: return
 
             val constructorInfo = PrimaryConstructorInfo(classInfo, expectedTypeInfo)
             val builder = CallableBuilderConfiguration(
-                    Collections.singletonList(constructorInfo), element as JetElement, file, editor, false, kind == PLAIN_CLASS || kind == INTERFACE
+                    Collections.singletonList(constructorInfo), element as KtElement, file, editor, false, kind == PLAIN_CLASS || kind == INTERFACE
             ).createBuilder()
             builder.placement = CallablePlacement.NoReceiver(targetParent)
             project.executeCommand(text) { builder.build() }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/createClassUtils.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/createClassUtils.kt
index 088fd55de45..641f79ee764 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/createClassUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/createClassUtils.kt
@@ -32,9 +32,9 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.contai
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.guessTypes
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.noSubstitutions
 import org.jetbrains.kotlin.psi.Call
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -48,7 +48,7 @@ internal fun String.checkClassName(): Boolean = isNotEmpty() && Character.isUppe
 private fun String.checkPackageName(): Boolean = isNotEmpty() && Character.isLowerCase(first())
 
 internal fun getTargetParentByQualifier(
-        file: JetFile,
+        file: KtFile,
         isQualified: Boolean,
         qualifierDescriptor: DeclarationDescriptor?): PsiElement? {
     val project = file.getProject()
@@ -68,7 +68,7 @@ internal fun getTargetParentByQualifier(
     return if (targetParent.canRefactor()) return targetParent else null
 }
 
-internal fun getTargetParentByCall(call: Call, file: JetFile): PsiElement? {
+internal fun getTargetParentByCall(call: Call, file: KtFile): PsiElement? {
     val receiver = call.getExplicitReceiver()
     return when (receiver) {
         ReceiverValue.NO_RECEIVER -> getTargetParentByQualifier(file, false, null)
@@ -82,7 +82,7 @@ internal fun isInnerClassExpected(call: Call): Boolean {
     return receiver != ReceiverValue.NO_RECEIVER && receiver !is Qualifier
 }
 
-internal fun JetExpression.getInheritableTypeInfo(
+internal fun KtExpression.getInheritableTypeInfo(
         context: BindingContext,
         moduleDescriptor: ModuleDescriptor,
         containingDeclaration: PsiElement): Pair<TypeInfo, (ClassKind) -> Boolean> {
@@ -108,12 +108,12 @@ internal fun JetExpression.getInheritableTypeInfo(
     }
 }
 
-internal fun JetSimpleNameExpression.getCreatePackageFixIfApplicable(targetParent: PsiElement): IntentionAction? {
+internal fun KtSimpleNameExpression.getCreatePackageFixIfApplicable(targetParent: PsiElement): IntentionAction? {
     val name = getReferencedName()
     if (!name.checkPackageName()) return null
 
     val basePackage: PsiPackage? = when (targetParent) {
-                                      is JetFile -> JavaPsiFacade.getInstance(targetParent.getProject()).findPackage(targetParent.getPackageFqName().asString())
+                                      is KtFile -> JavaPsiFacade.getInstance(targetParent.getProject()).findPackage(targetParent.getPackageFqName().asString())
                                       is PsiPackage -> targetParent
                                       else -> null
                                   }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateLocalVariableActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateLocalVariableActionFactory.kt
index 79152c47c58..50a8936d3b6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateLocalVariableActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateLocalVariableActionFactory.kt
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.idea.quickfix.JetSingleIntentionActionFactory
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.CreateFromUsageFixBase
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
 import org.jetbrains.kotlin.idea.util.application.executeCommand
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getAssignmentByLHS
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElement
@@ -38,32 +38,32 @@ import java.util.*
 
 object CreateLocalVariableActionFactory: JetSingleIntentionActionFactory() {
     override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-        val refExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetSimpleNameExpression>()) ?: return null
+        val refExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass<KtSimpleNameExpression>()) ?: return null
         if (refExpr.getQualifiedElement() != refExpr) return null
-        if (refExpr.getReferencedNameElementType() != JetTokens.IDENTIFIER) return null
+        if (refExpr.getReferencedNameElementType() != KtTokens.IDENTIFIER) return null
 
         val propertyName = refExpr.getReferencedName()
 
         val container = refExpr.parents
-                .filter { it is JetBlockExpression || it is JetDeclarationWithBody }
-                .firstOrNull() as? JetElement ?: return null
+                .filter { it is KtBlockExpression || it is KtDeclarationWithBody }
+                .firstOrNull() as? KtElement ?: return null
 
-        return object: CreateFromUsageFixBase<JetSimpleNameExpression>(refExpr) {
+        return object: CreateFromUsageFixBase<KtSimpleNameExpression>(refExpr) {
             override fun getText(): String = JetBundle.message("create.local.variable.from.usage", propertyName)
 
-            override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+            override fun invoke(project: Project, editor: Editor?, file: KtFile) {
                 val assignment = refExpr.getAssignmentByLHS()
                 val varExpected = assignment != null
                 var originalElement = assignment ?: refExpr
 
                 val actualContainer = when (container) {
-                    is JetBlockExpression -> container
-                    else -> ConvertToBlockBodyIntention.convert(container as JetDeclarationWithBody).bodyExpression!!
-                } as JetBlockExpression
+                    is KtBlockExpression -> container
+                    else -> ConvertToBlockBodyIntention.convert(container as KtDeclarationWithBody).bodyExpression!!
+                } as KtBlockExpression
 
                 if (actualContainer != container) {
                     val bodyExpression = actualContainer.statements.first()!!
-                    originalElement = (bodyExpression as? JetReturnExpression)?.returnedExpression ?: bodyExpression
+                    originalElement = (bodyExpression as? KtReturnExpression)?.returnedExpression ?: bodyExpression
                 }
 
                 val typeInfo = TypeInfo(
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByNamedArgumentActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByNamedArgumentActionFactory.kt
index 04283de2cef..4e4583f362a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByNamedArgumentActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByNamedArgumentActionFactory.kt
@@ -30,23 +30,23 @@ import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 
-public object CreateParameterByNamedArgumentActionFactory: CreateParameterFromUsageFactory<JetValueArgument>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetValueArgument? {
-        val argument = QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetValueArgument>()) ?: return null
+public object CreateParameterByNamedArgumentActionFactory: CreateParameterFromUsageFactory<KtValueArgument>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtValueArgument? {
+        val argument = QuickFixUtil.getParentElementOfType(diagnostic, javaClass<KtValueArgument>()) ?: return null
         return if (argument.isNamed()) argument else null
     }
 
-    override fun extractFixData(element: JetValueArgument, diagnostic: Diagnostic): CreateParameterData<JetValueArgument>? {
-        val result = (diagnostic.psiFile as? JetFile)?.analyzeFullyAndGetResult() ?: return null
+    override fun extractFixData(element: KtValueArgument, diagnostic: Diagnostic): CreateParameterData<KtValueArgument>? {
+        val result = (diagnostic.psiFile as? KtFile)?.analyzeFullyAndGetResult() ?: return null
         val context = result.bindingContext
 
         val name = element.getArgumentName()?.text ?: return null
         val argumentExpression = element.getArgumentExpression()
 
-        val callElement = element.getStrictParentOfType<JetCallElement>() ?: return null
+        val callElement = element.getStrictParentOfType<KtCallElement>() ?: return null
         val functionDescriptor = callElement.getResolvedCall(context)?.resultingDescriptor as? FunctionDescriptor ?: return null
         val callable = DescriptorToSourceUtilsIde.getAnyDeclaration(callElement.project, functionDescriptor) ?: return null
-        if (!((callable is JetFunction || callable is JetClass) && callable.canRefactor())) return null
+        if (!((callable is KtFunction || callable is KtClass) && callable.canRefactor())) return null
 
         val anyType = functionDescriptor.builtIns.anyType
         val paramType = argumentExpression?.guessTypes(context, result.moduleDescriptor)?.let {
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByRefActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByRefActionFactory.kt
index b6e2e1f1eb9..6a78e4669fc 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByRefActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByRefActionFactory.kt
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.guessT
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetValVar
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getAssignmentByLHS
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElement
@@ -40,23 +40,23 @@ import org.jetbrains.kotlin.psi.psiUtil.parents
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.scopes.utils.asJetScope
 import org.jetbrains.kotlin.resolve.source.getPsi
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import java.util.*
 
-object CreateParameterByRefActionFactory : CreateParameterFromUsageFactory<JetSimpleNameExpression>() {
-    override fun getElementOfInterest(diagnostic: Diagnostic): JetSimpleNameExpression? {
-        val refExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetSimpleNameExpression>()) ?: return null
+object CreateParameterByRefActionFactory : CreateParameterFromUsageFactory<KtSimpleNameExpression>() {
+    override fun getElementOfInterest(diagnostic: Diagnostic): KtSimpleNameExpression? {
+        val refExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass<KtSimpleNameExpression>()) ?: return null
         if (refExpr.getQualifiedElement() != refExpr) return null
-        if (refExpr.getReferencedNameElementType() != JetTokens.IDENTIFIER) return null
+        if (refExpr.getReferencedNameElementType() != KtTokens.IDENTIFIER) return null
         return refExpr
     }
 
     override fun extractFixData(
-            element: JetSimpleNameExpression,
+            element: KtSimpleNameExpression,
             diagnostic: Diagnostic
-    ): CreateParameterData<JetSimpleNameExpression>? {
-        val result = (diagnostic.psiFile as? JetFile)?.analyzeFullyAndGetResult() ?: return null
+    ): CreateParameterData<KtSimpleNameExpression>? {
+        val result = (diagnostic.psiFile as? KtFile)?.analyzeFullyAndGetResult() ?: return null
         val context = result.bindingContext
         val moduleDescriptor = result.moduleDescriptor
 
@@ -74,35 +74,35 @@ object CreateParameterByRefActionFactory : CreateParameterFromUsageFactory<JetSi
 
         fun chooseFunction(): PsiElement? {
             if (varExpected) return null
-            return element.parents.filter { it is JetNamedFunction || it is JetSecondaryConstructor }.firstOrNull()
+            return element.parents.filter { it is KtNamedFunction || it is KtSecondaryConstructor }.firstOrNull()
         }
 
-        fun chooseContainingClass(it: PsiElement): JetClass? {
+        fun chooseContainingClass(it: PsiElement): KtClass? {
             valOrVar = if (varExpected) JetValVar.Var else JetValVar.Val
-            return it.parents.firstIsInstanceOrNull<JetClassOrObject>() as? JetClass
+            return it.parents.firstIsInstanceOrNull<KtClassOrObject>() as? KtClass
         }
 
         // todo: skip lambdas for now because Change Signature doesn't apply to them yet
         fun chooseContainerPreferringClass(): PsiElement? {
             return element.parents
                     .filter {
-                        it is JetNamedFunction || it is JetSecondaryConstructor || it is JetPropertyAccessor ||
-                        it is JetClassBody || it is JetClassInitializer || it is JetDelegationSpecifier
+                        it is KtNamedFunction || it is KtSecondaryConstructor || it is KtPropertyAccessor ||
+                        it is KtClassBody || it is KtClassInitializer || it is KtDelegationSpecifier
                     }
                     .firstOrNull()
                     ?.let {
                         when {
-                            (it is JetNamedFunction || it is JetSecondaryConstructor) && varExpected,
-                            it is JetPropertyAccessor -> chooseContainingClass(it)
-                            it is JetClassInitializer -> it.parent?.parent as? JetClass
-                            it is JetDelegationSpecifier -> {
-                                val klass = it.getStrictParentOfType<JetClassOrObject>()
-                                if (klass is JetClass && !klass.isInterface() && klass !is JetEnumEntry) klass else null
+                            (it is KtNamedFunction || it is KtSecondaryConstructor) && varExpected,
+                            it is KtPropertyAccessor -> chooseContainingClass(it)
+                            it is KtClassInitializer -> it.parent?.parent as? KtClass
+                            it is KtDelegationSpecifier -> {
+                                val klass = it.getStrictParentOfType<KtClassOrObject>()
+                                if (klass is KtClass && !klass.isInterface() && klass !is KtEnumEntry) klass else null
                             }
-                            it is JetClassBody -> {
-                                val klass = it.parent as? JetClass
+                            it is KtClassBody -> {
+                                val klass = it.parent as? KtClass
                                 when {
-                                    klass is JetEnumEntry -> chooseContainingClass(klass)
+                                    klass is KtEnumEntry -> chooseContainingClass(klass)
                                     klass != null && klass.isInterface() -> null
                                     else -> klass
                                 }
@@ -131,7 +131,7 @@ object CreateParameterByRefActionFactory : CreateParameterFromUsageFactory<JetSi
     }
 }
 
-fun JetType.hasTypeParametersToAdd(functionDescriptor: FunctionDescriptor, context: BindingContext): Boolean {
+fun KtType.hasTypeParametersToAdd(functionDescriptor: FunctionDescriptor, context: BindingContext): Boolean {
     val typeParametersToAdd = LinkedHashSet(getTypeParameters())
     typeParametersToAdd.removeAll(functionDescriptor.typeParameters)
     if (typeParametersToAdd.isEmpty()) return false
@@ -143,7 +143,7 @@ fun JetType.hasTypeParametersToAdd(functionDescriptor: FunctionDescriptor, conte
                 }
 
                 is FunctionDescriptor -> {
-                    val function = functionDescriptor.source.getPsi() as? JetFunction
+                    val function = functionDescriptor.source.getPsi() as? KtFunction
                     function?.let { context[BindingContext.RESOLUTION_SCOPE, it.bodyExpression] }
                 }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFactory.kt
index 04a24f68b6e..5373abd9386 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFactory.kt
@@ -20,16 +20,16 @@ import com.intellij.codeInsight.intention.IntentionAction
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.quickfix.KotlinSingleIntentionActionFactoryWithDelegate
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.resolve.BindingContext
 
-data class CreateParameterData<E : JetElement>(
+data class CreateParameterData<E : KtElement>(
         val context: BindingContext,
         val parameterInfo: JetParameterInfo,
         val originalExpression: E
 )
 
-abstract class CreateParameterFromUsageFactory<E : JetElement>: KotlinSingleIntentionActionFactoryWithDelegate<E, CreateParameterData<E>>() {
+abstract class CreateParameterFromUsageFactory<E : KtElement>: KotlinSingleIntentionActionFactoryWithDelegate<E, CreateParameterData<E>>() {
     override fun createFix(data: CreateParameterData<E>): IntentionAction? {
         return CreateParameterFromUsageFix(
                 data.parameterInfo.callableDescriptor as FunctionDescriptor,
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFix.kt
index 025ecb28c3b..e6adf3a3984 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFix.kt
@@ -23,10 +23,10 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.JetBundle
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.CreateFromUsageFixBase
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.*
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
 
-public class CreateParameterFromUsageFix<E : JetElement>(
+public class CreateParameterFromUsageFix<E : KtElement>(
         val functionDescriptor: FunctionDescriptor,
         val parameterInfo: JetParameterInfo,
         val defaultValueContext: E
@@ -37,7 +37,7 @@ public class CreateParameterFromUsageFix<E : JetElement>(
 
     override fun startInWriteAction() = false
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         val config = object : JetChangeSignatureConfiguration {
             override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
                 return originalDescriptor.modify { it.addParameter(parameterInfo) }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/migration/MigrateTypeParameterListFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/migration/MigrateTypeParameterListFix.kt
index 0d8029c3d29..a81d6cf9916 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/migration/MigrateTypeParameterListFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/migration/MigrateTypeParameterListFix.kt
@@ -23,26 +23,26 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.quickfix.CleanupFix
 import org.jetbrains.kotlin.idea.quickfix.KotlinQuickFixAction
 import org.jetbrains.kotlin.idea.quickfix.JetSingleIntentionActionFactory
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetTypeParameterList
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtTypeParameterList
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 
-class MigrateTypeParameterListFix(typeParameterList: JetTypeParameterList)
-    : KotlinQuickFixAction<JetTypeParameterList>(typeParameterList), CleanupFix {
+class MigrateTypeParameterListFix(typeParameterList: KtTypeParameterList)
+    : KotlinQuickFixAction<KtTypeParameterList>(typeParameterList), CleanupFix {
 
     override fun getFamilyName(): String = "Migrate type parameter list syntax"
     override fun getText(): String  = familyName
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
-        val function = element.getStrictParentOfType<JetNamedFunction>() ?: return
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+        val function = element.getStrictParentOfType<KtNamedFunction>() ?: return
         function.addBefore(element, function.receiverTypeReference ?: function.nameIdentifier)
         element.delete()
     }
 
     companion object : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? {
-            val typeParameterList = diagnostic.psiElement as? JetTypeParameterList ?: return null
+            val typeParameterList = diagnostic.psiElement as? KtTypeParameterList ?: return null
             return MigrateTypeParameterListFix(typeParameterList)
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/quickfixUtil/quickfixUtil.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/quickfixUtil/quickfixUtil.kt
index cedabc303a9..641b4a97fac 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/quickfixUtil/quickfixUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/quickfixUtil/quickfixUtil.kt
@@ -21,8 +21,8 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.quickfix.KotlinQuickFixAction
 import org.jetbrains.kotlin.idea.quickfix.JetSingleIntentionActionFactory
-import org.jetbrains.kotlin.psi.JetPrimaryConstructor
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtPrimaryConstructor
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 
 inline fun <reified T : PsiElement> Diagnostic.createIntentionForFirstParentOfType(
@@ -36,7 +36,7 @@ fun createIntentionFactory(
     override fun createAction(diagnostic: Diagnostic) = factory(diagnostic)
 }
 
-public fun JetPrimaryConstructor.addConstructorKeyword(): PsiElement? {
-    val keyword = JetPsiFactory(this).createConstructorKeyword()
+public fun KtPrimaryConstructor.addConstructorKeyword(): PsiElement? {
+    val keyword = KtPsiFactory(this).createConstructorKeyword()
     return addAfter(keyword, getModifierList() ?: return null)
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/CallKindHandler.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/CallKindHandler.kt
index ebd4b0418a7..31451b5e6d8 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/CallKindHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/CallKindHandler.kt
@@ -21,26 +21,26 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelectorOrThis
 
 internal interface CallKindHandler {
-    val elementToReplace: JetElement
+    val elementToReplace: KtElement
 
     fun precheckReplacementPattern(pattern: ReplaceWithAnnotationAnalyzer.ReplacementExpression): Boolean
 
-    fun wrapGeneratedExpression(expression: JetExpression): JetElement
+    fun wrapGeneratedExpression(expression: KtExpression): KtElement
 
-    fun unwrapResult(result: JetElement): JetElement
+    fun unwrapResult(result: KtElement): KtElement
 }
 
-internal class CallExpressionHandler(callElement: JetExpression) : CallKindHandler {
+internal class CallExpressionHandler(callElement: KtExpression) : CallKindHandler {
     override val elementToReplace = callElement.getQualifiedExpressionForSelectorOrThis()
 
     override fun precheckReplacementPattern(pattern: ReplaceWithAnnotationAnalyzer.ReplacementExpression) = true
 
-    override fun wrapGeneratedExpression(expression: JetExpression) = expression
+    override fun wrapGeneratedExpression(expression: KtExpression) = expression
 
-    override fun unwrapResult(result: JetElement) = result
+    override fun unwrapResult(result: KtElement) = result
 }
 
-internal class AnnotationEntryHandler(annotationEntry: JetAnnotationEntry) : CallKindHandler {
+internal class AnnotationEntryHandler(annotationEntry: KtAnnotationEntry) : CallKindHandler {
     override val elementToReplace = annotationEntry
 
     override fun precheckReplacementPattern(pattern: ReplaceWithAnnotationAnalyzer.ReplacementExpression): Boolean {
@@ -50,13 +50,13 @@ internal class AnnotationEntryHandler(annotationEntry: JetAnnotationEntry) : Cal
 
     //TODO: how to prohibit wrapping replacement expression into anything?
 
-    override fun wrapGeneratedExpression(expression: JetExpression): JetAnnotationEntry {
-        return createByPattern("@Dummy($0)", expression) { JetPsiFactory(expression).createAnnotationEntry(it) }
+    override fun wrapGeneratedExpression(expression: KtExpression): KtAnnotationEntry {
+        return createByPattern("@Dummy($0)", expression) { KtPsiFactory(expression).createAnnotationEntry(it) }
     }
 
-    override fun unwrapResult(result: JetElement): JetAnnotationEntry {
-        result as JetAnnotationEntry
+    override fun unwrapResult(result: KtElement): KtAnnotationEntry {
+        result as KtAnnotationEntry
         val text = result.valueArguments.single().getArgumentExpression()!!.text
-        return result.replaced(JetPsiFactory(result).createAnnotationEntry("@" + text))
+        return result.replaced(KtPsiFactory(result).createAnnotationEntry("@" + text))
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/CallableUsageReplacementStrategy.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/CallableUsageReplacementStrategy.kt
index 7590fcd7c84..9c62d1d7440 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/CallableUsageReplacementStrategy.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/CallableUsageReplacementStrategy.kt
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.idea.intentions.setType
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.ShortenReferences
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.*
@@ -48,7 +48,7 @@ import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver
 import org.jetbrains.kotlin.resolve.scopes.utils.asJetScope
 import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.*
 
@@ -56,7 +56,7 @@ class CallableUsageReplacementStrategy(
         private val replacement: ReplaceWithAnnotationAnalyzer.ReplacementExpression
 ) : UsageReplacementStrategy {
 
-    override fun createReplacer(usage: JetSimpleNameExpression): (() -> JetElement)? {
+    override fun createReplacer(usage: KtSimpleNameExpression): (() -> KtElement)? {
         val bindingContext = usage.analyze(BodyResolveMode.PARTIAL)
         val resolvedCall = usage.getResolvedCall(bindingContext) ?: return null
         if (!resolvedCall.isReallySuccess()) return null
@@ -72,25 +72,25 @@ class CallableUsageReplacementStrategy(
         }
     }
 
-    private fun callTypeHandler(callElement: JetElement): CallKindHandler? {
+    private fun callTypeHandler(callElement: KtElement): CallKindHandler? {
         return when (callElement) {
-            is JetExpression -> CallExpressionHandler(callElement)
-            is JetAnnotationEntry -> AnnotationEntryHandler(callElement)
+            is KtExpression -> CallExpressionHandler(callElement)
+            is KtAnnotationEntry -> AnnotationEntryHandler(callElement)
             else -> null
         }
     }
 }
 
 private fun performCallReplacement(
-        element: JetSimpleNameExpression,
+        element: KtSimpleNameExpression,
         bindingContext: BindingContext,
         resolvedCall: ResolvedCall<out CallableDescriptor>,
-        callElement: JetElement,
+        callElement: KtElement,
         callKindHandler: CallKindHandler,
         replacement: ReplaceWithAnnotationAnalyzer.ReplacementExpression
-): JetElement {
+): KtElement {
     val project = element.project
-    val psiFactory = JetPsiFactory(project)
+    val psiFactory = KtPsiFactory(project)
     val descriptor = resolvedCall.resultingDescriptor
 
     val qualifiedExpression = callElement.getQualifiedExpressionForSelector()
@@ -112,13 +112,13 @@ private fun performCallReplacement(
 
     receiver?.mark(RECEIVER_VALUE_KEY)
 
-    val wrapper = if (elementToBeReplaced is JetExpression)
+    val wrapper = if (elementToBeReplaced is KtExpression)
         ConstructedExpressionWrapperWithIntroduceFeature(replacement.expression, bindingContext, elementToBeReplaced)
     else
         ConstructedExpressionWrapper(replacement.expression, bindingContext)
 
     //TODO: this@
-    for (thisExpression in replacement.expression.collectDescendantsOfType<JetThisExpression>()) {
+    for (thisExpression in replacement.expression.collectDescendantsOfType<KtThisExpression>()) {
         if (receiver != null) {
             wrapper.replaceExpression(thisExpression, receiver)
         }
@@ -131,15 +131,15 @@ private fun performCallReplacement(
 
     wrapper.processTypeParameterUsages(resolvedCall)
 
-    if (qualifiedExpression is JetSafeQualifiedExpression) {
+    if (qualifiedExpression is KtSafeQualifiedExpression) {
         (wrapper as ConstructedExpressionWrapperWithIntroduceFeature).wrapExpressionForSafeCall(receiver!!, receiverType)
     }
-    else if (callElement is JetBinaryExpression && callElement.operationToken == JetTokens.IDENTIFIER) {
+    else if (callElement is KtBinaryExpression && callElement.operationToken == KtTokens.IDENTIFIER) {
         wrapper.keepInfixFormIfPossible()
     }
 
     if (receiver != null && wrapper is ConstructedExpressionWrapperWithIntroduceFeature) {
-        val thisReplaced = wrapper.expression.collectDescendantsOfType<JetExpression> { it[RECEIVER_VALUE_KEY] }
+        val thisReplaced = wrapper.expression.collectDescendantsOfType<KtExpression> { it[RECEIVER_VALUE_KEY] }
         if (receiver.shouldKeepValue(thisReplaced.size)) {
             wrapper.introduceValue(receiver, receiverType, thisReplaced)
         }
@@ -147,13 +147,13 @@ private fun performCallReplacement(
 
     if (wrapper is ConstructedExpressionWrapperWithIntroduceFeature) {
         for ((parameter, value, valueType) in introduceValuesForParameters) {
-            val usagesReplaced = wrapper.expression.collectDescendantsOfType<JetExpression> { it[PARAMETER_VALUE_KEY] == parameter }
+            val usagesReplaced = wrapper.expression.collectDescendantsOfType<KtExpression> { it[PARAMETER_VALUE_KEY] == parameter }
             wrapper.introduceValue(value, valueType, usagesReplaced, nameSuggestion = parameter.name.asString())
         }
     }
 
     val wrappedExpression = callKindHandler.wrapGeneratedExpression(wrapper.expression)
-    var result = elementToBeReplaced.replace(wrappedExpression) as JetElement
+    var result = elementToBeReplaced.replace(wrappedExpression) as KtElement
 
     val file = result.getContainingJetFile()
     replacement.fqNamesToImport
@@ -170,7 +170,7 @@ private fun performCallReplacement(
     commentSaver.restore(resultRange)
 
     @Suppress("UNCHECKED_CAST")
-    return callKindHandler.unwrapResult(resultRange.last as JetElement)
+    return callKindHandler.unwrapResult(resultRange.last as KtElement)
 }
 
 private fun ConstructedExpressionWrapper.processValueParameterUsages(
@@ -187,11 +187,11 @@ private fun ConstructedExpressionWrapper.processValueParameterUsages(
         argument.expression.put(PARAMETER_VALUE_KEY, parameter)
 
         val parameterName = parameter.name
-        val usages = expression.collectDescendantsOfType<JetExpression> {
+        val usages = expression.collectDescendantsOfType<KtExpression> {
             it[ReplaceWithAnnotationAnalyzer.PARAMETER_USAGE_KEY] == parameterName
         }
         usages.forEach {
-            val usageArgument = it.parent as? JetValueArgument
+            val usageArgument = it.parent as? KtValueArgument
             if (argument.isNamed) {
                 usageArgument?.mark(MAKE_ARGUMENT_NAMED_KEY)
             }
@@ -213,24 +213,24 @@ private fun ConstructedExpressionWrapper.processValueParameterUsages(
 
 private data class IntroduceValueForParameter(
         val parameter: ValueParameterDescriptor,
-        val value: JetExpression,
-        val valueType: JetType?)
+        val value: KtExpression,
+        val valueType: KtType?)
 
 private fun ConstructedExpressionWrapper.processTypeParameterUsages(resolvedCall: ResolvedCall<out CallableDescriptor>) {
     val typeParameters = resolvedCall.resultingDescriptor.original.typeParameters
 
     val callElement = resolvedCall.call.callElement
-    val callExpression = callElement as? JetCallExpression
+    val callExpression = callElement as? KtCallExpression
     val explicitTypeArgs = callExpression?.typeArgumentList?.arguments
     if (explicitTypeArgs != null && explicitTypeArgs.size() != typeParameters.size()) return
 
     for ((index, typeParameter) in typeParameters.withIndex()) {
         val parameterName = typeParameter.name
-        val usages = expression.collectDescendantsOfType<JetExpression> {
+        val usages = expression.collectDescendantsOfType<KtExpression> {
             it[ReplaceWithAnnotationAnalyzer.TYPE_PARAMETER_USAGE_KEY] == parameterName
         }
 
-        val factory = JetPsiFactory(callElement)
+        val factory = KtPsiFactory(callElement)
         val type = resolvedCall.typeArguments[typeParameter]!!
         val typeElement = if (explicitTypeArgs != null) { // we use explicit type arguments if available to avoid shortening
             val _typeElement = explicitTypeArgs[index].typeReference?.typeElement ?: continue
@@ -242,7 +242,7 @@ private fun ConstructedExpressionWrapper.processTypeParameterUsages(resolvedCall
 
         // for class literal ("X::class") we need type arguments only for kotlin.Array
         val typeClassifier = type.constructor.declarationDescriptor
-        val classLiteralTypeElement = if (typeElement is JetUserType && typeElement.typeArgumentList == null || typeClassifier == null || KotlinBuiltIns.isArray(type)) {
+        val classLiteralTypeElement = if (typeElement is KtUserType && typeElement.typeArgumentList == null || typeClassifier == null || KotlinBuiltIns.isArray(type)) {
             typeElement
         }
         else {
@@ -251,8 +251,8 @@ private fun ConstructedExpressionWrapper.processTypeParameterUsages(resolvedCall
 
         for (usage in usages) {
             val parent = usage.parent
-            if (parent is JetUserType) {
-                if (parent.parent is JetTypeReference && parent.parent.parent is JetClassLiteralExpression) {
+            if (parent is KtUserType) {
+                if (parent.parent is KtTypeReference && parent.parent.parent is KtClassLiteralExpression) {
                     parent.replace(classLiteralTypeElement)
                 }
                 else {
@@ -261,17 +261,17 @@ private fun ConstructedExpressionWrapper.processTypeParameterUsages(resolvedCall
             }
             else {
                 //TODO: tests for this?
-                replaceExpression(usage, JetPsiFactory(usage).createExpression(typeElement.text))
+                replaceExpression(usage, KtPsiFactory(usage).createExpression(typeElement.text))
             }
         }
     }
 }
 
-private fun ConstructedExpressionWrapperWithIntroduceFeature.wrapExpressionForSafeCall(receiver: JetExpression, receiverType: JetType?) {
-    val qualified = expression as? JetQualifiedExpression
+private fun ConstructedExpressionWrapperWithIntroduceFeature.wrapExpressionForSafeCall(receiver: KtExpression, receiverType: KtType?) {
+    val qualified = expression as? KtQualifiedExpression
     if (qualified != null) {
         if (qualified.receiverExpression[RECEIVER_VALUE_KEY]) {
-            if (qualified is JetSafeQualifiedExpression) return // already safe
+            if (qualified is KtSafeQualifiedExpression) return // already safe
             val selector = qualified.selectorExpression
             if (selector != null) {
                 expression = psiFactory.createExpressionByPattern("$0?.$1", receiver, selector)
@@ -281,7 +281,7 @@ private fun ConstructedExpressionWrapperWithIntroduceFeature.wrapExpressionForSa
     }
 
     if (expressionToBeReplaced.isUsedAsExpression(bindingContext)) {
-        val thisReplaced = expression.collectDescendantsOfType<JetExpression> { it[RECEIVER_VALUE_KEY] }
+        val thisReplaced = expression.collectDescendantsOfType<KtExpression> { it[RECEIVER_VALUE_KEY] }
         introduceValue(receiver, receiverType, thisReplaced, safeCall = true)
     }
     else {
@@ -290,39 +290,39 @@ private fun ConstructedExpressionWrapperWithIntroduceFeature.wrapExpressionForSa
 }
 
 private fun ConstructedExpressionWrapper.keepInfixFormIfPossible() {
-    val dotQualified = expression as? JetDotQualifiedExpression ?: return
+    val dotQualified = expression as? KtDotQualifiedExpression ?: return
     val receiver = dotQualified.receiverExpression
     if (!receiver[RECEIVER_VALUE_KEY]) return
-    val call = dotQualified.selectorExpression as? JetCallExpression ?: return
-    val nameExpression = call.calleeExpression as? JetSimpleNameExpression ?: return
+    val call = dotQualified.selectorExpression as? KtCallExpression ?: return
+    val nameExpression = call.calleeExpression as? KtSimpleNameExpression ?: return
     val argument = call.valueArguments.singleOrNull() ?: return
     if (argument.getArgumentName() != null) return
     val argumentExpression = argument.getArgumentExpression() ?: return
     expression = psiFactory.createExpressionByPattern("$0 ${nameExpression.text} $1", receiver, argumentExpression)
 }
 
-private fun JetExpression?.shouldKeepValue(usageCount: Int): Boolean {
+private fun KtExpression?.shouldKeepValue(usageCount: Int): Boolean {
     if (usageCount == 1) return false
     val sideEffectOnly = usageCount == 0
 
     return when (this) {
-        is JetSimpleNameExpression -> false
-        is JetQualifiedExpression -> receiverExpression.shouldKeepValue(usageCount) || selectorExpression.shouldKeepValue(usageCount)
-        is JetUnaryExpression -> operationToken in setOf(JetTokens.PLUSPLUS, JetTokens.MINUSMINUS) || baseExpression.shouldKeepValue(usageCount)
-        is JetStringTemplateExpression -> entries.any { if (sideEffectOnly) it.expression.shouldKeepValue(usageCount) else it is JetStringTemplateEntryWithExpression }
-        is JetThisExpression, is JetSuperExpression, is JetConstantExpression -> false
-        is JetParenthesizedExpression -> expression.shouldKeepValue(usageCount)
-        is JetArrayAccessExpression -> if (sideEffectOnly) arrayExpression.shouldKeepValue(usageCount) || indexExpressions.any { it.shouldKeepValue(usageCount) } else true
-        is JetBinaryExpression -> if (sideEffectOnly) left.shouldKeepValue(usageCount) || right.shouldKeepValue(usageCount) else true
-        is JetIfExpression -> if (sideEffectOnly) condition.shouldKeepValue(usageCount) || then.shouldKeepValue(usageCount) || `else`.shouldKeepValue(usageCount) else true
-        is JetBinaryExpressionWithTypeRHS -> true
+        is KtSimpleNameExpression -> false
+        is KtQualifiedExpression -> receiverExpression.shouldKeepValue(usageCount) || selectorExpression.shouldKeepValue(usageCount)
+        is KtUnaryExpression -> operationToken in setOf(KtTokens.PLUSPLUS, KtTokens.MINUSMINUS) || baseExpression.shouldKeepValue(usageCount)
+        is KtStringTemplateExpression -> entries.any { if (sideEffectOnly) it.expression.shouldKeepValue(usageCount) else it is KtStringTemplateEntryWithExpression }
+        is KtThisExpression, is KtSuperExpression, is KtConstantExpression -> false
+        is KtParenthesizedExpression -> expression.shouldKeepValue(usageCount)
+        is KtArrayAccessExpression -> if (sideEffectOnly) arrayExpression.shouldKeepValue(usageCount) || indexExpressions.any { it.shouldKeepValue(usageCount) } else true
+        is KtBinaryExpression -> if (sideEffectOnly) left.shouldKeepValue(usageCount) || right.shouldKeepValue(usageCount) else true
+        is KtIfExpression -> if (sideEffectOnly) condition.shouldKeepValue(usageCount) || then.shouldKeepValue(usageCount) || `else`.shouldKeepValue(usageCount) else true
+        is KtBinaryExpressionWithTypeRHS -> true
         else -> true
     }
 }
 
 private class Argument(
-        val expression: JetExpression,
-        val expressionType: JetType?,
+        val expression: KtExpression,
+        val expressionType: KtType?,
         val isNamed: Boolean = false,
         val isDefaultValue: Boolean = false)
 
@@ -354,7 +354,7 @@ private fun argumentForParameter(
             val expressionCopy = expression.copied()
 
             // clean up user data in original
-            expression.forEachDescendantOfType<JetExpression> { it.clear(ReplaceWithAnnotationAnalyzer.PARAMETER_USAGE_KEY) }
+            expression.forEachDescendantOfType<KtExpression> { it.clear(ReplaceWithAnnotationAnalyzer.PARAMETER_USAGE_KEY) }
 
             return Argument(expressionCopy, null/*TODO*/, isDefaultValue = true)
         }
@@ -368,7 +368,7 @@ private fun argumentForParameter(
             }
 
             val elementType = parameter.varargElementType!!
-            val expression = JetPsiFactory(project).buildExpression {
+            val expression = KtPsiFactory(project).buildExpression {
                 appendFixedText(arrayOfFunctionName(elementType))
                 appendFixedText("(")
                 for ((i, argument) in arguments.withIndex()) {
@@ -388,7 +388,7 @@ private fun argumentForParameter(
 }
 
 private fun postProcessInsertedCode(range: PsiChildRange): PsiChildRange {
-    val elements = range.filterIsInstance<JetElement>().toList()
+    val elements = range.filterIsInstance<KtElement>().toList()
 
     elements.forEach {
         introduceNamedArguments(it)
@@ -409,7 +409,7 @@ private fun postProcessInsertedCode(range: PsiChildRange): PsiChildRange {
             ShortenReferences.FilterResult.SKIP
         }
         else {
-            val thisReceiver = (element as? JetQualifiedExpression)?.receiverExpression as? JetThisExpression
+            val thisReceiver = (element as? KtQualifiedExpression)?.receiverExpression as? KtThisExpression
             if (thisReceiver != null && thisReceiver[USER_CODE_KEY]) // don't remove explicit 'this' coming from user's code
                 ShortenReferences.FilterResult.GO_INSIDE
             else
@@ -423,7 +423,7 @@ private fun postProcessInsertedCode(range: PsiChildRange): PsiChildRange {
 
     newElements.forEach {
         // clean up user data
-        it.forEachDescendantOfType<JetExpression> {
+        it.forEachDescendantOfType<KtExpression> {
             it.clear(USER_CODE_KEY)
             it.clear(ReplaceWithAnnotationAnalyzer.PARAMETER_USAGE_KEY)
             it.clear(ReplaceWithAnnotationAnalyzer.TYPE_PARAMETER_USAGE_KEY)
@@ -431,7 +431,7 @@ private fun postProcessInsertedCode(range: PsiChildRange): PsiChildRange {
             it.clear(RECEIVER_VALUE_KEY)
             it.clear(WAS_FUNCTION_LITERAL_ARGUMENT_KEY)
         }
-        it.forEachDescendantOfType<JetValueArgument> {
+        it.forEachDescendantOfType<KtValueArgument> {
             it.clear(MAKE_ARGUMENT_NAMED_KEY)
             it.clear(DEFAULT_PARAMETER_VALUE_KEY)
         }
@@ -440,16 +440,16 @@ private fun postProcessInsertedCode(range: PsiChildRange): PsiChildRange {
     return PsiChildRange(newElements.first(), newElements.last())
 }
 
-private fun introduceNamedArguments(result: JetElement) {
-    val callsToProcess = LinkedHashSet<JetCallExpression>()
-    result.forEachDescendantOfType<JetValueArgument> {
+private fun introduceNamedArguments(result: KtElement) {
+    val callsToProcess = LinkedHashSet<KtCallExpression>()
+    result.forEachDescendantOfType<KtValueArgument> {
         if (it[MAKE_ARGUMENT_NAMED_KEY] && !it.isNamed()) {
-            val callExpression = (it.parent as? JetValueArgumentList)?.parent as? JetCallExpression
+            val callExpression = (it.parent as? KtValueArgumentList)?.parent as? KtCallExpression
             callsToProcess.addIfNotNull(callExpression)
         }
     }
 
-    val psiFactory = JetPsiFactory(result)
+    val psiFactory = KtPsiFactory(result)
 
     for (callExpression in callsToProcess) {
         val bindingContext = callExpression.analyze(BodyResolveMode.PARTIAL)
@@ -459,7 +459,7 @@ private fun introduceNamedArguments(result: JetElement) {
         val argumentsToMakeNamed = callExpression.valueArguments.dropWhile { !it[MAKE_ARGUMENT_NAMED_KEY] }
         for (argument in argumentsToMakeNamed) {
             if (argument.isNamed()) continue
-            if (argument is JetFunctionLiteralArgument) continue
+            if (argument is KtFunctionLiteralArgument) continue
             val argumentMatch = resolvedCall.getArgumentMapping(argument) as ArgumentMatch
             val name = argumentMatch.valueParameter.name
             //TODO: not always correct for vararg's
@@ -474,26 +474,26 @@ private fun introduceNamedArguments(result: JetElement) {
     }
 }
 
-private fun dropArgumentsForDefaultValues(result: JetElement) {
+private fun dropArgumentsForDefaultValues(result: KtElement) {
     val project = result.project
     val newBindingContext = result.analyze()
     val argumentsToDrop = ArrayList<ValueArgument>()
 
     // we drop only those arguments that added to the code from some parameter's default
-    fun canDropArgument(argument: ValueArgument) = (argument as JetValueArgument)[DEFAULT_PARAMETER_VALUE_KEY]
+    fun canDropArgument(argument: ValueArgument) = (argument as KtValueArgument)[DEFAULT_PARAMETER_VALUE_KEY]
 
-    result.forEachDescendantOfType<JetCallExpression> { callExpression ->
+    result.forEachDescendantOfType<KtCallExpression> { callExpression ->
         val resolvedCall = callExpression.getResolvedCall(newBindingContext) ?: return@forEachDescendantOfType
 
         argumentsToDrop.addAll(OptionalParametersHelper.detectArgumentsToDropForDefaults(resolvedCall, project, ::canDropArgument))
     }
 
     for (argument in argumentsToDrop) {
-        argument as JetValueArgument
-        val argumentList = argument.parent as JetValueArgumentList
+        argument as KtValueArgument
+        val argumentList = argument.parent as KtValueArgumentList
         argumentList.removeArgument(argument)
         if (argumentList.arguments.isEmpty()) {
-            val callExpression = argumentList.parent as JetCallExpression
+            val callExpression = argumentList.parent as KtCallExpression
             if (callExpression.functionLiteralArguments.isNotEmpty()) {
                 argumentList.delete()
             }
@@ -501,7 +501,7 @@ private fun dropArgumentsForDefaultValues(result: JetElement) {
     }
 }
 
-private fun arrayOfFunctionName(elementType: JetType): String {
+private fun arrayOfFunctionName(elementType: KtType): String {
     return when {
         KotlinBuiltIns.isInt(elementType) -> "kotlin.intArrayOf"
         KotlinBuiltIns.isLong(elementType) -> "kotlin.longArrayOf"
@@ -516,22 +516,22 @@ private fun arrayOfFunctionName(elementType: JetType): String {
     }
 }
 
-private fun removeExplicitTypeArguments(result: JetElement) {
-    result.collectDescendantsOfType<JetTypeArgumentList>(canGoInside = { !it[USER_CODE_KEY] }) {
+private fun removeExplicitTypeArguments(result: KtElement) {
+    result.collectDescendantsOfType<KtTypeArgumentList>(canGoInside = { !it[USER_CODE_KEY] }) {
         RemoveExplicitTypeArgumentsIntention.isApplicableTo(it, approximateFlexible = true)
     }.forEach { it.delete() }
 }
 
-private fun simplifySpreadArrayOfArguments(result: JetElement) {
+private fun simplifySpreadArrayOfArguments(result: KtElement) {
     //TODO: test for nested
 
-    val argumentsToExpand = ArrayList<Pair<JetValueArgument, Collection<JetValueArgument>>>()
+    val argumentsToExpand = ArrayList<Pair<KtValueArgument, Collection<KtValueArgument>>>()
 
-    result.forEachDescendantOfType<JetValueArgument>(canGoInside = { !it[USER_CODE_KEY] }) { argument ->
+    result.forEachDescendantOfType<KtValueArgument>(canGoInside = { !it[USER_CODE_KEY] }) { argument ->
         if (argument.getSpreadElement() != null && !argument.isNamed()) {
             val argumentExpression = argument.getArgumentExpression() ?: return@forEachDescendantOfType
             val resolvedCall = argumentExpression.getResolvedCall(argumentExpression.analyze(BodyResolveMode.PARTIAL)) ?: return@forEachDescendantOfType
-            val callExpression = resolvedCall.call.callElement as? JetCallExpression ?: return@forEachDescendantOfType
+            val callExpression = resolvedCall.call.callElement as? KtCallExpression ?: return@forEachDescendantOfType
             if (CompileTimeConstantUtils.isArrayMethodCall(resolvedCall)) {
                 argumentsToExpand.add(argument to callExpression.valueArguments)
             }
@@ -543,8 +543,8 @@ private fun simplifySpreadArrayOfArguments(result: JetElement) {
     }
 }
 
-private fun JetValueArgument.replaceByMultiple(arguments: Collection<JetValueArgument>) {
-    val list = parent as JetValueArgumentList
+private fun KtValueArgument.replaceByMultiple(arguments: Collection<KtValueArgument>) {
+    val list = parent as KtValueArgumentList
     if (arguments.isEmpty()) {
         list.removeArgument(this)
     }
@@ -557,19 +557,19 @@ private fun JetValueArgument.replaceByMultiple(arguments: Collection<JetValueArg
     }
 }
 
-private fun restoreFunctionLiteralArguments(expression: JetElement) {
-    val callExpressions = ArrayList<JetCallExpression>()
+private fun restoreFunctionLiteralArguments(expression: KtElement) {
+    val callExpressions = ArrayList<KtCallExpression>()
 
-    expression.forEachDescendantOfType<JetExpression>(fun (expr) {
+    expression.forEachDescendantOfType<KtExpression>(fun (expr) {
         if (!expr[WAS_FUNCTION_LITERAL_ARGUMENT_KEY]) return
         assert(expr.unpackFunctionLiteral() != null)
 
-        val argument = expr.parent as? JetValueArgument ?: return
-        if (argument is JetFunctionLiteralArgument) return
+        val argument = expr.parent as? KtValueArgument ?: return
+        if (argument is KtFunctionLiteralArgument) return
         if (argument.isNamed()) return
-        val argumentList = argument.parent as? JetValueArgumentList ?: return
+        val argumentList = argument.parent as? KtValueArgumentList ?: return
         if (argument != argumentList.arguments.last()) return
-        val callExpression = argumentList.parent as? JetCallExpression ?: return
+        val callExpression = argumentList.parent as? KtCallExpression ?: return
         if (callExpression.functionLiteralArguments.isNotEmpty()) return
 
         val resolvedCall = callExpression.getResolvedCall(callExpression.analyze(BodyResolveMode.PARTIAL)) ?: return
@@ -585,11 +585,11 @@ private fun restoreFunctionLiteralArguments(expression: JetElement) {
 
 internal operator fun <T: Any> PsiElement.get(key: Key<T>): T? = getCopyableUserData(key)
 internal operator fun PsiElement.get(key: Key<Unit>): Boolean = getCopyableUserData(key) != null
-private fun <T: Any> JetElement.clear(key: Key<T>) = putCopyableUserData(key, null)
-private fun <T: Any> JetElement.put(key: Key<T>, value: T) = putCopyableUserData(key, value)
-private fun JetElement.mark(key: Key<Unit>) = putCopyableUserData(key, Unit)
+private fun <T: Any> KtElement.clear(key: Key<T>) = putCopyableUserData(key, null)
+private fun <T: Any> KtElement.put(key: Key<T>, value: T) = putCopyableUserData(key, value)
+private fun KtElement.mark(key: Key<Unit>) = putCopyableUserData(key, Unit)
 
-private fun <T: JetElement> T.marked(key: Key<Unit>): T {
+private fun <T: KtElement> T.marked(key: Key<Unit>): T {
     putCopyableUserData(key, Unit)
     return this
 }
@@ -605,14 +605,14 @@ private val MAKE_ARGUMENT_NAMED_KEY = Key<Unit>("MAKE_ARGUMENT_NAMED")
 private val DEFAULT_PARAMETER_VALUE_KEY = Key<Unit>("DEFAULT_PARAMETER_VALUE")
 
 private open class ConstructedExpressionWrapper(
-        var expression: JetExpression,
+        var expression: KtExpression,
         val bindingContext: BindingContext
 ) {
-    val psiFactory = JetPsiFactory(expression)
+    val psiFactory = KtPsiFactory(expression)
 
-    public fun replaceExpression(oldExpression: JetExpression, newExpression: JetExpression): JetExpression {
+    public fun replaceExpression(oldExpression: KtExpression, newExpression: KtExpression): KtExpression {
         assert(expression.isAncestor(oldExpression))
-        val result = oldExpression.replace(newExpression) as JetExpression
+        val result = oldExpression.replace(newExpression) as KtExpression
         if (oldExpression == expression) {
             expression = result
         }
@@ -621,16 +621,16 @@ private open class ConstructedExpressionWrapper(
 }
 
 private class ConstructedExpressionWrapperWithIntroduceFeature(
-        expression: JetExpression,
+        expression: KtExpression,
         bindingContext: BindingContext,
-        val expressionToBeReplaced: JetExpression
+        val expressionToBeReplaced: KtExpression
 ) : ConstructedExpressionWrapper(expression, bindingContext) {
-    val addedStatements = ArrayList<JetExpression>()
+    val addedStatements = ArrayList<KtExpression>()
 
     public fun introduceValue(
-            value: JetExpression,
-            valueType: JetType?,
-            usages: Collection<JetExpression>,
+            value: KtExpression,
+            valueType: KtType?,
+            usages: Collection<KtExpression>,
             nameSuggestion: String? = null,
             safeCall: Boolean = false
     ) {
@@ -655,12 +655,12 @@ private class ConstructedExpressionWrapperWithIntroduceFeature(
         fun isNameUsed(name: String) = collectNameUsages(expression, name).any { nameUsage -> usages.none { it.isAncestor(nameUsage) } }
 
         if (!safeCall) {
-            val block = expressionToBeReplaced.parent as? JetBlockExpression
+            val block = expressionToBeReplaced.parent as? KtBlockExpression
             if (block != null) {
                 val resolutionScope = bindingContext[BindingContext.RESOLUTION_SCOPE, expressionToBeReplaced]
 
                 if (usages.isNotEmpty()) {
-                    var explicitType: JetType? = null
+                    var explicitType: KtType? = null
                     if (valueType != null && !ErrorUtils.containsErrorType(valueType)) {
                         val valueTypeWithoutExpectedType = value.computeTypeInContext(
                                 resolutionScope!!,
@@ -676,8 +676,8 @@ private class ConstructedExpressionWrapperWithIntroduceFeature(
                         resolutionScope!!.getLocalVariable(Name.identifier(name)) == null && !isNameUsed(name)
                     }
 
-                    var declaration = psiFactory.createDeclarationByPattern<JetVariableDeclaration>("val $0 = $1", name, value)
-                    declaration = block.addBefore(declaration, expressionToBeReplaced) as JetVariableDeclaration
+                    var declaration = psiFactory.createDeclarationByPattern<KtVariableDeclaration>("val $0 = $1", name, value)
+                    declaration = block.addBefore(declaration, expressionToBeReplaced) as KtVariableDeclaration
                     block.addBefore(psiFactory.createNewLine(), expressionToBeReplaced)
 
                     if (explicitType != null) {
@@ -689,7 +689,7 @@ private class ConstructedExpressionWrapperWithIntroduceFeature(
                     addedStatements.add(declaration)
                 }
                 else {
-                    addedStatements.add(block.addBefore(value, expressionToBeReplaced) as JetExpression)
+                    addedStatements.add(block.addBefore(value, expressionToBeReplaced) as KtExpression)
                     block.addBefore(psiFactory.createNewLine(), expressionToBeReplaced)
                 }
                 return
@@ -709,7 +709,7 @@ private class ConstructedExpressionWrapperWithIntroduceFeature(
         }
     }
 
-    private fun collectNameUsages(scope: JetExpression, name: String)
-            = scope.collectDescendantsOfType<JetSimpleNameExpression> { it.getReceiverExpression() == null && it.getReferencedName() == name }
+    private fun collectNameUsages(scope: KtExpression, name: String)
+            = scope.collectDescendantsOfType<KtSimpleNameExpression> { it.getReceiverExpression() == null && it.getReferencedName() == name }
 }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ClassUsageReplacementStrategy.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ClassUsageReplacementStrategy.kt
index b3bb85ed43f..0682b5f2f3c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ClassUsageReplacementStrategy.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ClassUsageReplacementStrategy.kt
@@ -24,26 +24,26 @@ import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelectorOrThis
 import org.jetbrains.kotlin.utils.addToStdlib.check
 
 class ClassUsageReplacementStrategy(
-        typeReplacement: JetUserType?,
+        typeReplacement: KtUserType?,
         constructorReplacement: ReplaceWithAnnotationAnalyzer.ReplacementExpression?,
         private val project: Project
 ) : UsageReplacementStrategy {
 
-    private val factory = JetPsiFactory(project)
+    private val factory = KtPsiFactory(project)
 
     private val typeReplacement = typeReplacement?.check { it.referenceExpression != null }
     private val typeReplacementQualifierAsExpression = typeReplacement?.qualifier?.let { factory.createExpression(it.text) }
 
     private val constructorReplacementStrategy = constructorReplacement?.let { CallableUsageReplacementStrategy(it) }
 
-    override fun createReplacer(usage: JetSimpleNameExpression): (() -> JetElement)? {
-        if (usage !is JetNameReferenceExpression) return null
+    override fun createReplacer(usage: KtSimpleNameExpression): (() -> KtElement)? {
+        if (usage !is KtNameReferenceExpression) return null
 
         constructorReplacementStrategy?.createReplacer(usage)?.let { return it }
 
         val parent = usage.parent
         when (parent) {
-            is JetUserType -> {
+            is KtUserType -> {
                 if (typeReplacement == null) return null
                 return {
                     val replaced = parent.replaced(typeReplacement)
@@ -51,7 +51,7 @@ class ClassUsageReplacementStrategy(
                 } //TODO: type arguments and type arguments of outer class are lost
             }
 
-            is JetCallExpression -> {
+            is KtCallExpression -> {
                 if (usage != parent.calleeExpression) return null
                 when {
 //                    constructorReplacementStrategy != null -> return constructorReplacementStrategy.createReplacer(usage)
@@ -64,7 +64,7 @@ class ClassUsageReplacementStrategy(
         }
     }
 
-    private fun replaceConstructorCallWithOtherTypeConstruction(callExpression: JetCallExpression): JetElement {
+    private fun replaceConstructorCallWithOtherTypeConstruction(callExpression: KtCallExpression): KtElement {
         callExpression.calleeExpression!!.replace(typeReplacement!!.referenceExpression!!)
 
         val expressionToReplace = callExpression.getQualifiedExpressionForSelectorOrThis()
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageFix.kt
index 37a3a62139b..e70434dab06 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageFix.kt
@@ -25,12 +25,12 @@ import org.jetbrains.kotlin.idea.core.targetDescriptors
 import org.jetbrains.kotlin.idea.quickfix.CleanupFix
 import org.jetbrains.kotlin.idea.quickfix.JetSingleIntentionActionFactory
 import org.jetbrains.kotlin.idea.quickfix.moveCaret
-import org.jetbrains.kotlin.psi.JetImportDirective
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtImportDirective
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.resolve.calls.callUtil.getCalleeExpressionIfAny
 
 public class DeprecatedSymbolUsageFix(
-        element: JetSimpleNameExpression/*TODO?*/,
+        element: KtSimpleNameExpression/*TODO?*/,
         replaceWith: ReplaceWith
 ) : DeprecatedSymbolUsageFixBase(element, replaceWith), CleanupFix, HighPriorityAction {
 
@@ -50,7 +50,7 @@ public class DeprecatedSymbolUsageFix(
             return DeprecatedSymbolUsageFix(nameExpression, replacement)
         }
 
-        public fun isImportToBeRemoved(import: JetImportDirective): Boolean {
+        public fun isImportToBeRemoved(import: KtImportDirective): Boolean {
             return !import.isAllUnder
                    && import.targetDescriptors().all { DeprecatedSymbolUsageFixBase.fetchReplaceWithPattern(it, import.project) != null }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageFixBase.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageFixBase.kt
index 445537fea25..a3960f2d868 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageFixBase.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageFixBase.kt
@@ -26,9 +26,9 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.idea.core.OptionalParametersHelper
 import org.jetbrains.kotlin.idea.quickfix.KotlinQuickFixAction
-import org.jetbrains.kotlin.psi.JetConstructorCalleeExpression
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtConstructorCalleeExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.annotations.argumentValue
 import org.jetbrains.kotlin.resolve.constants.StringValue
@@ -38,9 +38,9 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.hasDefaultValue
 //TODO: different replacements for property accessors
 
 public abstract class DeprecatedSymbolUsageFixBase(
-        element: JetSimpleNameExpression,
+        element: KtSimpleNameExpression,
         val replaceWith: ReplaceWith
-) : KotlinQuickFixAction<JetSimpleNameExpression>(element) {
+) : KotlinQuickFixAction<KtSimpleNameExpression>(element) {
 
     override fun isAvailable(project: Project, editor: Editor?, file: PsiFile): Boolean {
         if (!super.isAvailable(project, editor, file)) return false
@@ -48,7 +48,7 @@ public abstract class DeprecatedSymbolUsageFixBase(
         return strategy != null && strategy.createReplacer(element) != null
     }
 
-    final override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+    final override fun invoke(project: Project, editor: Editor?, file: KtFile) {
         val strategy = UsageReplacementStrategy.build(element, replaceWith, recheckAnnotation = false)!!
         invoke(strategy, project, editor)
     }
@@ -77,7 +77,7 @@ public abstract class DeprecatedSymbolUsageFixBase(
         }
 
         data class Data(
-                val nameExpression: JetSimpleNameExpression,
+                val nameExpression: KtSimpleNameExpression,
                 val replaceWith: ReplaceWith,
                 val descriptor: DeclarationDescriptor
         )
@@ -93,9 +93,9 @@ public abstract class DeprecatedSymbolUsageFixBase(
                             else -> null
                         } ?: return null
             */
-            val nameExpression: JetSimpleNameExpression = (if (psiElement is JetSimpleNameExpression)
+            val nameExpression: KtSimpleNameExpression = (if (psiElement is KtSimpleNameExpression)
                 psiElement
-            else if (psiElement is JetConstructorCalleeExpression)
+            else if (psiElement is KtConstructorCalleeExpression)
                 psiElement.constructorReferenceExpression
             else
                 null) ?: return null
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageInWholeProjectFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageInWholeProjectFix.kt
index d654abafb94..d68a7733028 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageInWholeProjectFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageInWholeProjectFix.kt
@@ -30,7 +30,7 @@ import com.intellij.util.ui.UIUtil
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.core.targetDescriptors
 import org.jetbrains.kotlin.idea.quickfix.JetSingleIntentionActionFactory
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.stubindex.JetSourceFilterScope
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
@@ -42,7 +42,7 @@ import org.jetbrains.kotlin.renderer.NameShortness
 import org.jetbrains.kotlin.renderer.ParameterNameRenderingPolicy
 
 public class DeprecatedSymbolUsageInWholeProjectFix(
-        element: JetSimpleNameExpression,
+        element: KtSimpleNameExpression,
         replaceWith: ReplaceWith,
         private val text: String
 ) : DeprecatedSymbolUsageFixBase(element, replaceWith) {
@@ -69,7 +69,7 @@ public class DeprecatedSymbolUsageInWholeProjectFix(
                         val usages = runReadAction {
                             val searchScope = JetSourceFilterScope.kotlinSources(GlobalSearchScope.projectScope(project), project)
                             ReferencesSearch.search(psiElement, searchScope)
-                                    .filterIsInstance<JetSimpleNameReference>()
+                                    .filterIsInstance<KtSimpleNameReference>()
                                     .map { ref -> ref.expression }
                         }
                         replaceUsages(project, usages, replacementStrategy)
@@ -77,28 +77,28 @@ public class DeprecatedSymbolUsageInWholeProjectFix(
                 })
     }
 
-    private fun targetPsiElement(): JetDeclaration? {
+    private fun targetPsiElement(): KtDeclaration? {
         val referenceTarget = element.mainReference.resolve()
         return when (referenceTarget) {
-            is JetNamedFunction -> referenceTarget
-            is JetProperty -> referenceTarget
-            is JetConstructor<*> -> referenceTarget.getContainingClassOrObject() //TODO: constructor can be deprecated itself
+            is KtNamedFunction -> referenceTarget
+            is KtProperty -> referenceTarget
+            is KtConstructor<*> -> referenceTarget.getContainingClassOrObject() //TODO: constructor can be deprecated itself
             else -> null
         }
     }
 
-    private fun replaceUsages(project: Project, usages: Collection<JetSimpleNameExpression>, replacementStrategy: UsageReplacementStrategy) {
+    private fun replaceUsages(project: Project, usages: Collection<KtSimpleNameExpression>, replacementStrategy: UsageReplacementStrategy) {
         UIUtil.invokeLaterIfNeeded {
             project.executeWriteCommand(text) {
                 // we should delete imports later to not affect other usages
-                val importsToDelete = arrayListOf<JetImportDirective>()
+                val importsToDelete = arrayListOf<KtImportDirective>()
 
                 for (usage in usages) {
                     try {
                         if (!usage.isValid) continue // TODO: nested calls
 
                         //TODO: keep the import if we don't know how to replace some of the usages
-                        val importDirective = usage.getStrictParentOfType<JetImportDirective>()
+                        val importDirective = usage.getStrictParentOfType<KtImportDirective>()
                         if (importDirective != null) {
                             if (!importDirective.isAllUnder && importDirective.targetDescriptors().size() == 1) {
                                 importsToDelete.add(importDirective)
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt
index 8fbe00737ff..30733215407 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.idea.core.copied
 import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.imports.importableFqName
 import org.jetbrains.kotlin.idea.intentions.InsertExplicitTypeArgumentsIntention
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.idea.references.canBeResolvedViaImport
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
@@ -60,7 +60,7 @@ object ReplaceWithAnnotationAnalyzer {
     public val TYPE_PARAMETER_USAGE_KEY: Key<Name> = Key("TYPE_PARAMETER_USAGE")
 
     public data class ReplacementExpression(
-            val expression: JetExpression,
+            val expression: KtExpression,
             val fqNamesToImport: Collection<FqName>
     ) {
         fun copy() = ReplacementExpression(expression.copied(), fqNamesToImport)
@@ -83,7 +83,7 @@ object ReplaceWithAnnotationAnalyzer {
             symbolDescriptor: CallableDescriptor,
             resolutionFacade: ResolutionFacade
     ): ReplacementExpression? {
-        val psiFactory = JetPsiFactory(resolutionFacade.project)
+        val psiFactory = KtPsiFactory(resolutionFacade.project)
         var expression = try {
             psiFactory.createExpression(annotation.pattern)
         }
@@ -99,8 +99,8 @@ object ReplaceWithAnnotationAnalyzer {
 
         var bindingContext = analyzeInContext(expression, module, scope, resolutionFacade)
 
-        val typeArgsToAdd = ArrayList<Pair<JetCallExpression, JetTypeArgumentList>>()
-        expression.forEachDescendantOfType<JetCallExpression> {
+        val typeArgsToAdd = ArrayList<Pair<KtCallExpression, KtTypeArgumentList>>()
+        expression.forEachDescendantOfType<KtCallExpression> {
             if (InsertExplicitTypeArgumentsIntention.isApplicableTo(it, bindingContext)) {
                 typeArgsToAdd.add(it to InsertExplicitTypeArgumentsIntention.createTypeArguments(it, bindingContext)!!)
             }
@@ -115,10 +115,10 @@ object ReplaceWithAnnotationAnalyzer {
             bindingContext = analyzeInContext(expression, module, scope, resolutionFacade)
         }
 
-        val receiversToAdd = ArrayList<Pair<JetExpression, JetExpression>>()
+        val receiversToAdd = ArrayList<Pair<KtExpression, KtExpression>>()
         val importFqNames = importFqNames(annotation).toMutableSet()
 
-        expression.forEachDescendantOfType<JetSimpleNameExpression> { expression ->
+        expression.forEachDescendantOfType<KtSimpleNameExpression> { expression ->
             val target = bindingContext[BindingContext.REFERENCE_TARGET, expression] ?: return@forEachDescendantOfType
 
             //TODO: other types of references ('[]' etc)
@@ -152,7 +152,7 @@ object ReplaceWithAnnotationAnalyzer {
 
         // add receivers in reverse order because arguments of a call were processed after the callee's name
         for ((expr, receiverExpression) in receiversToAdd.reversed()) {
-            val expressionToReplace = expr.parent as? JetCallExpression ?: expr
+            val expressionToReplace = expr.parent as? KtCallExpression ?: expr
             val newExpr = expressionToReplace.replaced(psiFactory.createExpressionByPattern("$0.$1", receiverExpression, expressionToReplace))
             if (expressionToReplace == expression) {
                 expression = newExpr
@@ -166,15 +166,15 @@ object ReplaceWithAnnotationAnalyzer {
             annotation: ReplaceWith,
             symbolDescriptor: ClassDescriptor,
             resolutionFacade: ResolutionFacade
-    ): JetUserType? {
-        val psiFactory = JetPsiFactory(resolutionFacade.project)
+    ): KtUserType? {
+        val psiFactory = KtPsiFactory(resolutionFacade.project)
         val typeReference = try {
             psiFactory.createType(annotation.pattern)
         }
         catch(e: Exception) {
             return null
         }
-        if (typeReference.typeElement !is JetUserType) return null
+        if (typeReference.typeElement !is KtUserType) return null
 
         val module = symbolDescriptor.module
 
@@ -185,10 +185,10 @@ object ReplaceWithAnnotationAnalyzer {
         val bindingTrace = BindingTraceContext()
         typeResolver.resolvePossiblyBareType(TypeResolutionContext(scope, bindingTrace, false, true), typeReference)
 
-        val typesToQualify = ArrayList<Pair<JetNameReferenceExpression, FqName>>()
+        val typesToQualify = ArrayList<Pair<KtNameReferenceExpression, FqName>>()
 
-        typeReference.forEachDescendantOfType<JetNameReferenceExpression> { expression ->
-            val parentType = expression.parent as? JetUserType ?: return@forEachDescendantOfType
+        typeReference.forEachDescendantOfType<KtNameReferenceExpression> { expression ->
+            val parentType = expression.parent as? KtUserType ?: return@forEachDescendantOfType
             if (parentType.qualifier != null) return@forEachDescendantOfType
             val targetClass = bindingTrace.bindingContext[BindingContext.REFERENCE_TARGET, expression] as? ClassDescriptor ?: return@forEachDescendantOfType
             val fqName = targetClass.fqNameUnsafe
@@ -198,10 +198,10 @@ object ReplaceWithAnnotationAnalyzer {
         }
 
         for ((nameExpression, fqName) in typesToQualify) {
-            nameExpression.mainReference.bindToFqName(fqName, JetSimpleNameReference.ShorteningMode.NO_SHORTENING)
+            nameExpression.mainReference.bindToFqName(fqName, KtSimpleNameReference.ShorteningMode.NO_SHORTENING)
         }
 
-        return typeReference.typeElement as JetUserType
+        return typeReference.typeElement as KtUserType
     }
 
     private fun buildExplicitImportsScope(annotation: ReplaceWith, resolutionFacade: ResolutionFacade, module: ModuleDescriptor): ExplicitImportsScope {
@@ -219,7 +219,7 @@ object ReplaceWithAnnotationAnalyzer {
     }
 
     private fun analyzeInContext(
-            expression: JetExpression,
+            expression: KtExpression,
             module: ModuleDescriptor,
             scope: LexicalScope,
             resolutionFacade: ResolutionFacade
@@ -237,7 +237,7 @@ object ReplaceWithAnnotationAnalyzer {
         return traceContext.bindingContext
     }
 
-    private fun getResolutionScope(descriptor: DeclarationDescriptor, ownerDescriptor: DeclarationDescriptor, additionalScopes: Collection<JetScope>): LexicalScope? {
+    private fun getResolutionScope(descriptor: DeclarationDescriptor, ownerDescriptor: DeclarationDescriptor, additionalScopes: Collection<KtScope>): LexicalScope? {
         return when (descriptor) {
             is PackageFragmentDescriptor -> {
                 val moduleDescriptor = descriptor.containingDeclaration
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/UsageReplacementStrategy.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/UsageReplacementStrategy.kt
index faa838a0bb7..9b43b2c76a4 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/UsageReplacementStrategy.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/UsageReplacementStrategy.kt
@@ -21,17 +21,17 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.references.mainReference
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.isReallySuccess
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 
 interface UsageReplacementStrategy {
-    fun createReplacer(usage: JetSimpleNameExpression): (() -> JetElement)?
+    fun createReplacer(usage: KtSimpleNameExpression): (() -> KtElement)?
 
     companion object {
-        fun build(element: JetSimpleNameExpression, replaceWith: ReplaceWith, recheckAnnotation: Boolean): UsageReplacementStrategy? {
+        fun build(element: KtSimpleNameExpression, replaceWith: ReplaceWith, recheckAnnotation: Boolean): UsageReplacementStrategy? {
             val resolutionFacade = element.getResolutionFacade()
             val bindingContext = resolutionFacade.analyze(element, BodyResolveMode.PARTIAL)
             var target = element.mainReference.resolveToDescriptors(bindingContext).singleOrNull() ?: return null
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/AbstractPullPushMembersHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/AbstractPullPushMembersHandler.kt
index 2155f56f2f8..e1ea4200abb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/AbstractPullPushMembersHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/AbstractPullPushMembersHandler.kt
@@ -52,8 +52,8 @@ public abstract class AbstractPullPushMembersHandler(
 
     protected abstract fun invoke(project: Project,
                                   editor: Editor?,
-                                  classOrObject: JetClassOrObject?,
-                                  member: JetNamedDeclaration?,
+                                  classOrObject: KtClassOrObject?,
+                                  member: KtNamedDeclaration?,
                                   dataContext: DataContext?)
 
     override fun invoke(project: Project, editor: Editor, file: PsiFile, dataContext: DataContext?) {
@@ -61,7 +61,7 @@ public abstract class AbstractPullPushMembersHandler(
         editor.scrollingModel.scrollToCaret(ScrollType.MAKE_VISIBLE)
 
         val target = (file.findElementAt(offset) ?: return).parentsWithSelf.firstOrNull {
-            it is JetClassOrObject || ((it is JetNamedFunction || it is JetProperty) && it.parent is JetClassBody)
+            it is KtClassOrObject || ((it is KtNamedFunction || it is KtProperty) && it.parent is KtClassBody)
         }
 
         if (target == null) {
@@ -79,8 +79,8 @@ public abstract class AbstractPullPushMembersHandler(
         val editor = dataContext?.let { CommonDataKeys.EDITOR.getData(it) }
 
         val (classOrObject, member) = when (element) {
-            is JetNamedFunction, is JetProperty -> element.getStrictParentOfType<JetClassOrObject>() to element as JetNamedDeclaration?
-            is JetClassOrObject -> element to null
+            is KtNamedFunction, is KtProperty -> element.getStrictParentOfType<KtClassOrObject>() to element as KtNamedDeclaration?
+            is KtClassOrObject -> element to null
             else -> {
                 reportWrongPosition(project, editor)
                 return
@@ -93,9 +93,9 @@ public abstract class AbstractPullPushMembersHandler(
     override fun isEnabledOnElements(elements: Array<out PsiElement>): Boolean {
         return elements.mapTo(HashSet<PsiElement>()) {
             when (it) {
-                is JetNamedFunction, is JetProperty ->
-                    (it.parent as? JetClassBody)?.parent as? JetClassOrObject
-                is JetClassOrObject -> it
+                is KtNamedFunction, is KtProperty ->
+                    (it.parent as? KtClassBody)?.parent as? KtClassOrObject
+                is KtClassOrObject -> it
                 else -> null
             } ?: return false
         }.size() == 1
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/CallableRefactoring.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/CallableRefactoring.kt
index 4cd7f69bb8e..54b3925568a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/CallableRefactoring.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/CallableRefactoring.kt
@@ -36,14 +36,14 @@ import org.jetbrains.kotlin.idea.JetBundle
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
-import org.jetbrains.kotlin.psi.JetBlockExpression
-import org.jetbrains.kotlin.psi.JetDeclarationWithBody
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtBlockExpression
+import org.jetbrains.kotlin.psi.KtDeclarationWithBody
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.OverrideResolver
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.utils.asJetScope
 import java.util.*
 
@@ -183,9 +183,9 @@ fun getAffectedCallables(project: Project, descriptorsForChange: Collection<Call
     }
 }
 
-fun DeclarationDescriptor.getContainingScope(): JetScope? {
+fun DeclarationDescriptor.getContainingScope(): KtScope? {
     val declaration = DescriptorToSourceUtils.descriptorToDeclaration(this)
-    val block = declaration?.getParent() as? JetBlockExpression
+    val block = declaration?.getParent() as? KtBlockExpression
     if (block != null) {
         val lastStatement = block.statements.last()
         return lastStatement.analyze()[BindingContext.RESOLUTION_SCOPE, lastStatement]
@@ -200,7 +200,7 @@ fun DeclarationDescriptor.getContainingScope(): JetScope? {
     }
 }
 
-fun JetDeclarationWithBody.getBodyScope(bindingContext: BindingContext): JetScope? {
-    val expression = getBodyExpression()?.getChildren()?.firstOrNull { it is JetExpression } as JetExpression?
+fun KtDeclarationWithBody.getBodyScope(bindingContext: BindingContext): KtScope? {
+    val expression = getBodyExpression()?.getChildren()?.firstOrNull { it is KtExpression } as KtExpression?
     return expression?.let { bindingContext[BindingContext.RESOLUTION_SCOPE, it] }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/JetRefactoringUtil.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/JetRefactoringUtil.java
index 097c23bb213..72878f89d06 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/JetRefactoringUtil.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/JetRefactoringUtil.java
@@ -56,7 +56,7 @@ import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import javax.swing.*;
 import javax.swing.event.ListSelectionEvent;
@@ -103,7 +103,7 @@ public class JetRefactoringUtil {
 
     @NotNull
     public static List<? extends PsiElement> checkSuperMethods(
-            @NotNull JetDeclaration declaration,
+            @NotNull KtDeclaration declaration,
             @Nullable Collection<PsiElement> ignore,
             @NotNull String actionStringKey
     ) {
@@ -120,7 +120,7 @@ public class JetRefactoringUtil {
         Map<PsiElement, CallableDescriptor> overriddenElementsToDescriptor = new HashMap<PsiElement, CallableDescriptor>();
         for (CallableDescriptor overriddenDescriptor : DescriptorUtils.getAllOverriddenDescriptors(declarationDescriptor)) {
             PsiElement overriddenDeclaration = DescriptorToSourceUtilsIde.INSTANCE$.getAnyDeclaration(project, overriddenDescriptor);
-            if (PsiTreeUtil.instanceOf(overriddenDeclaration, JetNamedFunction.class, JetProperty.class, PsiMethod.class)) {
+            if (PsiTreeUtil.instanceOf(overriddenDeclaration, KtNamedFunction.class, KtProperty.class, PsiMethod.class)) {
                 overriddenElementsToDescriptor.put(overriddenDeclaration, overriddenDescriptor);
             }
         }
@@ -136,7 +136,7 @@ public class JetRefactoringUtil {
 
     @NotNull
     private static List<? extends PsiElement> askUserForMethodsToSearch(
-            @NotNull JetDeclaration declaration,
+            @NotNull KtDeclaration declaration,
             @NotNull CallableDescriptor declarationDescriptor,
             @NotNull Map<PsiElement, CallableDescriptor> overriddenElementsToDescriptor,
             @NotNull List<String> superClasses,
@@ -177,7 +177,7 @@ public class JetRefactoringUtil {
 
                         PsiElement element = entry.getKey();
                         CallableDescriptor descriptor = entry.getValue();
-                        if (element instanceof JetNamedFunction || element instanceof JetProperty) {
+                        if (element instanceof KtNamedFunction || element instanceof KtProperty) {
                             description = formatClassDescriptor(descriptor.getContainingDeclaration());
                         }
                         else {
@@ -240,10 +240,10 @@ public class JetRefactoringUtil {
     @NotNull
     public static String formatJavaOrLightMethod(@NotNull PsiMethod method) {
         PsiElement originalDeclaration = LightClassUtilsKt.getUnwrapped(method);
-        if (originalDeclaration instanceof JetDeclaration) {
-            JetDeclaration jetDeclaration = (JetDeclaration) originalDeclaration;
-            BindingContext bindingContext = ResolutionUtils.analyze(jetDeclaration, BodyResolveMode.FULL);
-            DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, jetDeclaration);
+        if (originalDeclaration instanceof KtDeclaration) {
+            KtDeclaration ktDeclaration = (KtDeclaration) originalDeclaration;
+            BindingContext bindingContext = ResolutionUtils.analyze(ktDeclaration, BodyResolveMode.FULL);
+            DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, ktDeclaration);
 
             if (descriptor != null) return formatFunctionDescriptor(descriptor);
         }
@@ -251,7 +251,7 @@ public class JetRefactoringUtil {
     }
 
     @NotNull
-    public static String formatClass(@NotNull JetClassOrObject classOrObject) {
+    public static String formatClass(@NotNull KtClassOrObject classOrObject) {
         BindingContext bindingContext = ResolutionUtils.analyze(classOrObject, BodyResolveMode.FULL);
         DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, classOrObject);
 
@@ -317,9 +317,9 @@ public class JetRefactoringUtil {
         int parameterIndex = JetPsiUtilKt.parameterIndex(LightClassUtilsKt.getUnwrapped(parameter));
 
         if (method instanceof KotlinLightMethod) {
-            JetDeclaration declaration = ((KotlinLightMethod) method).getOrigin();
-            if (declaration instanceof JetFunction) {
-                result.add(((JetFunction) declaration).getValueParameters().get(parameterIndex));
+            KtDeclaration declaration = ((KotlinLightMethod) method).getOrigin();
+            if (declaration instanceof KtFunction) {
+                result.add(((KtFunction) declaration).getValueParameters().get(parameterIndex));
             }
         }
         else {
@@ -328,7 +328,7 @@ public class JetRefactoringUtil {
     }
 
     public interface SelectExpressionCallback {
-        void run(@Nullable JetExpression expression);
+        void run(@Nullable KtExpression expression);
     }
 
     public static void selectExpression(
@@ -356,59 +356,59 @@ public class JetRefactoringUtil {
         }
     }
 
-    public static List<JetExpression> getSmartSelectSuggestions(
+    public static List<KtExpression> getSmartSelectSuggestions(
             @NotNull PsiFile file,
             int offset
     ) throws IntroduceRefactoringException {
         if (offset < 0) {
-            return new ArrayList<JetExpression>();
+            return new ArrayList<KtExpression>();
         }
 
         PsiElement element = file.findElementAt(offset);
         if (element == null) {
-            return new ArrayList<JetExpression>();
+            return new ArrayList<KtExpression>();
         }
         if (element instanceof PsiWhiteSpace) {
             return getSmartSelectSuggestions(file, offset - 1);
         }
 
-        List<JetExpression> expressions = new ArrayList<JetExpression>();
-        while (element != null && !(element instanceof JetBlockExpression && !(element.getParent() instanceof JetFunctionLiteral)) &&
-               !(element instanceof JetNamedFunction)
-               && !(element instanceof JetClassBody)) {
-            if (element instanceof JetExpression && !(element instanceof JetStatementExpression)) {
+        List<KtExpression> expressions = new ArrayList<KtExpression>();
+        while (element != null && !(element instanceof KtBlockExpression && !(element.getParent() instanceof KtFunctionLiteral)) &&
+               !(element instanceof KtNamedFunction)
+               && !(element instanceof KtClassBody)) {
+            if (element instanceof KtExpression && !(element instanceof KtStatementExpression)) {
                 boolean addExpression = true;
 
-                if (JetPsiUtil.isLabelIdentifierExpression(element)) {
+                if (KtPsiUtil.isLabelIdentifierExpression(element)) {
                     addExpression = false;
                 }
-                else if (element.getParent() instanceof JetQualifiedExpression) {
-                    JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) element.getParent();
+                else if (element.getParent() instanceof KtQualifiedExpression) {
+                    KtQualifiedExpression qualifiedExpression = (KtQualifiedExpression) element.getParent();
                     if (qualifiedExpression.getReceiverExpression() != element) {
                         addExpression = false;
                     }
                 }
-                else if (element.getParent() instanceof JetCallElement
-                         || element.getParent() instanceof JetThisExpression
-                         || PsiTreeUtil.getParentOfType(element, JetSuperExpression.class) != null) {
+                else if (element.getParent() instanceof KtCallElement
+                         || element.getParent() instanceof KtThisExpression
+                         || PsiTreeUtil.getParentOfType(element, KtSuperExpression.class) != null) {
                     addExpression = false;
                 }
-                else if (element.getParent() instanceof JetOperationExpression) {
-                    JetOperationExpression operationExpression = (JetOperationExpression) element.getParent();
+                else if (element.getParent() instanceof KtOperationExpression) {
+                    KtOperationExpression operationExpression = (KtOperationExpression) element.getParent();
                     if (operationExpression.getOperationReference() == element) {
                         addExpression = false;
                     }
                 }
                 if (addExpression) {
-                    JetExpression expression = (JetExpression)element;
+                    KtExpression expression = (KtExpression)element;
                     BindingContext bindingContext = ResolutionUtils.analyze(expression, BodyResolveMode.FULL);
-                    JetType expressionType = bindingContext.getType(expression);
+                    KtType expressionType = bindingContext.getType(expression);
                     if (expressionType == null || !KotlinBuiltIns.isUnit(expressionType)) {
                         expressions.add(expression);
                     }
                 }
             }
-            else if (element instanceof JetTypeElement) {
+            else if (element instanceof KtTypeElement) {
                 expressions.clear();
             }
             element = element.getParent();
@@ -420,7 +420,7 @@ public class JetRefactoringUtil {
             @NotNull Editor editor, @NotNull PsiFile file, int offset,
             boolean failOnEmptySuggestion,
             @NotNull final SelectExpressionCallback callback) throws IntroduceRefactoringException {
-        List<JetExpression> expressions = getSmartSelectSuggestions(file, offset);
+        List<KtExpression> expressions = getSmartSelectSuggestions(file, offset);
         if (expressions.size() == 0) {
             if (failOnEmptySuggestion) throw new IntroduceRefactoringException(JetRefactoringBundle.message("cannot.refactor.not.expression"));
             return;
@@ -432,7 +432,7 @@ public class JetRefactoringUtil {
         }
 
         final DefaultListModel model = new DefaultListModel();
-        for (JetExpression expression : expressions) {
+        for (KtExpression expression : expressions) {
             model.addElement(expression);
         }
 
@@ -444,7 +444,7 @@ public class JetRefactoringUtil {
             @Override
             public Component getListCellRendererComponent(@NotNull JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
                 Component rendererComponent = super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
-                JetExpression element = (JetExpression) value;
+                KtExpression element = (KtExpression) value;
                 if (element.isValid()) {
                     setText(getExpressionShortText(element));
                 }
@@ -458,7 +458,7 @@ public class JetRefactoringUtil {
                 highlighter.dropHighlight();
                 int selectedIndex = list.getSelectedIndex();
                 if (selectedIndex < 0) return;
-                JetExpression expression = (JetExpression) model.get(selectedIndex);
+                KtExpression expression = (KtExpression) model.get(selectedIndex);
                 List<PsiElement> toExtract = new ArrayList<PsiElement>();
                 toExtract.add(expression);
                 highlighter.highlight(expression, toExtract);
@@ -470,7 +470,7 @@ public class JetRefactoringUtil {
                 setRequestFocus(true).setItemChoosenCallback(new Runnable() {
             @Override
             public void run() {
-                callback.run((JetExpression) list.getSelectedValue());
+                callback.run((KtExpression) list.getSelectedValue());
             }
         }).addListener(new JBPopupAdapter() {
             @Override
@@ -481,15 +481,15 @@ public class JetRefactoringUtil {
         
     }
 
-    public static String getExpressionShortText(@NotNull JetElement element) { //todo: write appropriate implementation
+    public static String getExpressionShortText(@NotNull KtElement element) { //todo: write appropriate implementation
         return StringUtilKt.collapseSpaces(StringUtil.shortenTextWithEllipsis(element.getText(), 53, 0));
     }
 
     @Nullable
-    private static JetExpression findExpression(
+    private static KtExpression findExpression(
             @NotNull PsiFile file, int startOffset, int endOffset, boolean failOnNoExpression
     ) throws IntroduceRefactoringException {
-        JetExpression element = CodeInsightUtils.findExpression(file, startOffset, endOffset);
+        KtExpression element = CodeInsightUtils.findExpression(file, startOffset, endOffset);
         if (element == null) {
             //todo: if it's infix expression => add (), then commit document then return new created expression
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/KotlinNamesValidator.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/KotlinNamesValidator.kt
index 0aaeffc1118..119e4022afe 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/KotlinNamesValidator.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/KotlinNamesValidator.kt
@@ -19,11 +19,11 @@ package org.jetbrains.kotlin.idea.refactoring
 import com.intellij.lang.refactoring.NamesValidator
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
-import org.jetbrains.kotlin.lexer.JetKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
 
 public class KotlinNamesValidator : NamesValidator {
-    private val KEYWORD_SET = JetTokens.KEYWORDS.getTypes().filterIsInstance<JetKeywordToken>().map { it.getValue() }.toSet()
+    private val KEYWORD_SET = KtTokens.KEYWORDS.getTypes().filterIsInstance<KtKeywordToken>().map { it.getValue() }.toSet()
 
     override fun isKeyword(name: String, project: Project?): Boolean = name in KEYWORD_SET
     override fun isIdentifier(name: String, project: Project?): Boolean = KotlinNameSuggester.isIdentifier(name)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/KotlinRefactoringSupportProvider.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/KotlinRefactoringSupportProvider.kt
index f8bdbb7e11e..fccac0ede81 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/KotlinRefactoringSupportProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/KotlinRefactoringSupportProvider.kt
@@ -51,21 +51,21 @@ public class KotlinRefactoringSupportProvider : RefactoringSupportProvider() {
 
     override fun isInplaceRenameAvailable(element: PsiElement, context: PsiElement?): Boolean {
         when (element) {
-            is JetProperty -> {
+            is KtProperty -> {
                 if (element.isLocal()) return true
             }
-            is JetMultiDeclarationEntry -> return true
-            is JetFunction -> {
+            is KtMultiDeclarationEntry -> return true
+            is KtFunction -> {
                 if (element.isLocal() && element.nameIdentifier != null) return true
             }
-            is JetParameter -> {
+            is KtParameter -> {
                 val parent = element.getParent()
-                if (parent is JetForExpression) {
+                if (parent is KtForExpression) {
                     return true
                 }
-                if (parent is JetParameterList) {
+                if (parent is KtParameterList) {
                     val grandparent = parent.getParent()
-                    return grandparent is JetCatchClause || grandparent is JetFunctionLiteral
+                    return grandparent is KtCatchClause || grandparent is KtFunctionLiteral
                 }
             }
         }
@@ -80,6 +80,6 @@ public class KotlinRefactoringSupportProvider : RefactoringSupportProvider() {
 }
 
 class KotlinVetoRenameCondition: Condition<PsiElement> {
-    override fun value(t: PsiElement?): Boolean = t is JetElement && t is PsiNameIdentifierOwner && t.nameIdentifier == null
+    override fun value(t: PsiElement?): Boolean = t is KtElement && t is PsiNameIdentifierOwner && t.nameIdentifier == null
 }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeInfo.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeInfo.kt
index 614f9e2075c..15ac98858a9 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeInfo.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeInfo.kt
@@ -39,12 +39,12 @@ import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetCallableDefinitionUsage
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCallerUsage
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
 import java.util.ArrayList
 import java.util.HashMap
@@ -53,7 +53,7 @@ import java.util.LinkedHashSet
 public open class JetChangeInfo(
         val methodDescriptor: JetMethodDescriptor,
         private var name: String = methodDescriptor.getName(),
-        val newReturnType: JetType? = methodDescriptor.baseDescriptor.getReturnType(),
+        val newReturnType: KtType? = methodDescriptor.baseDescriptor.getReturnType(),
         var newReturnTypeText: String = methodDescriptor.renderOriginalReturnType(),
         var newVisibility: Visibility = methodDescriptor.getVisibility(),
         parameterInfos: List<JetParameterInfo> = methodDescriptor.getParameters(),
@@ -106,7 +106,7 @@ public open class JetChangeInfo(
     fun getNonReceiverParametersCount(): Int = newParameters.size() - (if (receiverParameterInfo != null) 1 else 0)
 
     fun getNonReceiverParameters(): List<JetParameterInfo> {
-        methodDescriptor.baseDeclaration.let { if (it is JetProperty || it is JetParameter) return emptyList() }
+        methodDescriptor.baseDeclaration.let { if (it is KtProperty || it is KtParameter) return emptyList() }
         return receiverParameterInfo?.let { receiver -> newParameters.filter { it != receiver } } ?: newParameters
     }
 
@@ -162,8 +162,8 @@ public open class JetChangeInfo(
             fun add(element: PsiElement) {
                 element.unwrapped?.let {
                     val usageInfo = when (it) {
-                        is JetNamedFunction, is JetConstructor<*>, is JetClassOrObject ->
-                            KotlinCallerUsage(it as JetNamedDeclaration)
+                        is KtNamedFunction, is KtConstructor<*>, is KtClassOrObject ->
+                            KotlinCallerUsage(it as KtNamedDeclaration)
                         is PsiMethod ->
                             CallerUsageInfo(it, true, true)
                         else ->
@@ -203,7 +203,7 @@ public open class JetChangeInfo(
                 buffer.append(newVisibility).append(' ')
             }
 
-            buffer.append(if (kind == Kind.SECONDARY_CONSTRUCTOR) JetTokens.CONSTRUCTOR_KEYWORD else JetTokens.FUN_KEYWORD).append(' ')
+            buffer.append(if (kind == Kind.SECONDARY_CONSTRUCTOR) KtTokens.CONSTRUCTOR_KEYWORD else KtTokens.FUN_KEYWORD).append(' ')
 
             if (kind == Kind.FUNCTION) {
                 receiverParameterInfo?.let {
@@ -236,7 +236,7 @@ public open class JetChangeInfo(
     ): String {
         val signatureParameters = getNonReceiverParameters()
 
-        val isLambda = inheritedCallable.getDeclaration() is JetFunctionLiteral
+        val isLambda = inheritedCallable.getDeclaration() is KtFunctionLiteral
         if (isLambda && signatureParameters.size() == 1 && !signatureParameters.get(0).requiresExplicitType(inheritedCallable)) {
             return signatureParameters.get(0).getDeclarationSignature(0, inheritedCallable)
         }
@@ -356,7 +356,7 @@ public open class JetChangeInfo(
             return createJavaChangeInfo(originalPsiMethod, currentPsiMethod, newName, PsiType.VOID, newJavaParameters.toTypedArray())
         }
 
-        if (ProjectStructureUtil.isJsKotlinModule(getMethod().getContainingFile() as JetFile)) return null
+        if (ProjectStructureUtil.isJsKotlinModule(getMethod().getContainingFile() as KtFile)) return null
 
         if (javaChangeInfos == null) {
             val method = getMethod()
@@ -364,9 +364,9 @@ public open class JetChangeInfo(
                 val (originalPsiMethod, currentPsiMethod) = it
 
                 when (method) {
-                    is JetFunction, is JetClassOrObject ->
+                    is KtFunction, is KtClassOrObject ->
                         createJavaChangeInfoForFunctionOrGetter(originalPsiMethod, currentPsiMethod, false)
-                    is JetProperty, is JetParameter -> {
+                    is KtProperty, is KtParameter -> {
                         val accessorName = originalPsiMethod.getName()
                         when {
                             JvmAbi.isGetterName(accessorName) ->
@@ -391,7 +391,7 @@ public val JetChangeInfo.originalBaseFunctionDescriptor: CallableDescriptor
 public val JetChangeInfo.kind: Kind get() = methodDescriptor.kind
 
 public val JetChangeInfo.oldName: String?
-    get() = (methodDescriptor.getMethod() as? JetFunction)?.getName()
+    get() = (methodDescriptor.getMethod() as? KtFunction)?.getName()
 
 public fun JetChangeInfo.getAffectedCallables(): Collection<UsageInfo> = methodDescriptor.affectedCallables + propagationTargetUsageInfos
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt
index 41ee5a21e29..e86370d6346 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt
@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.core.refactoring.createJavaMethod
 import org.jetbrains.kotlin.idea.core.refactoring.toPsiFile
@@ -84,10 +84,10 @@ public class JetChangeSignature(project: Project,
     private fun runSilentRefactoring(descriptor: JetMethodDescriptor) {
         val baseDeclaration = descriptor.baseDeclaration
         val processor = when (baseDeclaration) {
-            is JetFunction, is JetClass -> {
+            is KtFunction, is KtClass -> {
                 JetChangeSignatureDialog.createRefactoringProcessorForSilentChangeSignature(project, commandName, descriptor, defaultValueContext)
             }
-            is JetProperty, is JetParameter -> {
+            is KtProperty, is KtParameter -> {
                 JetChangePropertySignatureDialog.createProcessorForSilentRefactoring(project, commandName, descriptor)
             }
             is PsiMethod -> {
@@ -106,8 +106,8 @@ public class JetChangeSignature(project: Project,
     private fun runInteractiveRefactoring(descriptor: JetMethodDescriptor) {
         val baseDeclaration = descriptor.baseDeclaration
         val dialog = when (baseDeclaration) {
-            is JetFunction, is JetClass -> JetChangeSignatureDialog(project, descriptor, defaultValueContext, commandName)
-            is JetProperty, is JetParameter -> JetChangePropertySignatureDialog(project, descriptor, commandName)
+            is KtFunction, is KtClass -> JetChangeSignatureDialog(project, descriptor, defaultValueContext, commandName)
+            is KtProperty, is KtParameter -> JetChangePropertySignatureDialog(project, descriptor, commandName)
             is PsiMethod -> {
                 // No changes are made from Kotlin side: just run foreign refactoring
                 if (descriptor is JetChangeSignatureData) {
@@ -137,7 +137,7 @@ public class JetChangeSignature(project: Project,
 
     private fun getPreviewInfoForJavaMethod(descriptor: JetMethodDescriptor): Pair<PsiMethod, JavaChangeInfo> {
         val originalMethod = descriptor.baseDeclaration as PsiMethod
-        val contextFile = defaultValueContext.getContainingFile() as JetFile
+        val contextFile = defaultValueContext.getContainingFile() as KtFile
 
         // Generate new Java method signature from the Kotlin point of view
         val ktChangeInfo = JetChangeInfo(methodDescriptor = descriptor, context = defaultValueContext)
@@ -147,8 +147,8 @@ public class JetChangeSignature(project: Project,
             append("class Dummy {\n").append(ktSignature).append("{}\n}")
             toString()
         }
-        val dummyFile = LightVirtualFile("dummy.kt", JetFileType.INSTANCE, dummyFileText).toPsiFile(project) as JetFile
-        val dummyDeclaration = (dummyFile.getDeclarations().first() as JetClass).getBody()!!.getDeclarations().first()
+        val dummyFile = LightVirtualFile("dummy.kt", KotlinFileType.INSTANCE, dummyFileText).toPsiFile(project) as KtFile
+        val dummyDeclaration = (dummyFile.getDeclarations().first() as KtClass).getBody()!!.getDeclarations().first()
 
         // Convert to PsiMethod which can be used in Change Signature dialog
         val containingClass = PsiElementFactory.SERVICE.getInstance(project).createClass("Dummy")
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt
index 8d1f6dd06a9..8049f41bff2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt
@@ -34,10 +34,10 @@ import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetCallableDefinitionUsage
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetFunction
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import java.util.Collections
@@ -55,8 +55,8 @@ public class JetChangeSignatureData(
         receiver = createReceiverInfoIfNeeded()
 
         val valueParameters = when {
-            baseDeclaration is JetFunction -> baseDeclaration.getValueParameters()
-            baseDeclaration is JetClass -> baseDeclaration.getPrimaryConstructorParameters()
+            baseDeclaration is KtFunction -> baseDeclaration.getValueParameters()
+            baseDeclaration is KtClass -> baseDeclaration.getPrimaryConstructorParameters()
             else -> null
         }
         parameters = baseDescriptor.getValueParameters()
@@ -75,8 +75,8 @@ public class JetChangeSignatureData(
     }
 
     private fun createReceiverInfoIfNeeded(): JetParameterInfo? {
-        val callable = baseDeclaration as? JetCallableDeclaration ?: return null
-        val bodyScope = (callable as? JetFunction)?.getBodyExpression()?.let { it.analyze()[BindingContext.RESOLUTION_SCOPE, it] }
+        val callable = baseDeclaration as? KtCallableDeclaration ?: return null
+        val bodyScope = (callable as? KtFunction)?.getBodyExpression()?.let { it.analyze()[BindingContext.RESOLUTION_SCOPE, it] }
         val paramNames = baseDescriptor.getValueParameters().map { it.getName().asString() }
         val validator = bodyScope?.let { bodyScope ->
             CollectingNameValidator(paramNames) {
@@ -106,14 +106,14 @@ public class JetChangeSignatureData(
 
     override val affectedCallables: Collection<UsageInfo> by lazy {
         primaryCallables + primaryCallables.flatMapTo(HashSet<UsageInfo>()) { primaryFunction ->
-            val primaryDeclaration = primaryFunction.getDeclaration() as? JetCallableDeclaration
+            val primaryDeclaration = primaryFunction.getDeclaration() as? KtCallableDeclaration
             val lightMethods = primaryDeclaration?.toLightMethods() ?: Collections.emptyList()
             lightMethods.flatMap { baseMethod ->
                 OverridingMethodsSearch
                         .search(baseMethod)
                         .map { overridingMethod ->
                             if (overridingMethod is KotlinLightMethod) {
-                                val overridingDeclaration = overridingMethod.namedUnwrappedElement as JetNamedDeclaration
+                                val overridingDeclaration = overridingMethod.namedUnwrappedElement as KtNamedDeclaration
                                 val overridingDescriptor = overridingDeclaration.resolveToDescriptor() as CallableDescriptor
                                 JetCallableDefinitionUsage<PsiElement>(overridingDeclaration, overridingDescriptor, primaryFunction, null)
                             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.kt
index 195caa052ec..ecde6afd737 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.kt
@@ -58,14 +58,14 @@ public class JetChangeSignatureHandler : ChangeSignatureHandler {
 
         val element = findTargetMember(file, editor) ?: CommonDataKeys.PSI_ELEMENT.getData(dataContext) ?: return
         val elementAtCaret = file.findElementAt(editor.getCaretModel().getOffset()) ?: return
-        if (element !is JetElement) throw AssertionError("This handler must be invoked for Kotlin elements only: ${element.getText()}")
+        if (element !is KtElement) throw AssertionError("This handler must be invoked for Kotlin elements only: ${element.getText()}")
 
         invokeChangeSignature(element, elementAtCaret, project, editor)
     }
 
     override fun invoke(project: Project, elements: Array<PsiElement>, dataContext: DataContext?) {
         val element = elements.singleOrNull()?.unwrapped ?: return
-        if (element !is JetElement) throw AssertionError("This handler must be invoked for Kotlin elements only: ${element.getText()}")
+        if (element !is KtElement) throw AssertionError("This handler must be invoked for Kotlin elements only: ${element.getText()}")
 
         val editor = dataContext?.let { CommonDataKeys.EDITOR.getData(it) }
         invokeChangeSignature(element, element, project, editor)
@@ -78,41 +78,41 @@ public class JetChangeSignatureHandler : ChangeSignatureHandler {
         public fun findTargetForRefactoring(element: PsiElement): PsiElement? {
             val elementParent = element.getParent()
 
-            if ((elementParent is JetNamedFunction || elementParent is JetClass || elementParent is JetProperty)
-                && (elementParent as JetNamedDeclaration).getNameIdentifier() === element) return elementParent
+            if ((elementParent is KtNamedFunction || elementParent is KtClass || elementParent is KtProperty)
+                && (elementParent as KtNamedDeclaration).getNameIdentifier() === element) return elementParent
 
-            if (elementParent is JetParameter) {
-                val primaryConstructor = PsiTreeUtil.getParentOfType(elementParent, javaClass<JetPrimaryConstructor>())
+            if (elementParent is KtParameter) {
+                val primaryConstructor = PsiTreeUtil.getParentOfType(elementParent, javaClass<KtPrimaryConstructor>())
                 if (elementParent.hasValOrVar()
                     && (elementParent.getNameIdentifier() === element || elementParent.getValOrVarKeyword() === element)
                     && primaryConstructor != null
                     && primaryConstructor.getValueParameterList() === elementParent.getParent()) return elementParent
             }
 
-            if (elementParent is JetSecondaryConstructor && elementParent.getConstructorKeyword() === element) return elementParent
+            if (elementParent is KtSecondaryConstructor && elementParent.getConstructorKeyword() === element) return elementParent
 
-            element.getStrictParentOfType<JetParameterList>()?.let { parameterList ->
-                return PsiTreeUtil.getParentOfType(parameterList, javaClass<JetFunction>(), javaClass<JetProperty>(), javaClass<JetClass>())
+            element.getStrictParentOfType<KtParameterList>()?.let { parameterList ->
+                return PsiTreeUtil.getParentOfType(parameterList, javaClass<KtFunction>(), javaClass<KtProperty>(), javaClass<KtClass>())
             }
 
-            element.getStrictParentOfType<JetTypeParameterList>()?.let { typeParameterList ->
-                return PsiTreeUtil.getParentOfType(typeParameterList, javaClass<JetFunction>(), javaClass<JetProperty>(), javaClass<JetClass>())
+            element.getStrictParentOfType<KtTypeParameterList>()?.let { typeParameterList ->
+                return PsiTreeUtil.getParentOfType(typeParameterList, javaClass<KtFunction>(), javaClass<KtProperty>(), javaClass<KtClass>())
             }
 
-            val call: JetCallElement? = PsiTreeUtil.getParentOfType(element,
-                                                                   javaClass<JetCallExpression>(),
-                                                                   javaClass<JetDelegatorToSuperCall>(),
-                                                                   javaClass<JetConstructorDelegationCall>())
+            val call: KtCallElement? = PsiTreeUtil.getParentOfType(element,
+                                                                   javaClass<KtCallExpression>(),
+                                                                   javaClass<KtDelegatorToSuperCall>(),
+                                                                   javaClass<KtConstructorDelegationCall>())
             val calleeExpr = call?.let {
                 val callee = it.getCalleeExpression()
-                (callee as? JetConstructorCalleeExpression)?.getConstructorReferenceExpression() ?: callee
-            } ?: element.getStrictParentOfType<JetSimpleNameExpression>()
+                (callee as? KtConstructorCalleeExpression)?.getConstructorReferenceExpression() ?: callee
+            } ?: element.getStrictParentOfType<KtSimpleNameExpression>()
 
-            if (calleeExpr is JetSimpleNameExpression || calleeExpr is JetConstructorDelegationReferenceExpression) {
-                val jetElement = element.getStrictParentOfType<JetElement>() ?: return null
+            if (calleeExpr is KtSimpleNameExpression || calleeExpr is KtConstructorDelegationReferenceExpression) {
+                val jetElement = element.getStrictParentOfType<KtElement>() ?: return null
 
                 val bindingContext = jetElement.analyze(BodyResolveMode.FULL)
-                val descriptor = bindingContext[BindingContext.REFERENCE_TARGET, calleeExpr as JetReferenceExpression]
+                val descriptor = bindingContext[BindingContext.REFERENCE_TARGET, calleeExpr as KtReferenceExpression]
 
                 if (descriptor is ClassDescriptor || descriptor is CallableDescriptor) return calleeExpr
             }
@@ -120,7 +120,7 @@ public class JetChangeSignatureHandler : ChangeSignatureHandler {
             return null
         }
 
-        public fun invokeChangeSignature(element: JetElement, context: PsiElement, project: Project, editor: Editor?) {
+        public fun invokeChangeSignature(element: KtElement, context: PsiElement, project: Project, editor: Editor?) {
             val bindingContext = element.analyze(BodyResolveMode.FULL)
 
             val callableDescriptor = findDescriptor(element, project, editor, bindingContext) ?: return
@@ -154,7 +154,7 @@ public class JetChangeSignatureHandler : ChangeSignatureHandler {
 
         private fun getDescriptor(bindingContext: BindingContext, element: PsiElement): DeclarationDescriptor? {
             val descriptor = when (element) {
-                is JetReferenceExpression -> bindingContext[BindingContext.REFERENCE_TARGET, element]
+                is KtReferenceExpression -> bindingContext[BindingContext.REFERENCE_TARGET, element]
                 else -> bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, element]
             }
             return if (descriptor is ClassDescriptor) descriptor.getUnsubstitutedPrimaryConstructor() else descriptor
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java
index 6e436d417d6..7c78387e268 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java
@@ -48,7 +48,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.asJava.KotlinLightMethod;
 import org.jetbrains.kotlin.asJava.LightClassUtilsKt;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.idea.analysis.AnalyzerUtilKt;
 import org.jetbrains.kotlin.idea.caches.resolve.JavaResolutionUtils;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
@@ -57,7 +57,7 @@ import org.jetbrains.kotlin.idea.codeInsight.JetFileReferencesResolver;
 import org.jetbrains.kotlin.idea.core.refactoring.JetRefactoringUtilKt;
 import org.jetbrains.kotlin.idea.refactoring.CallableRefactoringKt;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.*;
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference;
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference;
 import org.jetbrains.kotlin.idea.references.ReferenceUtilKt;
 import org.jetbrains.kotlin.idea.search.usagesSearch.UtilsKt;
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
@@ -75,12 +75,12 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver;
 import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
 import org.jetbrains.kotlin.resolve.source.KotlinSourceElementKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.*;
 
@@ -162,13 +162,13 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
 
                 SearchScope scope = callee.getUseScope();
                 if (scope instanceof GlobalSearchScope) {
-                    scope = GlobalSearchScope.getScopeRestrictedByFileTypes((GlobalSearchScope) scope, JetFileType.INSTANCE);
+                    scope = GlobalSearchScope.getScopeRestrictedByFileTypes((GlobalSearchScope) scope, KotlinFileType.INSTANCE);
                 }
 
                 for (PsiReference reference : ReferencesSearch.search(callee, scope)) {
                     PsiElement element = reference.getElement();
-                    JetCallElement callElement = PsiTreeUtil.getParentOfType(element, JetCallElement.class);
-                    JetExpression calleeExpression = callElement != null ? callElement.getCalleeExpression() : null;
+                    KtCallElement callElement = PsiTreeUtil.getParentOfType(element, KtCallElement.class);
+                    KtExpression calleeExpression = callElement != null ? callElement.getCalleeExpression() : null;
                     if (calleeExpression != null && PsiTreeUtil.isAncestor(calleeExpression, element, false)) {
                         result.add(propagationTarget
                                    ? new KotlinCallerCallUsage(callElement)
@@ -182,18 +182,18 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
     private static void findCallerUsages(KotlinCallerUsage callerUsage, JetChangeInfo changeInfo, final Set<UsageInfo> result) {
         result.add(callerUsage);
 
-        JetNamedDeclaration element = callerUsage.getElement();
+        KtNamedDeclaration element = callerUsage.getElement();
         if (element == null) return;
 
         for (PsiReference ref : ReferencesSearch.search(element, element.getUseScope())) {
             PsiElement refElement = ref.getElement();
-            JetCallElement callElement = PsiTreeUtil.getParentOfType(refElement, JetCallElement.class);
+            KtCallElement callElement = PsiTreeUtil.getParentOfType(refElement, KtCallElement.class);
             if (callElement != null && PsiTreeUtil.isAncestor(callElement.getCalleeExpression(), refElement, false)) {
                 result.add(new KotlinCallerCallUsage(callElement));
             }
         }
 
-        JetElement body = ChangeSignatureUtilsKt.getDeclarationBody(element);
+        KtElement body = ChangeSignatureUtilsKt.getDeclarationBody(element);
         final Set<String> newParameterNames = CollectionsKt.mapTo(
                 changeInfo.getNonReceiverParameters(),
                 new HashSet<String>(),
@@ -208,9 +208,9 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
             final DeclarationDescriptor callerDescriptor = ResolutionUtils.resolveToDescriptor(element);
             final BindingContext context = ResolutionUtils.analyze(body);
             body.accept(
-                    new JetTreeVisitorVoid() {
+                    new KtTreeVisitorVoid() {
                         @Override
-                        public void visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression) {
+                        public void visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression) {
                             final String currentName = expression.getReferencedName();
                             if (!newParameterNames.contains(currentName)) return;
 
@@ -226,7 +226,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
                             if (resultingDescriptor instanceof ValueParameterDescriptor
                                 && resultingDescriptor.getContainingDeclaration() == callerDescriptor) return;
 
-                            JetElement callElement = resolvedCall.getCall().getCallElement();
+                            KtElement callElement = resolvedCall.getCall().getCallElement();
 
                             ReceiverValue receiver = resolvedCall.getExtensionReceiver();
                             if (!(receiver instanceof ThisReceiver)) {
@@ -270,22 +270,22 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         for (PsiReference reference : ReferencesSearch.search(functionPsi, functionPsi.getUseScope())) {
             PsiElement element = reference.getElement();
 
-            if (functionPsi instanceof JetClass && reference.resolve() != functionPsi) continue;
+            if (functionPsi instanceof KtClass && reference.resolve() != functionPsi) continue;
 
-            if (element instanceof JetReferenceExpression) {
+            if (element instanceof KtReferenceExpression) {
                 PsiElement parent = element.getParent();
 
-                if (parent instanceof JetCallExpression)
-                    result.add(new JetFunctionCallUsage((JetCallExpression) parent, functionUsageInfo));
-                else if (parent instanceof JetUserType && parent.getParent() instanceof JetTypeReference) {
+                if (parent instanceof KtCallExpression)
+                    result.add(new JetFunctionCallUsage((KtCallExpression) parent, functionUsageInfo));
+                else if (parent instanceof KtUserType && parent.getParent() instanceof KtTypeReference) {
                     parent = parent.getParent().getParent();
 
-                    if (parent instanceof JetConstructorCalleeExpression && parent.getParent() instanceof JetDelegatorToSuperCall)
-                        result.add(new JetFunctionCallUsage((JetDelegatorToSuperCall)parent.getParent(), functionUsageInfo));
+                    if (parent instanceof KtConstructorCalleeExpression && parent.getParent() instanceof KtDelegatorToSuperCall)
+                        result.add(new JetFunctionCallUsage((KtDelegatorToSuperCall)parent.getParent(), functionUsageInfo));
                 }
-                else if (element instanceof JetSimpleNameExpression
-                         && (functionPsi instanceof JetProperty || functionPsi instanceof JetParameter)) {
-                    result.add(new JetPropertyCallUsage((JetSimpleNameExpression) element));
+                else if (element instanceof KtSimpleNameExpression
+                         && (functionPsi instanceof KtProperty || functionPsi instanceof KtParameter)) {
+                    result.add(new JetPropertyCallUsage((KtSimpleNameExpression) element));
                 }
             }
         }
@@ -295,24 +295,24 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         if (oldName != null)
             TextOccurrencesUtil.findNonCodeUsages(functionPsi, oldName, true, true, changeInfo.getNewName(), result);
 
-        List<JetParameter> oldParameters = JetPsiUtilKt.getValueParameters((JetNamedDeclaration) functionPsi);
+        List<KtParameter> oldParameters = JetPsiUtilKt.getValueParameters((KtNamedDeclaration) functionPsi);
 
         JetParameterInfo newReceiverInfo = changeInfo.getReceiverParameterInfo();
 
         for (JetParameterInfo parameterInfo : changeInfo.getNewParameters()) {
             if (parameterInfo.getOldIndex() >= 0 && parameterInfo.getOldIndex() < oldParameters.size()) {
-                JetParameter oldParam = oldParameters.get(parameterInfo.getOldIndex());
+                KtParameter oldParam = oldParameters.get(parameterInfo.getOldIndex());
                 String oldParamName = oldParam.getName();
 
                 if (parameterInfo == newReceiverInfo || (oldParamName != null && !oldParamName.equals(parameterInfo.getName()))) {
                     for (PsiReference reference : ReferencesSearch.search(oldParam, oldParam.getUseScope())) {
                         PsiElement element = reference.getElement();
 
-                        if ((element instanceof JetSimpleNameExpression || element instanceof KDocName) &&
-                            !(element.getParent() instanceof JetValueArgumentName)) // Usages in named arguments of the calls usage will be changed when the function call is changed
+                        if ((element instanceof KtSimpleNameExpression || element instanceof KDocName) &&
+                            !(element.getParent() instanceof KtValueArgumentName)) // Usages in named arguments of the calls usage will be changed when the function call is changed
                         {
                             JetParameterUsage parameterUsage =
-                                    new JetParameterUsage((JetElement) element, parameterInfo, functionUsageInfo);
+                                    new JetParameterUsage((KtElement) element, parameterInfo, functionUsageInfo);
                             result.add(parameterUsage);
                         }
                     }
@@ -320,14 +320,14 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
             }
         }
 
-        if (functionPsi instanceof JetFunction && newReceiverInfo != changeInfo.getMethodDescriptor().getReceiver()) {
+        if (functionPsi instanceof KtFunction && newReceiverInfo != changeInfo.getMethodDescriptor().getReceiver()) {
             findOriginalReceiversUsages(functionUsageInfo, result, changeInfo);
         }
 
-        if (functionPsi instanceof JetClass && ((JetClass) functionPsi).isEnum()) {
-            for (JetDeclaration declaration : ((JetClass) functionPsi).getDeclarations()) {
-                if (declaration instanceof JetEnumEntry && ((JetEnumEntry) declaration).getDelegationSpecifiers().isEmpty()) {
-                    result.add(new JetEnumEntryWithoutSuperCallUsage((JetEnumEntry) declaration));
+        if (functionPsi instanceof KtClass && ((KtClass) functionPsi).isEnum()) {
+            for (KtDeclaration declaration : ((KtClass) functionPsi).getDeclarations()) {
+                if (declaration instanceof KtEnumEntry && ((KtEnumEntry) declaration).getDelegationSpecifiers().isEmpty()) {
+                    result.add(new JetEnumEntryWithoutSuperCallUsage((KtEnumEntry) declaration));
                 }
             }
         }
@@ -335,13 +335,13 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         UtilsKt.processDelegationCallConstructorUsages(
                 functionPsi,
                 functionPsi.getUseScope(),
-                new Function1<JetCallElement, Boolean>() {
+                new Function1<KtCallElement, Boolean>() {
                     @Override
-                    public Boolean invoke(JetCallElement element) {
-                        if (element instanceof JetConstructorDelegationCall) {
-                            result.add(new JetConstructorDelegationCallUsage((JetConstructorDelegationCall) element, changeInfo));
+                    public Boolean invoke(KtCallElement element) {
+                        if (element instanceof KtConstructorDelegationCall) {
+                            result.add(new JetConstructorDelegationCallUsage((KtConstructorDelegationCall) element, changeInfo));
                         }
-                        else if (element instanceof JetDelegatorToSuperCall) {
+                        else if (element instanceof KtDelegatorToSuperCall) {
                             result.add(new JetFunctionCallUsage(element, functionUsageInfo));
 
                         }
@@ -353,15 +353,15 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
 
     private static void processInternalReferences(
             JetCallableDefinitionUsage functionUsageInfo,
-            JetTreeVisitor<BindingContext> visitor
+            KtTreeVisitor<BindingContext> visitor
     ) {
-        JetFunction jetFunction = (JetFunction) functionUsageInfo.getDeclaration();
-        JetExpression body = jetFunction.getBodyExpression();
+        KtFunction ktFunction = (KtFunction) functionUsageInfo.getDeclaration();
+        KtExpression body = ktFunction.getBodyExpression();
         if (body != null) {
             body.accept(visitor, ResolutionUtils.analyze(body, BodyResolveMode.FULL));
         }
-        for (JetParameter parameter : jetFunction.getValueParameters()) {
-            JetExpression defaultValue = parameter.getDefaultValue();
+        for (KtParameter parameter : ktFunction.getValueParameters()) {
+            KtExpression defaultValue = parameter.getDefaultValue();
             if (defaultValue != null) {
                 defaultValue.accept(visitor, ResolutionUtils.analyze(defaultValue, BodyResolveMode.FULL));
             }
@@ -377,13 +377,13 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         final CallableDescriptor callableDescriptor = functionUsageInfo.getOriginalCallableDescriptor();
         processInternalReferences(
                 functionUsageInfo,
-                new JetTreeVisitor<BindingContext>() {
+                new KtTreeVisitor<BindingContext>() {
                     private void processExplicitThis(
-                            @NotNull JetSimpleNameExpression expression,
+                            @NotNull KtSimpleNameExpression expression,
                             @NotNull ReceiverParameterDescriptor receiverDescriptor
                     ) {
                         if (originalReceiverInfo != null && !changeInfo.hasParameter(originalReceiverInfo)) return;
-                        if (!(expression.getParent() instanceof JetThisExpression)) return;
+                        if (!(expression.getParent() instanceof KtThisExpression)) return;
 
                         if (receiverDescriptor == callableDescriptor.getExtensionReceiverParameter()) {
                             assert originalReceiverInfo != null : "No original receiver info provided: " + functionUsageInfo.getDeclaration().getText();
@@ -392,12 +392,12 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
                         else {
                             ClassifierDescriptor targetDescriptor = receiverDescriptor.getType().getConstructor().getDeclarationDescriptor();
                             assert targetDescriptor != null : "Receiver type has no descriptor: " + functionUsageInfo.getDeclaration().getText();
-                            result.add(new JetNonQualifiedOuterThisUsage((JetThisExpression) expression.getParent(), targetDescriptor));
+                            result.add(new JetNonQualifiedOuterThisUsage((KtThisExpression) expression.getParent(), targetDescriptor));
                         }
                     }
 
                     private void processImplicitThis(
-                            @NotNull JetElement callElement,
+                            @NotNull KtElement callElement,
                             @NotNull ThisReceiver receiverValue
                     ) {
                         DeclarationDescriptor targetDescriptor = receiverValue.getDeclarationDescriptor();
@@ -411,7 +411,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
                     }
 
                     @Override
-                    public Void visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression, BindingContext context) {
+                    public Void visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression, BindingContext context) {
                         ResolvedCall<? extends CallableDescriptor> resolvedCall = CallUtilKt.getResolvedCall(expression, context);
                         if (resolvedCall == null) return null;
 
@@ -453,25 +453,25 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         if (samClass == null) return;
 
         for (PsiReference ref : ReferencesSearch.search(samClass)) {
-            if (!(ref instanceof JetSimpleNameReference)) continue;
+            if (!(ref instanceof KtSimpleNameReference)) continue;
 
-            JetSimpleNameExpression callee = ((JetSimpleNameReference) ref).getExpression();
-            JetCallExpression callExpression = PsiTreeUtil.getParentOfType(callee, JetCallExpression.class);
+            KtSimpleNameExpression callee = ((KtSimpleNameReference) ref).getExpression();
+            KtCallExpression callExpression = PsiTreeUtil.getParentOfType(callee, KtCallExpression.class);
             if (callExpression == null || callExpression.getCalleeExpression() != callee) continue;
 
             List<? extends ValueArgument> arguments = callExpression.getValueArguments();
             if (arguments.size() != 1) continue;
 
-            JetExpression argExpression = arguments.get(0).getArgumentExpression();
-            if (!(argExpression instanceof JetFunctionLiteralExpression)) continue;
+            KtExpression argExpression = arguments.get(0).getArgumentExpression();
+            if (!(argExpression instanceof KtFunctionLiteralExpression)) continue;
 
             BindingContext context = ResolutionUtils.analyze(callExpression, BodyResolveMode.FULL);
 
-            JetFunctionLiteral functionLiteral = ((JetFunctionLiteralExpression) argExpression).getFunctionLiteral();
+            KtFunctionLiteral functionLiteral = ((KtFunctionLiteralExpression) argExpression).getFunctionLiteral();
             FunctionDescriptor functionDescriptor = context.get(BindingContext.FUNCTION, functionLiteral);
             assert functionDescriptor != null : "No descriptor for " + functionLiteral.getText();
 
-            JetType samCallType = context.getType(callExpression);
+            KtType samCallType = context.getType(callExpression);
             if (samCallType == null) continue;
 
             result.add(new DeferredJavaMethodOverrideOrSAMUsage(functionLiteral, functionDescriptor, samCallType));
@@ -488,11 +488,11 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         UtilsKt.processDelegationCallConstructorUsages(
                 psiMethod,
                 psiMethod.getUseScope(),
-                new Function1<JetCallElement, Boolean>() {
+                new Function1<KtCallElement, Boolean>() {
                     @Override
-                    public Boolean invoke(JetCallElement element) {
-                        if (element instanceof JetConstructorDelegationCall) {
-                            result.add(new JavaConstructorDeferredUsageInDelegationCall((JetConstructorDelegationCall) element));
+                    public Boolean invoke(KtCallElement element) {
+                        if (element instanceof KtConstructorDelegationCall) {
+                            result.add(new JavaConstructorDeferredUsageInDelegationCall((KtConstructorDelegationCall) element));
                         }
                         return true;
                     }
@@ -506,9 +506,9 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
 
         for (PsiMethod overridingMethod : OverridingMethodsSearch.search((PsiMethod) method)) {
             PsiElement unwrappedElement = LightClassUtilsKt.getNamedUnwrappedElement(overridingMethod);
-            if (!(unwrappedElement instanceof JetNamedFunction)) continue;
+            if (!(unwrappedElement instanceof KtNamedFunction)) continue;
 
-            JetNamedFunction function = (JetNamedFunction) unwrappedElement;
+            KtNamedFunction function = (KtNamedFunction) unwrappedElement;
             FunctionDescriptor functionDescriptor = (FunctionDescriptor) ResolutionUtils.resolveToDescriptor(function);
 
             result.add(new DeferredJavaMethodOverrideOrSAMUsage(function, functionDescriptor, null));
@@ -531,46 +531,46 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
 
     private static void addDeferredCallerIfPossible(Set<UsageInfo> result, PsiMethod overridingCaller) {
         PsiElement unwrappedElement = LightClassUtilsKt.getNamedUnwrappedElement(overridingCaller);
-        if (unwrappedElement instanceof JetFunction || unwrappedElement instanceof JetClass) {
-            result.add(new DeferredJavaMethodKotlinCallerUsage((JetNamedDeclaration) unwrappedElement));
+        if (unwrappedElement instanceof KtFunction || unwrappedElement instanceof KtClass) {
+            result.add(new DeferredJavaMethodKotlinCallerUsage((KtNamedDeclaration) unwrappedElement));
         }
     }
 
     private static void findDeferredUsagesOfParameters(
             ChangeInfo changeInfo,
             Set<UsageInfo> result,
-            JetNamedFunction function,
+            KtNamedFunction function,
             FunctionDescriptor functionDescriptor
     ) {
         final JetCallableDefinitionUsage<?> functionInfoForParameters =
                 new JetCallableDefinitionUsage<PsiElement>(function, functionDescriptor, null, null);
-        List<JetParameter> oldParameters = JetPsiUtilKt.getValueParameters(function);
+        List<KtParameter> oldParameters = JetPsiUtilKt.getValueParameters(function);
         ParameterInfo[] parameters = changeInfo.getNewParameters();
         for (int i = 0; i < parameters.length; i++) {
             final int paramIndex = i;
             ParameterInfo parameterInfo = parameters[paramIndex];
             if (parameterInfo.getOldIndex() >= 0 && parameterInfo.getOldIndex() < oldParameters.size()) {
-                JetParameter oldParam = oldParameters.get(parameterInfo.getOldIndex());
+                KtParameter oldParam = oldParameters.get(parameterInfo.getOldIndex());
                 String oldParamName = oldParam.getName();
 
                 if (oldParamName != null && !oldParamName.equals(parameterInfo.getName())) {
                     for (PsiReference reference : ReferencesSearch.search(oldParam, oldParam.getUseScope())) {
                         final PsiElement element = reference.getElement();
 
-                        if ((element instanceof JetSimpleNameExpression || element instanceof KDocName) &&
-                            !(element.getParent() instanceof JetValueArgumentName)) // Usages in named arguments of the calls usage will be changed when the function call is changed
+                        if ((element instanceof KtSimpleNameExpression || element instanceof KDocName) &&
+                            !(element.getParent() instanceof KtValueArgumentName)) // Usages in named arguments of the calls usage will be changed when the function call is changed
                         {
                             result.add(
-                                    new JavaMethodDeferredKotlinUsage<JetElement>((JetElement) element) {
+                                    new JavaMethodDeferredKotlinUsage<KtElement>((KtElement) element) {
                                         @NotNull
                                         @Override
-                                        public JavaMethodKotlinUsageWithDelegate<JetElement> resolve(@NotNull JetChangeInfo javaMethodChangeInfo) {
-                                            return new JavaMethodKotlinUsageWithDelegate<JetElement>((JetElement) element,
-                                                                                                     javaMethodChangeInfo) {
+                                        public JavaMethodKotlinUsageWithDelegate<KtElement> resolve(@NotNull JetChangeInfo javaMethodChangeInfo) {
+                                            return new JavaMethodKotlinUsageWithDelegate<KtElement>((KtElement) element,
+                                                                                                    javaMethodChangeInfo) {
                                                 @NotNull
                                                 @Override
-                                                public JetUsageInfo<JetElement> getDelegateUsage() {
-                                                    return new JetParameterUsage((JetElement) element,
+                                                public JetUsageInfo<KtElement> getDelegateUsage() {
+                                                    return new JetParameterUsage((KtElement) element,
                                                                                  getJavaMethodChangeInfo().getNewParameters()[paramIndex],
                                                                                  functionInfoForParameters);
                                                 }
@@ -611,17 +611,17 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         JetChangeInfo changeInfo = (JetChangeInfo) info;
         PsiElement function = info.getMethod();
         PsiElement element = function != null ? function : changeInfo.getContext();
-        BindingContext bindingContext = ResolutionUtils.analyze((JetElement) element, BodyResolveMode.FULL);
+        BindingContext bindingContext = ResolutionUtils.analyze((KtElement) element, BodyResolveMode.FULL);
         CallableDescriptor oldDescriptor = JetChangeInfoKt.getOriginalBaseFunctionDescriptor(changeInfo);
         DeclarationDescriptor containingDeclaration = oldDescriptor.getContainingDeclaration();
 
-        JetScope parametersScope = null;
+        KtScope parametersScope = null;
         if (oldDescriptor instanceof ConstructorDescriptor && containingDeclaration instanceof ClassDescriptorWithResolutionScopes)
             parametersScope = ScopeUtilsKt.asJetScope(((ClassDescriptorWithResolutionScopes) containingDeclaration).getScopeForInitializerResolution());
-        else if (function instanceof JetFunction)
-            parametersScope = CallableRefactoringKt.getBodyScope((JetFunction) function, bindingContext);
+        else if (function instanceof KtFunction)
+            parametersScope = CallableRefactoringKt.getBodyScope((KtFunction) function, bindingContext);
 
-        JetScope callableScope = CallableRefactoringKt.getContainingScope(oldDescriptor);
+        KtScope callableScope = CallableRefactoringKt.getContainingScope(oldDescriptor);
 
         JetMethodDescriptor.Kind kind = JetChangeInfoKt.getKind(changeInfo);
         if (!kind.isConstructor() && callableScope != null && !info.getNewName().isEmpty()) {
@@ -654,13 +654,13 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
                     for (VariableDescriptor property : ScopeUtils.getVariablesFromImplicitReceivers(parametersScope, Name.identifier(parameterName))) {
                         PsiElement propertyDeclaration = DescriptorToSourceUtils.descriptorToDeclaration(property);
 
-                        if (propertyDeclaration != null && !(propertyDeclaration.getParent() instanceof JetParameterList)) {
+                        if (propertyDeclaration != null && !(propertyDeclaration.getParent() instanceof KtParameterList)) {
                             result.putValue(propertyDeclaration, "Duplicating property '" + parameterName + "'");
                             break;
                         }
                     }
                 }
-                else if (function instanceof JetFunction) {
+                else if (function instanceof KtFunction) {
                     VariableDescriptor variable = parametersScope.getLocalVariable(Name.identifier(parameterName));
 
                     if (variable != null && !(variable instanceof ValueParameterDescriptor)) {
@@ -673,16 +673,16 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
 
         JetParameterInfo newReceiverInfo = changeInfo.getReceiverParameterInfo();
         JetParameterInfo originalReceiverInfo = changeInfo.getMethodDescriptor().getReceiver();
-        if (function instanceof JetCallableDeclaration && newReceiverInfo != originalReceiverInfo) {
+        if (function instanceof KtCallableDeclaration && newReceiverInfo != originalReceiverInfo) {
             findReceiverIntroducingConflicts(result, function, newReceiverInfo);
             findInternalExplicitReceiverConflicts(refUsages.get(), result, originalReceiverInfo);
-            findThisLabelConflicts(refUsages, result, changeInfo, (JetCallableDeclaration) function);
+            findThisLabelConflicts(refUsages, result, changeInfo, (KtCallableDeclaration) function);
         }
 
         for (UsageInfo usageInfo : usageInfos) {
             if (!(usageInfo instanceof KotlinCallerUsage)) continue;
 
-            JetNamedDeclaration caller = (JetNamedDeclaration) usageInfo.getElement();
+            KtNamedDeclaration caller = (KtNamedDeclaration) usageInfo.getElement();
             DeclarationDescriptor callerDescriptor = ResolutionUtils.resolveToDescriptor(caller);
 
             findParameterDuplicationInCaller(result, changeInfo, caller, callerDescriptor);
@@ -694,15 +694,15 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
     private static void findParameterDuplicationInCaller(
             MultiMap<PsiElement, String> result,
             JetChangeInfo changeInfo,
-            JetNamedDeclaration caller,
+            KtNamedDeclaration caller,
             DeclarationDescriptor callerDescriptor
     ) {
-        List<JetParameter> valueParameters = JetPsiUtilKt.getValueParameters(caller);
-        Map<String, JetParameter> existingParameters = CollectionsKt.toMap(
+        List<KtParameter> valueParameters = JetPsiUtilKt.getValueParameters(caller);
+        Map<String, KtParameter> existingParameters = CollectionsKt.toMap(
                 valueParameters,
-                new Function1<JetParameter, String>() {
+                new Function1<KtParameter, String>() {
                     @Override
-                    public String invoke(JetParameter parameter) {
+                    public String invoke(KtParameter parameter) {
                         return parameter.getName();
                     }
                 }
@@ -711,7 +711,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
             if (!(parameterInfo.isNewParameter())) continue;
 
             String name = parameterInfo.getName();
-            JetParameter parameter = existingParameters.get(name);
+            KtParameter parameter = existingParameters.get(name);
             if (parameter != null) {
                 result.putValue(parameter, "There is already a parameter '" + name + "' in " +
                                            IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.render(callerDescriptor) +
@@ -724,9 +724,9 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
             Ref<UsageInfo[]> refUsages,
             MultiMap<PsiElement, String> result,
             JetChangeInfo changeInfo,
-            JetCallableDeclaration callable
+            KtCallableDeclaration callable
     ) {
-        JetPsiFactory psiFactory = new JetPsiFactory(callable.getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(callable.getProject());
         for (UsageInfo usageInfo : refUsages.get()) {
             if (!(usageInfo instanceof JetParameterUsage)) continue;
 
@@ -735,16 +735,16 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
 
             if (usageInfo.getElement() instanceof KDocName) continue; // TODO support converting parameter to receiver in KDoc
 
-            JetExpression originalExpr = (JetExpression) usageInfo.getElement();
-            JetScope scope = ResolutionUtils.analyze(originalExpr, BodyResolveMode.FULL)
+            KtExpression originalExpr = (KtExpression) usageInfo.getElement();
+            KtScope scope = ResolutionUtils.analyze(originalExpr, BodyResolveMode.FULL)
                     .get(BindingContext.RESOLUTION_SCOPE, originalExpr);
             if (scope == null) continue;
 
-            JetThisExpression newExpr = (JetThisExpression) psiFactory.createExpression(newExprText);
+            KtThisExpression newExpr = (KtThisExpression) psiFactory.createExpression(newExprText);
 
             BindingContext newContext = AnalyzerUtilKt.analyzeInContext(newExpr, scope, originalExpr);
 
-            JetSimpleNameExpression labelExpr = newExpr.getTargetLabel();
+            KtSimpleNameExpression labelExpr = newExpr.getTargetLabel();
             if (labelExpr != null && newContext.get(BindingContext.AMBIGUOUS_LABEL_TARGET, labelExpr) != null) {
                 result.putValue(
                         originalExpr,
@@ -781,11 +781,11 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
             for (UsageInfo usageInfo : usages) {
                 if (!(usageInfo instanceof JetFunctionCallUsage || usageInfo instanceof JetPropertyCallUsage)) continue;
 
-                JetElement callElement = (JetElement) usageInfo.getElement();
+                KtElement callElement = (KtElement) usageInfo.getElement();
                 if (callElement == null) continue;
 
                 PsiElement parent = callElement.getParent();
-                if (parent instanceof JetQualifiedExpression && ((JetQualifiedExpression) parent).getSelectorExpression() == callElement) {
+                if (parent instanceof KtQualifiedExpression && ((KtQualifiedExpression) parent).getSelectorExpression() == callElement) {
                     String message = "Explicit receiver is already present in call element: " +
                                      CommonRefactoringUtil.htmlEmphasize(parent.getText());
                     result.putValue(callElement, message);
@@ -799,12 +799,12 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
             PsiElement callable,
             JetParameterInfo newReceiverInfo
     ) {
-        if (newReceiverInfo != null && (callable instanceof JetNamedFunction) && ((JetNamedFunction) callable).getBodyExpression() != null) {
-            Map<JetReferenceExpression, BindingContext> noReceiverRefToContext = MapsKt.filter(
-                    JetFileReferencesResolver.INSTANCE$.resolve((JetNamedFunction) callable, true, true),
-                    new Function1<Map.Entry<? extends JetReferenceExpression, ? extends BindingContext>, Boolean>() {
+        if (newReceiverInfo != null && (callable instanceof KtNamedFunction) && ((KtNamedFunction) callable).getBodyExpression() != null) {
+            Map<KtReferenceExpression, BindingContext> noReceiverRefToContext = MapsKt.filter(
+                    JetFileReferencesResolver.INSTANCE$.resolve((KtNamedFunction) callable, true, true),
+                    new Function1<Map.Entry<? extends KtReferenceExpression, ? extends BindingContext>, Boolean>() {
                         @Override
-                        public Boolean invoke(Map.Entry<? extends JetReferenceExpression, ? extends BindingContext> entry) {
+                        public Boolean invoke(Map.Entry<? extends KtReferenceExpression, ? extends BindingContext> entry) {
                             ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(entry.getKey(), entry.getValue());
                             return resolvedCall != null
                                    && !resolvedCall.getDispatchReceiver().exists()
@@ -813,9 +813,9 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
                     }
             );
 
-            JetPsiFactory psiFactory = new JetPsiFactory(callable.getProject());
-            JetFile tempFile = JetRefactoringUtilKt.createTempCopy(
-                    (JetFile) callable.getContainingFile(),
+            KtPsiFactory psiFactory = new KtPsiFactory(callable.getProject());
+            KtFile tempFile = JetRefactoringUtilKt.createTempCopy(
+                    (KtFile) callable.getContainingFile(),
                     new Function1<String, String>() {
                         @Override
                         public String invoke(String s) {
@@ -823,23 +823,23 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
                         }
                     }
             );
-            JetNamedFunction functionWithReceiver =
-                    PsiTreeUtil.getParentOfType(tempFile.findElementAt(callable.getTextOffset()), JetNamedFunction.class);
-            JetTypeReference receiverTypeRef = psiFactory.createType(newReceiverInfo.getCurrentTypeText());
+            KtNamedFunction functionWithReceiver =
+                    PsiTreeUtil.getParentOfType(tempFile.findElementAt(callable.getTextOffset()), KtNamedFunction.class);
+            KtTypeReference receiverTypeRef = psiFactory.createType(newReceiverInfo.getCurrentTypeText());
             TypeRefHelpersKt.setReceiverTypeReference(functionWithReceiver, receiverTypeRef);
             //noinspection ConstantConditions
             BindingContext newContext = ResolutionUtils.analyze(functionWithReceiver.getBodyExpression(), BodyResolveMode.FULL);
 
             //noinspection ConstantConditions
-            int originalOffset = ((JetNamedFunction) callable).getBodyExpression().getTextOffset();
-            JetExpression newBody = functionWithReceiver.getBodyExpression();
-            for (Map.Entry<JetReferenceExpression, BindingContext> entry : noReceiverRefToContext.entrySet()) {
-                JetReferenceExpression originalRef = entry.getKey();
+            int originalOffset = ((KtNamedFunction) callable).getBodyExpression().getTextOffset();
+            KtExpression newBody = functionWithReceiver.getBodyExpression();
+            for (Map.Entry<KtReferenceExpression, BindingContext> entry : noReceiverRefToContext.entrySet()) {
+                KtReferenceExpression originalRef = entry.getKey();
                 BindingContext originalContext = entry.getValue();
                 //noinspection ConstantConditions
-                JetReferenceExpression newRef = PsiTreeUtil.getParentOfType(
+                KtReferenceExpression newRef = PsiTreeUtil.getParentOfType(
                         newBody.findElementAt(originalRef.getTextOffset() - originalOffset),
-                        JetReferenceExpression.class
+                        KtReferenceExpression.class
                 );
                 ResolvedCall<?> newResolvedCall = CallUtilKt.getResolvedCall(newRef, newContext);
                 if (newResolvedCall == null
@@ -859,10 +859,10 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         }
     }
 
-    private static List<JetType> getCallableParameterTypes(CallableDescriptor descriptor) {
-        return ContainerUtil.map(descriptor.getValueParameters(), new Function<ValueParameterDescriptor, JetType>() {
+    private static List<KtType> getCallableParameterTypes(CallableDescriptor descriptor) {
+        return ContainerUtil.map(descriptor.getValueParameters(), new Function<ValueParameterDescriptor, KtType>() {
             @Override
-            public JetType fun(ValueParameterDescriptor descriptor) {
+            public KtType fun(ValueParameterDescriptor descriptor) {
                 return descriptor.getType();
             }
         });
@@ -879,7 +879,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
             return ((JavaMethodDeferredKotlinUsage<?>) originalUsageInfo).resolve(javaMethodChangeInfo);
         }
 
-        JetCallElement callElement = PsiTreeUtil.getParentOfType(originalUsageInfo.getElement(), JetCallElement.class);
+        KtCallElement callElement = PsiTreeUtil.getParentOfType(originalUsageInfo.getElement(), KtCallElement.class);
         if (callElement == null) return null;
 
         PsiReference ref = originalUsageInfo.getReference();
@@ -891,7 +891,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
 
     private static boolean canCreateReplacementUsage(UsageInfo originalUsageInfo) {
         if (originalUsageInfo instanceof JavaMethodDeferredKotlinUsage) return true;
-        return PsiTreeUtil.getParentOfType(originalUsageInfo.getElement(), JetCallElement.class) != null;
+        return PsiTreeUtil.getParentOfType(originalUsageInfo.getElement(), KtCallElement.class) != null;
     }
 
     private static class NullabilityPropagator {
@@ -1067,10 +1067,10 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         }
 
         if (usageInfo instanceof MoveRenameUsageInfo && isJavaMethodUsage) {
-            JetSimpleNameExpression callee = PsiTreeUtil.getParentOfType(usageInfo.getElement(), JetSimpleNameExpression.class, false);
+            KtSimpleNameExpression callee = PsiTreeUtil.getParentOfType(usageInfo.getElement(), KtSimpleNameExpression.class, false);
             PsiReference ref = callee != null ? ReferenceUtilKt.getMainReference(callee) : null;
-            if (ref instanceof JetSimpleNameReference) {
-                ((JetSimpleNameReference) ref).handleElementRename(((PsiMethod)method).getName());
+            if (ref instanceof KtSimpleNameReference) {
+                ((KtSimpleNameReference) ref).handleElementRename(((PsiMethod)method).getName());
                 return true;
             }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetParameterInfo.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetParameterInfo.kt
index 64218da444e..4b653b8fb90 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetParameterInfo.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetParameterInfo.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.compareDescriptors
 import org.jetbrains.kotlin.idea.core.refactoring.quoteIfNeeded
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetCallableDefinitionUsage
-import org.jetbrains.kotlin.idea.references.JetReference
+import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.psi.*
@@ -34,33 +34,33 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.util.*
 
 public class JetParameterInfo(
         val callableDescriptor: CallableDescriptor,
         val originalIndex: Int = -1,
         private var name: String,
-        type: JetType? = null,
-        var defaultValueForParameter: JetExpression? = null,
-        var defaultValueForCall: JetExpression? = null,
+        type: KtType? = null,
+        var defaultValueForParameter: KtExpression? = null,
+        var defaultValueForCall: KtExpression? = null,
         var valOrVar: JetValVar = JetValVar.None,
-        val modifierList: JetModifierList? = null
+        val modifierList: KtModifierList? = null
 ): ParameterInfo {
-    val originalType: JetType? = type
+    val originalType: KtType? = type
     var currentTypeText: String = getOldTypeText()
 
     public val defaultValueParameterReferences: Map<PsiReference, DeclarationDescriptor>
 
     init {
-        val file = defaultValueForCall?.getContainingFile() as? JetFile
+        val file = defaultValueForCall?.getContainingFile() as? KtFile
         defaultValueParameterReferences =
                 if (defaultValueForCall != null && file != null && (file.isPhysical() || file.analysisContext != null)) {
                     val project = file.getProject()
                     val map = LinkedHashMap<PsiReference, DeclarationDescriptor>()
 
                     defaultValueForCall!!.accept(
-                            object : JetTreeVisitorVoid() {
+                            object : KtTreeVisitorVoid() {
                                 private fun selfParameterOrNull(parameter: DeclarationDescriptor?): ValueParameterDescriptor? {
                                     return if (parameter is ValueParameterDescriptor &&
                                                compareDescriptors(project, parameter.getContainingDeclaration(), callableDescriptor)) {
@@ -87,8 +87,8 @@ public class JetParameterInfo(
                                 }
 
                                 private fun getRelevantDescriptor(
-                                        expression: JetSimpleNameExpression,
-                                        ref: JetReference
+                                        expression: KtSimpleNameExpression,
+                                        ref: KtReference
                                 ): DeclarationDescriptor? {
                                     val context = expression.analyze(BodyResolveMode.PARTIAL)
 
@@ -96,7 +96,7 @@ public class JetParameterInfo(
                                     if (descriptor is ValueParameterDescriptor) return selfParameterOrNull(descriptor)
 
                                     if (descriptor is PropertyDescriptor && callableDescriptor is ConstructorDescriptor) {
-                                        val parameter = DescriptorToSourceUtils.getSourceFromDescriptor(descriptor) as? JetParameter
+                                        val parameter = DescriptorToSourceUtils.getSourceFromDescriptor(descriptor) as? KtParameter
                                         return parameter?.let { selfParameterOrNull(context[BindingContext.VALUE_PARAMETER, it]) }
                                     }
 
@@ -111,7 +111,7 @@ public class JetParameterInfo(
                                     return null
                                 }
 
-                                override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+                                override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
                                     val ref = expression.mainReference
                                     val descriptor = getRelevantDescriptor(expression, ref) ?: return
                                     map[ref] = descriptor
@@ -186,7 +186,7 @@ public class JetParameterInfo(
         if (originalIndex < 0) return !inheritedCallable.hasExpectedType()
 
         val inheritedParameterDescriptor = inheritedFunctionDescriptor.getValueParameters().get(originalIndex)
-        val parameter = DescriptorToSourceUtils.descriptorToDeclaration(inheritedParameterDescriptor) as? JetParameter ?: return false
+        val parameter = DescriptorToSourceUtils.descriptorToDeclaration(inheritedParameterDescriptor) as? KtParameter ?: return false
         return parameter.getTypeReference() != null
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetValVar.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetValVar.kt
index a851b7c7818..1b35cd7e898 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetValVar.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetValVar.kt
@@ -17,30 +17,30 @@
 package org.jetbrains.kotlin.idea.refactoring.changeSignature
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtPsiFactory
 
 public enum class JetValVar(val keywordName: String) {
     None("none") {
-        override fun createKeyword(factory: JetPsiFactory) = null
+        override fun createKeyword(factory: KtPsiFactory) = null
     },
     Val("val") {
-        override fun createKeyword(factory: JetPsiFactory) = factory.createValKeyword()
+        override fun createKeyword(factory: KtPsiFactory) = factory.createValKeyword()
     },
     Var("var"){
-        override fun createKeyword(factory: JetPsiFactory) = factory.createVarKeyword()
+        override fun createKeyword(factory: KtPsiFactory) = factory.createVarKeyword()
     };
 
     override fun toString(): String = keywordName
 
-    abstract fun createKeyword(factory: JetPsiFactory): PsiElement?
+    abstract fun createKeyword(factory: KtPsiFactory): PsiElement?
 }
 
 fun PsiElement?.toValVar(): JetValVar {
     return when {
         this == null -> JetValVar.None
-        getNode().getElementType() == JetTokens.VAL_KEYWORD -> JetValVar.Val
-        getNode().getElementType() == JetTokens.VAR_KEYWORD -> JetValVar.Var
+        getNode().getElementType() == KtTokens.VAL_KEYWORD -> JetValVar.Val
+        getNode().getElementType() == KtTokens.VAR_KEYWORD -> JetValVar.Var
         else -> throw IllegalArgumentException("Unknown val/var token: " + getText())
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinAwareJavaParameterInfoImpl.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinAwareJavaParameterInfoImpl.kt
index 7886850ec90..4def008a391 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinAwareJavaParameterInfoImpl.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinAwareJavaParameterInfoImpl.kt
@@ -18,11 +18,11 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature
 
 import com.intellij.psi.PsiType
 import com.intellij.refactoring.changeSignature.ParameterInfoImpl
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 
 public class KotlinAwareJavaParameterInfoImpl(
         oldParameterIndex: Int,
         name: String,
         type: PsiType,
-        val kotlinDefaultValue: JetExpression?
+        val kotlinDefaultValue: KtExpression?
 ): ParameterInfoImpl(oldParameterIndex, name, type, kotlinDefaultValue?.getText() ?: "")
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/changeSignatureUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/changeSignatureUtils.kt
index 5b1d80d1148..18aef4ab825 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/changeSignatureUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/changeSignatureUtils.kt
@@ -27,23 +27,23 @@ import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCaller
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.substitutions.getCallableSubstitutor
 
-fun JetNamedDeclaration.getDeclarationBody(): JetElement? {
+fun KtNamedDeclaration.getDeclarationBody(): KtElement? {
     return when {
-        this is JetClassOrObject -> getDelegationSpecifierList()
-        this is JetPrimaryConstructor -> getContainingClassOrObject().getDelegationSpecifierList()
-        this is JetSecondaryConstructor -> getDelegationCall()
-        this is JetNamedFunction -> getBodyExpression()
+        this is KtClassOrObject -> getDelegationSpecifierList()
+        this is KtPrimaryConstructor -> getContainingClassOrObject().getDelegationSpecifierList()
+        this is KtSecondaryConstructor -> getDelegationCall()
+        this is KtNamedFunction -> getBodyExpression()
         else -> null
     }
 }
 
 public fun PsiElement.isCaller(allUsages: Array<out UsageInfo>): Boolean {
-    val elementToSearch = (this as? JetClass)?.getPrimaryConstructor() ?: this
+    val elementToSearch = (this as? KtClass)?.getPrimaryConstructor() ?: this
     return allUsages
             .asSequence()
             .filter {
@@ -56,10 +56,10 @@ public fun PsiElement.isCaller(allUsages: Array<out UsageInfo>): Boolean {
             .any { it.getElement() == elementToSearch }
 }
 
-public fun JetElement.isInsideOfCallerBody(allUsages: Array<out UsageInfo>): Boolean {
+public fun KtElement.isInsideOfCallerBody(allUsages: Array<out UsageInfo>): Boolean {
     val container = parentsWithSelf.firstOrNull {
-        it is JetNamedFunction || it is JetConstructor<*> || it is JetClassOrObject
-    } as? JetNamedDeclaration ?: return false
+        it is KtNamedFunction || it is KtConstructor<*> || it is KtClassOrObject
+    } as? KtNamedDeclaration ?: return false
     val body = container.getDeclarationBody() ?: return false
     return body.getTextRange().contains(getTextRange()) && container.isCaller(allUsages)
 }
@@ -73,7 +73,7 @@ fun getCallableSubstitutor(
     return getCallableSubstitutor(currentBaseFunction, currentDerivedFunction)
 }
 
-fun JetType.renderTypeWithSubstitution(substitutor: TypeSubstitutor?, defaultText: String, inArgumentPosition: Boolean): String {
+fun KtType.renderTypeWithSubstitution(substitutor: TypeSubstitutor?, defaultText: String, inArgumentPosition: Boolean): String {
     val newType = substitutor?.substitute(this, Variance.INVARIANT) ?: return defaultText
     val renderer = if (inArgumentPosition) IdeDescriptorRenderers.SOURCE_CODE_FOR_TYPE_ARGUMENTS else IdeDescriptorRenderers.SOURCE_CODE
     return renderer.renderType(newType)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetCallableParameterTableModel.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetCallableParameterTableModel.java
index 8b36d404463..50c57afda87 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetCallableParameterTableModel.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetCallableParameterTableModel.java
@@ -26,9 +26,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetValVar;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetPsiFactory;
-import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtPsiFactory;
+import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
 
 public abstract class JetCallableParameterTableModel extends ParameterTableModelBase<JetParameterInfo, ParameterTableModelItemBase<JetParameterInfo>> {
     private final Project project;
@@ -50,9 +50,9 @@ public abstract class JetCallableParameterTableModel extends ParameterTableModel
         if (parameterInfo == null) {
             parameterInfo = new JetParameterInfo(methodDescriptor.getBaseDescriptor(), -1, "", null, null, null, JetValVar.None, null);
         }
-        JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(project);
+        KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(project);
         PsiCodeFragment paramTypeCodeFragment = psiFactory.createTypeCodeFragment(parameterInfo.getTypeText(), myTypeContext);
-        JetExpression defaultValueForCall = parameterInfo.getDefaultValueForCall();
+        KtExpression defaultValueForCall = parameterInfo.getDefaultValueForCall();
         PsiCodeFragment defaultValueCodeFragment = psiFactory.createExpressionCodeFragment(
                 defaultValueForCall != null ? defaultValueForCall.getText() : "",
                 myDefaultValueContext
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangePropertySignatureDialog.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangePropertySignatureDialog.kt
index 02eb0db99cf..c8be5b0e3a6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangePropertySignatureDialog.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangePropertySignatureDialog.kt
@@ -28,12 +28,12 @@ import com.intellij.ui.NonFocusableCheckBox
 import com.intellij.util.ui.FormBuilder
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.core.refactoring.validateElement
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetTypeCodeFragment
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtTypeCodeFragment
 import org.jetbrains.kotlin.resolve.AnalyzingUtils
 import javax.swing.JCheckBox
 import javax.swing.JComboBox
@@ -74,11 +74,11 @@ public class JetChangePropertySignatureDialog(
         }
 
         val documentManager = PsiDocumentManager.getInstance(myProject)
-        val psiFactory = JetPsiFactory(myProject)
+        val psiFactory = KtPsiFactory(myProject)
 
         return with(FormBuilder.createFormBuilder()) {
             val baseDeclaration = methodDescriptor.baseDeclaration
-            if (!((baseDeclaration as? JetProperty)?.isLocal() ?: false)) {
+            if (!((baseDeclaration as? KtProperty)?.isLocal() ?: false)) {
                 visibilityCombo.setSelectedItem(methodDescriptor.getVisibility())
                 addLabeledComponent("&Visibility: ", visibilityCombo)
             }
@@ -87,10 +87,10 @@ public class JetChangePropertySignatureDialog(
 
             val returnTypeCodeFragment = psiFactory.createTypeCodeFragment(methodDescriptor.renderOriginalReturnType(),
                                                                            baseDeclaration)
-            returnTypeField = EditorTextField(documentManager.getDocument(returnTypeCodeFragment), myProject, JetFileType.INSTANCE)
+            returnTypeField = EditorTextField(documentManager.getDocument(returnTypeCodeFragment), myProject, KotlinFileType.INSTANCE)
             addLabeledComponent("&Type: ", returnTypeField)
 
-            if (baseDeclaration is JetProperty) {
+            if (baseDeclaration is KtProperty) {
                 addSeparator()
 
                 val receiverTypeCheckBox = JCheckBox("Extension property: ")
@@ -102,7 +102,7 @@ public class JetChangePropertySignatureDialog(
 
                 val receiverTypeCodeFragment = psiFactory.createTypeCodeFragment(methodDescriptor.renderOriginalReceiverType() ?: "",
                                                                                  methodDescriptor.baseDeclaration)
-                receiverTypeField = EditorTextField(documentManager.getDocument(receiverTypeCodeFragment), myProject, JetFileType.INSTANCE)
+                receiverTypeField = EditorTextField(documentManager.getDocument(receiverTypeCodeFragment), myProject, KotlinFileType.INSTANCE)
                 receiverTypeLabel = JLabel("Receiver type: ")
                 receiverTypeLabel.setDisplayedMnemonic('t')
                 addLabeledComponent(receiverTypeLabel, receiverTypeField)
@@ -111,7 +111,7 @@ public class JetChangePropertySignatureDialog(
                     val receiverDefaultValueCodeFragment = psiFactory.createExpressionCodeFragment("", methodDescriptor.baseDeclaration)
                     receiverDefaultValueField = EditorTextField(documentManager.getDocument(receiverDefaultValueCodeFragment),
                                                                 myProject,
-                                                                JetFileType.INSTANCE)
+                                                                KotlinFileType.INSTANCE)
                     receiverDefaultValueLabel = JLabel("Default receiver value: ")
                     receiverDefaultValueLabel!!.setDisplayedMnemonic('D')
                     addLabeledComponent(receiverDefaultValueLabel, receiverDefaultValueField!!)
@@ -124,13 +124,13 @@ public class JetChangePropertySignatureDialog(
         }
     }
 
-    private fun getDefaultReceiverValue(): JetExpression? {
+    private fun getDefaultReceiverValue(): KtExpression? {
         val receiverDefaultValue = receiverDefaultValueField?.getText() ?: ""
-        return if (receiverDefaultValue.isNotEmpty()) JetPsiFactory(myProject).createExpression(receiverDefaultValue) else null
+        return if (receiverDefaultValue.isNotEmpty()) KtPsiFactory(myProject).createExpression(receiverDefaultValue) else null
     }
 
     override fun canRun() {
-        val psiFactory = JetPsiFactory(myProject)
+        val psiFactory = KtPsiFactory(myProject)
 
         psiFactory.createSimpleName(nameField.getText()).validateElement("Invalid name")
         psiFactory.createType(returnTypeField.getText()).validateElement("Invalid return type")
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangeSignatureDialog.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangeSignatureDialog.kt
index aa61451270b..b409f861b7b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangeSignatureDialog.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangeSignatureDialog.kt
@@ -44,13 +44,13 @@ import com.intellij.util.ui.table.JBTableRow
 import com.intellij.util.ui.table.JBTableRowEditor
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.*
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor.Kind
-import org.jetbrains.kotlin.psi.JetExpressionCodeFragment
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetTypeCodeFragment
+import org.jetbrains.kotlin.psi.KtExpressionCodeFragment
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtTypeCodeFragment
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import java.awt.BorderLayout
 import java.awt.Font
@@ -72,7 +72,7 @@ public class JetChangeSignatureDialog(
         JetMethodDescriptor,
         ParameterTableModelItemBase<JetParameterInfo>,
         JetCallableParameterTableModel>(project, methodDescriptor, false, context) {
-    override fun getFileType() = JetFileType.INSTANCE
+    override fun getFileType() = KotlinFileType.INSTANCE
 
     override fun createParametersInfoModel(descriptor: JetMethodDescriptor) = createParametersInfoModel(descriptor, myDefaultValueContext)
 
@@ -383,7 +383,7 @@ public class JetChangeSignatureDialog(
         }
 
         private fun createReturnTypeCodeFragment(project: Project, method: JetMethodDescriptor) =
-                JetPsiFactory(project).createTypeCodeFragment(method.renderOriginalReturnType(), method.baseDeclaration)
+                KtPsiFactory(project).createTypeCodeFragment(method.renderOriginalReturnType(), method.baseDeclaration)
 
         public fun createRefactoringProcessorForSilentChangeSignature(project: Project,
                                                                       commandName: String,
@@ -410,7 +410,7 @@ public class JetChangeSignatureDialog(
                 val parameterInfo = parameter.parameter
 
                 parameterInfo.currentTypeText = parameter.typeCodeFragment.getText().trim()
-                val codeFragment = parameter.defaultValueCodeFragment as JetExpressionCodeFragment
+                val codeFragment = parameter.defaultValueCodeFragment as KtExpressionCodeFragment
                 val oldDefaultValue = parameterInfo.defaultValueForCall
                 if (codeFragment.getText() != (if (oldDefaultValue != null) oldDefaultValue.getText() else "")) {
                     parameterInfo.defaultValueForCall = codeFragment.getContentElement()
@@ -433,6 +433,6 @@ public class JetChangeSignatureDialog(
         }
 
         private fun hasTypeReference(codeFragment: PsiCodeFragment?): Boolean
-                = (codeFragment as? JetTypeCodeFragment)?.hasTypeReference() ?: false
+                = (codeFragment as? KtTypeCodeFragment)?.hasTypeReference() ?: false
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetFunctionParameterTableModel.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetFunctionParameterTableModel.java
index 8627ff65306..ff715a5276c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetFunctionParameterTableModel.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetFunctionParameterTableModel.java
@@ -23,7 +23,7 @@ import com.intellij.refactoring.ui.StringTableCellEditor;
 import com.intellij.ui.BooleanTableCellRenderer;
 import com.intellij.util.ui.ColumnInfo;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
 
@@ -35,9 +35,9 @@ public class JetFunctionParameterTableModel extends JetCallableParameterTableMod
         super(methodDescriptor,
               context,
               new NameColumn(context.getProject()),
-              new TypeColumn(context.getProject(), JetFileType.INSTANCE),
+              new TypeColumn(context.getProject(), KotlinFileType.INSTANCE),
               new DefaultValueColumn<JetParameterInfo, ParameterTableModelItemBase<JetParameterInfo>>(context.getProject(),
-                                                                                                      JetFileType.INSTANCE),
+                                                                                                      KotlinFileType.INSTANCE),
               new ReceiverColumn(context.getProject(), methodDescriptor));
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetPrimaryConstructorParameterTableModel.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetPrimaryConstructorParameterTableModel.java
index e3e42a5fe6a..2b79c4dbff1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetPrimaryConstructorParameterTableModel.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetPrimaryConstructorParameterTableModel.java
@@ -21,7 +21,7 @@ import com.intellij.psi.PsiElement;
 import com.intellij.refactoring.changeSignature.ParameterTableModelItemBase;
 import com.intellij.util.ui.ColumnInfo;
 import org.jdesktop.swingx.autocomplete.ComboBoxCellEditor;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
@@ -37,8 +37,8 @@ public class JetPrimaryConstructorParameterTableModel extends JetCallableParamet
               context,
               new ValVarColumn(),
               new NameColumn(context.getProject()),
-              new TypeColumn(context.getProject(), JetFileType.INSTANCE),
-              new DefaultValueColumn<JetParameterInfo, ParameterTableModelItemBase<JetParameterInfo>>(context.getProject(), JetFileType.INSTANCE));
+              new TypeColumn(context.getProject(), KotlinFileType.INSTANCE),
+              new DefaultValueColumn<JetParameterInfo, ParameterTableModelItemBase<JetParameterInfo>>(context.getProject(), KotlinFileType.INSTANCE));
     }
 
     public static boolean isValVarColumn(ColumnInfo column) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetSecondaryConstructorParameterTableModel.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetSecondaryConstructorParameterTableModel.java
index 45198b54b37..3c8571f54fc 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetSecondaryConstructorParameterTableModel.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetSecondaryConstructorParameterTableModel.java
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature.ui;
 
 import com.intellij.psi.PsiElement;
 import com.intellij.refactoring.changeSignature.ParameterTableModelItemBase;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
 
@@ -27,7 +27,7 @@ public class JetSecondaryConstructorParameterTableModel extends JetCallableParam
         super(methodDescriptor,
               context,
               new NameColumn(context.getProject()),
-              new TypeColumn(context.getProject(), JetFileType.INSTANCE),
-              new DefaultValueColumn<JetParameterInfo, ParameterTableModelItemBase<JetParameterInfo>>(context.getProject(), JetFileType.INSTANCE));
+              new TypeColumn(context.getProject(), KotlinFileType.INSTANCE),
+              new DefaultValueColumn<JetParameterInfo, ParameterTableModelItemBase<JetParameterInfo>>(context.getProject(), KotlinFileType.INSTANCE));
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/KotlinCallerChooser.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/KotlinCallerChooser.kt
index 0919f5b7e0d..f84857fd5d3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/KotlinCallerChooser.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/KotlinCallerChooser.kt
@@ -37,13 +37,13 @@ import org.jetbrains.kotlin.asJava.toLightMethods
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.resolve.getJavaMethodDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.hierarchy.calls.KotlinCallHierarchyNodeDescriptor
 import org.jetbrains.kotlin.idea.hierarchy.calls.KotlinCallerMethodsTreeStructure
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetFunction
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import java.util.HashSet
 import java.util.LinkedHashSet
@@ -54,7 +54,7 @@ public class KotlinCallerChooser(
         title: String,
         previousTree: Tree?,
         callback: Consumer<Set<PsiElement>>
-): CallerChooserBase<PsiElement>(declaration, project, title, previousTree, "dummy." + JetFileType.EXTENSION, callback) {
+): CallerChooserBase<PsiElement>(declaration, project, title, previousTree, "dummy." + KotlinFileType.EXTENSION, callback) {
     override fun createTreeNode(method: PsiElement?, called: com.intellij.util.containers.HashSet<PsiElement>, cancelCallback: Runnable): KotlinMethodNode {
         return KotlinMethodNode(method, called, myProject, cancelCallback)
     }
@@ -80,8 +80,8 @@ public class KotlinMethodNode(
 
     override fun customizeRendererText(renderer: ColoredTreeCellRenderer) {
         val descriptor = when (myMethod) {
-            is JetFunction -> myMethod.resolveToDescriptor() as FunctionDescriptor
-            is JetClass -> (myMethod.resolveToDescriptor() as ClassDescriptor).getUnsubstitutedPrimaryConstructor() ?: return
+            is KtFunction -> myMethod.resolveToDescriptor() as FunctionDescriptor
+            is KtClass -> (myMethod.resolveToDescriptor() as ClassDescriptor).getUnsubstitutedPrimaryConstructor() ?: return
             is PsiMethod -> myMethod.getJavaMethodDescriptor() ?: return
             else -> throw AssertionError("Invalid declaration: ${myMethod.getElementTextWithContext()}")
         }
@@ -112,7 +112,7 @@ public class KotlinMethodNode(
 
         val processor = object: KotlinCallerMethodsTreeStructure.CalleeReferenceProcessor(false) {
             override fun onAccept(ref: PsiReference, element: PsiElement) {
-                if ((element is JetFunction || element is JetClass || element is PsiMethod) && element !in myCalled) {
+                if ((element is KtFunction || element is KtClass || element is PsiMethod) && element !in myCalled) {
                     callers.add(element)
                 }
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodDeferredKotlinUsage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodDeferredKotlinUsage.kt
index 8123e2d3552..16a7f28ebf0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodDeferredKotlinUsage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodDeferredKotlinUsage.kt
@@ -20,42 +20,42 @@ import com.intellij.psi.PsiElement
 import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
-import org.jetbrains.kotlin.psi.JetConstructorDelegationCall
-import org.jetbrains.kotlin.psi.JetFunction
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.psi.KtConstructorDelegationCall
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
+import org.jetbrains.kotlin.types.KtType
 
 public abstract class JavaMethodDeferredKotlinUsage<T : PsiElement>(element: T) : UsageInfo(element) {
     abstract fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<T>
 }
 
 public class DeferredJavaMethodOverrideOrSAMUsage(
-        val function: JetFunction,
+        val function: KtFunction,
         val functionDescriptor: FunctionDescriptor,
-        val samCallType: JetType?
-) : JavaMethodDeferredKotlinUsage<JetFunction>(function) {
-    override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<JetFunction> {
-        return object : JavaMethodKotlinUsageWithDelegate<JetFunction>(function, javaMethodChangeInfo) {
+        val samCallType: KtType?
+) : JavaMethodDeferredKotlinUsage<KtFunction>(function) {
+    override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<KtFunction> {
+        return object : JavaMethodKotlinUsageWithDelegate<KtFunction>(function, javaMethodChangeInfo) {
             override val delegateUsage = JetCallableDefinitionUsage(function, functionDescriptor, javaMethodChangeInfo.methodDescriptor.originalPrimaryCallable, samCallType)
         }
     }
 }
 
 public class DeferredJavaMethodKotlinCallerUsage(
-        val declaration: JetNamedDeclaration
-) : JavaMethodDeferredKotlinUsage<JetNamedDeclaration>(declaration) {
-    override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<JetNamedDeclaration> {
-        return object : JavaMethodKotlinUsageWithDelegate<JetNamedDeclaration>(declaration, javaMethodChangeInfo) {
+        val declaration: KtNamedDeclaration
+) : JavaMethodDeferredKotlinUsage<KtNamedDeclaration>(declaration) {
+    override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<KtNamedDeclaration> {
+        return object : JavaMethodKotlinUsageWithDelegate<KtNamedDeclaration>(declaration, javaMethodChangeInfo) {
             override val delegateUsage = KotlinCallerUsage(declaration)
         }
     }
 }
 
 public class JavaConstructorDeferredUsageInDelegationCall(
-        val delegationCall: JetConstructorDelegationCall
-) : JavaMethodDeferredKotlinUsage<JetConstructorDelegationCall>(delegationCall) {
-    override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<JetConstructorDelegationCall> {
-        return object : JavaMethodKotlinUsageWithDelegate<JetConstructorDelegationCall>(delegationCall, javaMethodChangeInfo) {
+        val delegationCall: KtConstructorDelegationCall
+) : JavaMethodDeferredKotlinUsage<KtConstructorDelegationCall>(delegationCall) {
+    override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<KtConstructorDelegationCall> {
+        return object : JavaMethodKotlinUsageWithDelegate<KtConstructorDelegationCall>(delegationCall, javaMethodChangeInfo) {
             override val delegateUsage = JetConstructorDelegationCallUsage(delegationCall, javaMethodChangeInfo)
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt
index 5be6bb3f743..1c1209924bf 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt
@@ -16,11 +16,11 @@
 
 package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 
-import org.jetbrains.kotlin.psi.JetCallElement
+import org.jetbrains.kotlin.psi.KtCallElement
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
 import com.intellij.usageView.UsageInfo
-import org.jetbrains.kotlin.psi.JetFunction
+import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 
 public abstract class JavaMethodKotlinUsageWithDelegate<T: PsiElement>(
@@ -32,9 +32,9 @@ public abstract class JavaMethodKotlinUsageWithDelegate<T: PsiElement>(
 }
 
 public class JavaMethodKotlinCallUsage(
-        callElement: JetCallElement,
+        callElement: KtCallElement,
         javaMethodChangeInfo: JetChangeInfo,
-        propagationCall: Boolean): JavaMethodKotlinUsageWithDelegate<JetCallElement>(callElement, javaMethodChangeInfo) {
+        propagationCall: Boolean): JavaMethodKotlinUsageWithDelegate<KtCallElement>(callElement, javaMethodChangeInfo) {
     override val delegateUsage = if (propagationCall) {
         KotlinCallerCallUsage(psiElement)
     } else {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetCallableDefinitionUsage.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetCallableDefinitionUsage.java
index 761902fdc88..fcc72e8504a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetCallableDefinitionUsage.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetCallableDefinitionUsage.java
@@ -41,7 +41,7 @@ import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetValVar;
 import org.jetbrains.kotlin.idea.util.ShortenReferences;
 import org.jetbrains.kotlin.idea.util.ShortenReferences.Options;
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.JetPsiUtilKt;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt;
@@ -49,7 +49,7 @@ import org.jetbrains.kotlin.psi.typeRefHelpers.TypeRefHelpersKt;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 import org.jetbrains.kotlin.types.substitutions.SubstitutionUtilsKt;
 
@@ -69,7 +69,7 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
     private final boolean hasExpectedType;
 
     @Nullable
-    private final JetType samCallType;
+    private final KtType samCallType;
 
     @Nullable
     private TypeSubstitutor typeSubstitutor;
@@ -78,7 +78,7 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
             @NotNull T function,
             @NotNull CallableDescriptor originalCallableDescriptor,
             @Nullable JetCallableDefinitionUsage<PsiElement> baseFunction,
-            @Nullable JetType samCallType
+            @Nullable KtType samCallType
     ) {
         super(function);
         this.originalCallableDescriptor = originalCallableDescriptor;
@@ -90,14 +90,14 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
     private static boolean checkIfHasExpectedType(@NotNull CallableDescriptor callableDescriptor, boolean isInherited) {
         if (!(callableDescriptor instanceof AnonymousFunctionDescriptor && isInherited)) return false;
 
-        JetFunctionLiteral functionLiteral =
-                (JetFunctionLiteral) DescriptorToSourceUtils.descriptorToDeclaration(callableDescriptor);
+        KtFunctionLiteral functionLiteral =
+                (KtFunctionLiteral) DescriptorToSourceUtils.descriptorToDeclaration(callableDescriptor);
         assert functionLiteral != null : "No declaration found for " + callableDescriptor;
 
         PsiElement parent = functionLiteral.getParent();
-        if (!(parent instanceof JetFunctionLiteralExpression)) return false;
+        if (!(parent instanceof KtFunctionLiteralExpression)) return false;
 
-        JetFunctionLiteralExpression expression = (JetFunctionLiteralExpression) parent;
+        KtFunctionLiteralExpression expression = (KtFunctionLiteralExpression) parent;
         return ResolutionUtils.analyze(expression, BodyResolveMode.PARTIAL).get(BindingContext.EXPECTED_EXPRESSION_TYPE, expression) != null;
     }
 
@@ -155,11 +155,11 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
         if (currentCallableDescriptor == null) {
             PsiElement element = getDeclaration();
 
-            if (element instanceof JetFunction || element instanceof JetProperty || element instanceof JetParameter) {
-                currentCallableDescriptor = (CallableDescriptor) ResolutionUtils.resolveToDescriptor((JetDeclaration) element);
+            if (element instanceof KtFunction || element instanceof KtProperty || element instanceof KtParameter) {
+                currentCallableDescriptor = (CallableDescriptor) ResolutionUtils.resolveToDescriptor((KtDeclaration) element);
             }
-            else if (element instanceof JetClass) {
-                currentCallableDescriptor = ((ClassDescriptor) ResolutionUtils.resolveToDescriptor((JetClass) element)).getUnsubstitutedPrimaryConstructor();
+            else if (element instanceof KtClass) {
+                currentCallableDescriptor = ((ClassDescriptor) ResolutionUtils.resolveToDescriptor((KtClass) element)).getUnsubstitutedPrimaryConstructor();
             }
             else if (element instanceof PsiMethod) {
                 currentCallableDescriptor = JavaResolutionUtils.getJavaMethodDescriptor((PsiMethod) element);
@@ -170,12 +170,12 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
 
     @Override
     public boolean processUsage(@NotNull JetChangeInfo changeInfo, @NotNull PsiElement element, @NotNull UsageInfo[] allUsages) {
-        if (!(element instanceof JetNamedDeclaration)) return true;
+        if (!(element instanceof KtNamedDeclaration)) return true;
 
-        JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(element.getProject());
+        KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(element.getProject());
 
         if (changeInfo.isNameChanged()) {
-            PsiElement identifier = ((JetCallableDeclaration) element).getNameIdentifier();
+            PsiElement identifier = ((KtCallableDeclaration) element).getNameIdentifier();
 
             if (identifier != null) {
                 identifier.replace(psiFactory.createIdentifier(changeInfo.getNewName()));
@@ -184,7 +184,7 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
 
         changeReturnTypeIfNeeded(changeInfo, element);
 
-        JetParameterList parameterList = JetPsiUtilKt.getValueParameterList((JetNamedDeclaration) element);
+        KtParameterList parameterList = JetPsiUtilKt.getValueParameterList((KtNamedDeclaration) element);
 
         if (changeInfo.isParameterSetOrOrderChanged()) {
             processParameterListWithStructuralChanges(changeInfo, element, parameterList, psiFactory);
@@ -192,7 +192,7 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
         else if (parameterList != null) {
             int paramIndex = originalCallableDescriptor.getExtensionReceiverParameter() != null ? 1 : 0;
 
-            for (JetParameter parameter : parameterList.getParameters()) {
+            for (KtParameter parameter : parameterList.getParameters()) {
                 JetParameterInfo parameterInfo = changeInfo.getNewParameters()[paramIndex];
                 changeParameter(paramIndex, parameter, parameterInfo);
                 paramIndex++;
@@ -201,18 +201,18 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
             ShortenWaitingSetKt.addToShorteningWaitSet(parameterList, Options.DEFAULT);
         }
 
-        if (element instanceof JetCallableDeclaration && changeInfo.isReceiverTypeChanged()) {
+        if (element instanceof KtCallableDeclaration && changeInfo.isReceiverTypeChanged()) {
             //noinspection unchecked
             String receiverTypeText = changeInfo.renderReceiverType((JetCallableDefinitionUsage<PsiElement>) this);
-            JetTypeReference receiverTypeRef = receiverTypeText != null ? psiFactory.createType(receiverTypeText) : null;
-            JetTypeReference newReceiverTypeRef = TypeRefHelpersKt
-                    .setReceiverTypeReference((JetCallableDeclaration) element, receiverTypeRef);
+            KtTypeReference receiverTypeRef = receiverTypeText != null ? psiFactory.createType(receiverTypeText) : null;
+            KtTypeReference newReceiverTypeRef = TypeRefHelpersKt
+                    .setReceiverTypeReference((KtCallableDeclaration) element, receiverTypeRef);
             if (newReceiverTypeRef != null) {
                 ShortenWaitingSetKt.addToShorteningWaitSet(newReceiverTypeRef, ShortenReferences.Options.DEFAULT);
             }
         }
 
-        if (changeInfo.isVisibilityChanged() && !JetPsiUtil.isLocal((JetDeclaration) element)) {
+        if (changeInfo.isVisibilityChanged() && !KtPsiUtil.isLocal((KtDeclaration) element)) {
             changeVisibility(changeInfo, element);
         }
 
@@ -220,18 +220,18 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
     }
 
     protected void changeReturnTypeIfNeeded(JetChangeInfo changeInfo, PsiElement element) {
-        if (!(element instanceof JetCallableDeclaration)) return;
-        if (element instanceof JetConstructor) return;
+        if (!(element instanceof KtCallableDeclaration)) return;
+        if (element instanceof KtConstructor) return;
 
-        JetCallableDeclaration callable = (JetCallableDeclaration) element;
+        KtCallableDeclaration callable = (KtCallableDeclaration) element;
 
         boolean returnTypeIsNeeded;
-        if (element instanceof JetFunction) {
-            returnTypeIsNeeded = !(callable instanceof JetFunctionLiteral)
+        if (element instanceof KtFunction) {
+            returnTypeIsNeeded = !(callable instanceof KtFunctionLiteral)
                                  && (changeInfo.isRefactoringTarget(originalCallableDescriptor) || callable.getTypeReference() != null);
         }
         else {
-            returnTypeIsNeeded = element instanceof JetProperty || element instanceof JetParameter;
+            returnTypeIsNeeded = element instanceof KtProperty || element instanceof KtParameter;
         }
 
         if (changeInfo.isReturnTypeChanged() && returnTypeIsNeeded) {
@@ -241,7 +241,7 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
             //TODO use ChangeFunctionReturnTypeFix.invoke when JetTypeCodeFragment.getType() is ready
             if (!(returnTypeText.equals("Unit") || returnTypeText.equals("kotlin.Unit"))) {
                 ShortenWaitingSetKt.addToShorteningWaitSet(
-                        callable.setTypeReference(JetPsiFactoryKt.JetPsiFactory(callable).createType(returnTypeText)),
+                        callable.setTypeReference(KtPsiFactoryKt.KtPsiFactory(callable).createType(returnTypeText)),
                         Options.DEFAULT
                 );
             }
@@ -251,19 +251,19 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
     private void processParameterListWithStructuralChanges(
             JetChangeInfo changeInfo,
             PsiElement element,
-            JetParameterList parameterList,
-            JetPsiFactory psiFactory
+            KtParameterList parameterList,
+            KtPsiFactory psiFactory
     ) {
         int parametersCount = changeInfo.getNonReceiverParametersCount();
-        boolean isLambda = element instanceof JetFunctionLiteral;
+        boolean isLambda = element instanceof KtFunctionLiteral;
         boolean canReplaceEntireList = false;
 
-        JetParameterList newParameterList = null;
+        KtParameterList newParameterList = null;
         if (isLambda) {
             if (parametersCount == 0) {
                 if (parameterList != null) {
                     parameterList.delete();
-                    PsiElement arrow = ((JetFunctionLiteral)element).getArrow();
+                    PsiElement arrow = ((KtFunctionLiteral)element).getArrow();
                     if (arrow != null) {
                         arrow.delete();
                     }
@@ -277,7 +277,7 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
                 canReplaceEntireList = true;
             }
         }
-        else if (!(element instanceof JetProperty || element instanceof JetParameter)) {
+        else if (!(element instanceof KtProperty || element instanceof KtParameter)) {
             newParameterList = psiFactory.createParameterList(changeInfo.getNewParametersSignature(
                     (JetCallableDefinitionUsage<PsiElement>) this)
             );
@@ -287,24 +287,24 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
 
         if (parameterList != null) {
             if (canReplaceEntireList) {
-                newParameterList = (JetParameterList) parameterList.replace(newParameterList);
+                newParameterList = (KtParameterList) parameterList.replace(newParameterList);
             }
             else {
                 newParameterList = replaceParameterListAndKeepDelimiters(parameterList, newParameterList);
             }
         }
         else {
-            if (element instanceof JetClass) {
-                JetPrimaryConstructor constructor = createPrimaryConstructorIfAbsent((JetClass) element);
-                JetParameterList oldParameterList = constructor.getValueParameterList();
+            if (element instanceof KtClass) {
+                KtPrimaryConstructor constructor = createPrimaryConstructorIfAbsent((KtClass) element);
+                KtParameterList oldParameterList = constructor.getValueParameterList();
                 assert oldParameterList != null : "primary constructor from factory has parameter list";
-                newParameterList = (JetParameterList) oldParameterList.replace(newParameterList);
+                newParameterList = (KtParameterList) oldParameterList.replace(newParameterList);
             }
             else if (isLambda) {
                 //noinspection ConstantConditions
-                JetFunctionLiteral functionLiteral = (JetFunctionLiteral) element;
+                KtFunctionLiteral functionLiteral = (KtFunctionLiteral) element;
                 PsiElement anchor = functionLiteral.getLBrace();
-                newParameterList = (JetParameterList) element.addAfter(newParameterList, anchor);
+                newParameterList = (KtParameterList) element.addAfter(newParameterList, anchor);
                 if (functionLiteral.getArrow() == null) {
                     Pair<PsiElement, PsiElement> whitespaceAndArrow = psiFactory.createWhitespaceAndArrow();
                     element.addRangeAfter(whitespaceAndArrow.getFirst(), whitespaceAndArrow.getSecond(), newParameterList);
@@ -317,18 +317,18 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
         }
     }
 
-    private static JetParameterList replaceParameterListAndKeepDelimiters(JetParameterList parameterList, JetParameterList newParameterList) {
-        List<JetParameter> oldParameters = parameterList.getParameters();
-        List<JetParameter> newParameters = newParameterList.getParameters();
+    private static KtParameterList replaceParameterListAndKeepDelimiters(KtParameterList parameterList, KtParameterList newParameterList) {
+        List<KtParameter> oldParameters = parameterList.getParameters();
+        List<KtParameter> newParameters = newParameterList.getParameters();
         int oldCount = oldParameters.size();
         int newCount = newParameters.size();
 
         int commonCount = Math.min(oldCount, newCount);
         for (int i = 0; i < commonCount; i++) {
-            oldParameters.set(i, (JetParameter) oldParameters.get(i).replace(newParameters.get(i)));
+            oldParameters.set(i, (KtParameter) oldParameters.get(i).replace(newParameters.get(i)));
         }
 
-        if (commonCount == 0) return (JetParameterList) parameterList.replace(newParameterList);
+        if (commonCount == 0) return (KtParameterList) parameterList.replace(newParameterList);
 
         if (oldCount > commonCount) {
             parameterList.deleteChildRange(oldParameters.get(commonCount - 1).getNextSibling(),
@@ -345,22 +345,22 @@ public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageIn
     }
 
     private static void changeVisibility(JetChangeInfo changeInfo, PsiElement element) {
-        JetModifierKeywordToken newVisibilityToken = DescriptorUtilsKt.toKeywordToken(changeInfo.getNewVisibility());
+        KtModifierKeywordToken newVisibilityToken = DescriptorUtilsKt.toKeywordToken(changeInfo.getNewVisibility());
 
-        if (element instanceof JetCallableDeclaration) {
-            PsiModificationUtilsKt.setVisibility((JetCallableDeclaration)element, newVisibilityToken);
+        if (element instanceof KtCallableDeclaration) {
+            PsiModificationUtilsKt.setVisibility((KtCallableDeclaration)element, newVisibilityToken);
         }
-        else if (element instanceof JetClass) {
-            PsiModificationUtilsKt.setVisibility(createPrimaryConstructorIfAbsent((JetClass) element), newVisibilityToken);
+        else if (element instanceof KtClass) {
+            PsiModificationUtilsKt.setVisibility(createPrimaryConstructorIfAbsent((KtClass) element), newVisibilityToken);
         }
         else throw new AssertionError("Invalid element: " + PsiUtilsKt.getElementTextWithContext(element));
     }
 
-    private void changeParameter(int parameterIndex, JetParameter parameter, JetParameterInfo parameterInfo) {
+    private void changeParameter(int parameterIndex, KtParameter parameter, JetParameterInfo parameterInfo) {
         PsiElement valOrVarKeyword = parameter.getValOrVarKeyword();
         JetValVar valOrVar = parameterInfo.getValOrVar();
 
-        JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(getProject());
         if (valOrVarKeyword != null) {
             PsiElement newKeyword = valOrVar.createKeyword(psiFactory);
             if (newKeyword != null) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetConstructorDelegationCallUsage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetConstructorDelegationCallUsage.kt
index e193950b0af..734cdb790d2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetConstructorDelegationCallUsage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetConstructorDelegationCallUsage.kt
@@ -18,30 +18,30 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 
 import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
-import org.jetbrains.kotlin.psi.JetConstructorDelegationCall
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetSecondaryConstructor
+import org.jetbrains.kotlin.psi.KtConstructorDelegationCall
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtSecondaryConstructor
 
 public class JetConstructorDelegationCallUsage(
-        call: JetConstructorDelegationCall,
+        call: KtConstructorDelegationCall,
         changeInfo: JetChangeInfo
-) : JetUsageInfo<JetConstructorDelegationCall>(call) {
+) : JetUsageInfo<KtConstructorDelegationCall>(call) {
     val delegate = JetFunctionCallUsage(call, changeInfo.methodDescriptor.originalPrimaryCallable)
 
-    override fun processUsage(changeInfo: JetChangeInfo, element: JetConstructorDelegationCall, allUsages: Array<out UsageInfo>): Boolean {
+    override fun processUsage(changeInfo: JetChangeInfo, element: KtConstructorDelegationCall, allUsages: Array<out UsageInfo>): Boolean {
         val isThisCall = element.isCallToThis()
 
         var elementToWorkWith = element
         if (changeInfo.getNewParametersCount() > 0 && element.isImplicit()) {
-            val constructor = element.getParent() as JetSecondaryConstructor
+            val constructor = element.getParent() as KtSecondaryConstructor
             elementToWorkWith = constructor.replaceImplicitDelegationCallWithExplicit(isThisCall)
         }
 
         val result = delegate.processUsage(changeInfo, elementToWorkWith, allUsages)
 
         if (changeInfo.getNewParametersCount() == 0 && !isThisCall && !elementToWorkWith.isImplicit()) {
-            (elementToWorkWith.getParent() as? JetSecondaryConstructor)?.getColon()?.delete()
-            elementToWorkWith.replace(JetPsiFactory(element).createConstructorDelegationCall(""))
+            (elementToWorkWith.getParent() as? KtSecondaryConstructor)?.getColon()?.delete()
+            elementToWorkWith.replace(KtPsiFactory(element).createConstructorDelegationCall(""))
         }
 
         return result
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt
index c8e2e4e166b..8df10704084 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt
@@ -20,15 +20,15 @@ import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
 import org.jetbrains.kotlin.psi.*
 
-public class JetEnumEntryWithoutSuperCallUsage(enumEntry: JetEnumEntry) : JetUsageInfo<JetEnumEntry>(enumEntry) {
-    override fun processUsage(changeInfo: JetChangeInfo, element: JetEnumEntry, allUsages: Array<out UsageInfo>): Boolean {
+public class JetEnumEntryWithoutSuperCallUsage(enumEntry: KtEnumEntry) : JetUsageInfo<KtEnumEntry>(enumEntry) {
+    override fun processUsage(changeInfo: JetChangeInfo, element: KtEnumEntry, allUsages: Array<out UsageInfo>): Boolean {
         if (changeInfo.newParameters.size() > 0) {
-            val psiFactory = JetPsiFactory(element)
+            val psiFactory = KtPsiFactory(element)
 
             val delegatorToSuperCall = (element.addAfter(
                     psiFactory.createEnumEntryInitializerList(),
                     element.getNameAsDeclaration()
-            ) as JetInitializerList).initializers[0] as JetDelegatorToSuperCall
+            ) as KtInitializerList).initializers[0] as KtDelegatorToSuperCall
 
             return JetFunctionCallUsage(delegatorToSuperCall, changeInfo.methodDescriptor.originalPrimaryCallable)
                     .processUsage(changeInfo, delegatorToSuperCall, allUsages)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetFunctionCallUsage.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetFunctionCallUsage.java
index fed937ea370..c6943d077a9 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetFunctionCallUsage.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetFunctionCallUsage.java
@@ -51,19 +51,19 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExtensionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver;
-import org.jetbrains.kotlin.types.JetType;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.KtType;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
 
 import java.util.*;
 
-public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
-    private static final Comparator<Pair<JetElement, JetElement>>
-            REVERSED_TEXT_OFFSET_COMPARATOR = new Comparator<Pair<JetElement, JetElement>>() {
+public class JetFunctionCallUsage extends JetUsageInfo<KtCallElement> {
+    private static final Comparator<Pair<KtElement, KtElement>>
+            REVERSED_TEXT_OFFSET_COMPARATOR = new Comparator<Pair<KtElement, KtElement>>() {
         @Override
         public int compare(
-                @NotNull Pair<JetElement, JetElement> p1,
-                @NotNull Pair<JetElement, JetElement> p2
+                @NotNull Pair<KtElement, KtElement> p1,
+                @NotNull Pair<KtElement, KtElement> p2
         ) {
             int offset1 = p1.getFirst().getTextRange().getStartOffset();
             int offset2 = p2.getFirst().getTextRange().getStartOffset();
@@ -79,7 +79,7 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
     private final BindingContext context;
     private final ResolvedCall<? extends CallableDescriptor> resolvedCall;
 
-    public JetFunctionCallUsage(@NotNull JetCallElement element, JetCallableDefinitionUsage callee) {
+    public JetFunctionCallUsage(@NotNull KtCallElement element, JetCallableDefinitionUsage callee) {
         super(element);
         this.callee = callee;
         this.context = ResolutionUtils.analyze(element, BodyResolveMode.FULL);
@@ -87,7 +87,7 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
     }
 
     @Override
-    public boolean processUsage(@NotNull JetChangeInfo changeInfo, @NotNull JetCallElement element, @NotNull UsageInfo[] allUsages) {
+    public boolean processUsage(@NotNull JetChangeInfo changeInfo, @NotNull KtCallElement element, @NotNull UsageInfo[] allUsages) {
         if (shouldSkipUsage(element)) return true;
 
         changeNameIfNeeded(changeInfo, element);
@@ -102,11 +102,11 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
         }
 
         if (changeInfo.getNewParametersCount() == 0
-            && element instanceof JetDelegatorToSuperCall) {
-            JetEnumEntry enumEntry = PsiTreeUtil.getParentOfType(element, JetEnumEntry.class, true);
+            && element instanceof KtDelegatorToSuperCall) {
+            KtEnumEntry enumEntry = PsiTreeUtil.getParentOfType(element, KtEnumEntry.class, true);
             if (enumEntry != null && enumEntry.getInitializerList() == element.getParent()) {
                 PsiElement colon = enumEntry.getColon();
-                JetInitializerList initializerList = enumEntry.getInitializerList();
+                KtInitializerList initializerList = enumEntry.getInitializerList();
                 enumEntry.deleteChildRange(colon != null ? colon : initializerList, initializerList);
             }
         }
@@ -114,12 +114,12 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
         return true;
     }
 
-    private boolean shouldSkipUsage(JetCallElement element) {
+    private boolean shouldSkipUsage(KtCallElement element) {
         // TODO: We probable need more clever processing of invalid calls, but for now default to Java-like behaviour
-        if (resolvedCall == null && !(element instanceof JetDelegatorToSuperCall)) return true;
+        if (resolvedCall == null && !(element instanceof KtDelegatorToSuperCall)) return true;
         if (resolvedCall != null && !ArgumentMappingKt.isReallySuccess(resolvedCall)) {
             // TODO: investigate why arguments are not recorded for enum constructor call
-            if (element instanceof JetDelegatorToSuperCall && element.getParent().getParent() instanceof JetEnumEntry) return false;
+            if (element instanceof KtDelegatorToSuperCall && element.getParent().getParent() instanceof KtEnumEntry) return false;
             for (ValueArgument valueArgument : resolvedCall.getCall().getValueArguments()) {
                 if (!(resolvedCall.getArgumentMapping(valueArgument) instanceof ArgumentMatch)) return true;
             }
@@ -133,31 +133,31 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
 
     private boolean isPropertyJavaUsage() {
         PsiElement calleeElement = this.callee.getElement();
-        return (calleeElement instanceof JetProperty || calleeElement instanceof JetParameter)
+        return (calleeElement instanceof KtProperty || calleeElement instanceof KtParameter)
                && resolvedCall != null && resolvedCall.getResultingDescriptor() instanceof JavaMethodDescriptor;
     }
 
-    protected void changeNameIfNeeded(JetChangeInfo changeInfo, JetCallElement element) {
+    protected void changeNameIfNeeded(JetChangeInfo changeInfo, KtCallElement element) {
         if (!changeInfo.isNameChanged()) return;
 
-        JetExpression callee = element.getCalleeExpression();
-        if (!(callee instanceof JetSimpleNameExpression)) return;
+        KtExpression callee = element.getCalleeExpression();
+        if (!(callee instanceof KtSimpleNameExpression)) return;
 
         String newName = changeInfo.getNewName();
         if (isPropertyJavaUsage()) {
-            String currentName = ((JetSimpleNameExpression) callee).getReferencedName();
+            String currentName = ((KtSimpleNameExpression) callee).getReferencedName();
             if (JvmAbi.isGetterName(currentName)) newName = JvmAbi.getterName(newName);
             else if (JvmAbi.isSetterName(currentName)) newName = JvmAbi.setterName(newName);
         }
 
-        callee.replace(JetPsiFactoryKt.JetPsiFactory(getProject()).createSimpleName(newName));
+        callee.replace(KtPsiFactoryKt.KtPsiFactory(getProject()).createSimpleName(newName));
     }
 
     @Nullable
-    private JetExpression getReceiverExpressionIfMatched(
+    private KtExpression getReceiverExpressionIfMatched(
             @NotNull ReceiverValue receiverValue,
             @NotNull DeclarationDescriptor originalDescriptor,
-            @NotNull JetPsiFactory psiFactory
+            @NotNull KtPsiFactory psiFactory
     ) {
         if (!receiverValue.exists()) return null;
 
@@ -175,32 +175,32 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
                 ((ReceiverParameterDescriptor) originalDescriptor).getValue() instanceof ExtensionReceiver;
         if (currentIsExtension != originalIsExtension) return null;
 
-        JetType originalType = originalDescriptor instanceof ReceiverParameterDescriptor
+        KtType originalType = originalDescriptor instanceof ReceiverParameterDescriptor
                                ? ((ReceiverParameterDescriptor) originalDescriptor).getType()
                                : originalDescriptor instanceof ClassDescriptor
                                  ? ((ClassDescriptor) originalDescriptor).getDefaultType()
                                  : null;
-        if (originalType == null || !JetTypeChecker.DEFAULT.isSubtypeOf(receiverValue.getType(), originalType)) return null;
+        if (originalType == null || !KotlinTypeChecker.DEFAULT.isSubtypeOf(receiverValue.getType(), originalType)) return null;
 
         return getReceiverExpression(receiverValue, psiFactory);
     }
 
     private boolean needSeparateVariable(@NotNull PsiElement element) {
-        if (element instanceof JetConstantExpression) return false;
-        if (element instanceof JetThisExpression) return false;
-        if (element instanceof JetSimpleNameExpression) return false;
+        if (element instanceof KtConstantExpression) return false;
+        if (element instanceof KtThisExpression) return false;
+        if (element instanceof KtSimpleNameExpression) return false;
 
         //noinspection SuspiciousMethodCalls
-        if (element instanceof JetBinaryExpression
-            && OperatorConventions.ASSIGNMENT_OPERATIONS.containsKey(((JetBinaryExpression) element).getOperationToken())) return true;
+        if (element instanceof KtBinaryExpression
+            && OperatorConventions.ASSIGNMENT_OPERATIONS.containsKey(((KtBinaryExpression) element).getOperationToken())) return true;
 
         //noinspection SuspiciousMethodCalls
-        if (element instanceof JetUnaryExpression
-            && OperatorConventions.INCREMENT_OPERATIONS.contains(((JetUnaryExpression) element).getOperationToken())) return true;
+        if (element instanceof KtUnaryExpression
+            && OperatorConventions.INCREMENT_OPERATIONS.contains(((KtUnaryExpression) element).getOperationToken())) return true;
 
-        if (element instanceof JetCallExpression) {
+        if (element instanceof KtCallExpression) {
             ResolvedCall<? extends CallableDescriptor> resolvedCall =
-                    CallUtilKt.getResolvedCall((JetCallExpression) element, context);
+                    CallUtilKt.getResolvedCall((KtCallExpression) element, context);
             return resolvedCall != null && resolvedCall.getResultingDescriptor() instanceof ConstructorDescriptor;
         }
 
@@ -211,25 +211,25 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
     }
 
     @NotNull
-    private JetExpression substituteReferences(
-            @NotNull JetExpression expression,
+    private KtExpression substituteReferences(
+            @NotNull KtExpression expression,
             @NotNull Map<PsiReference, DeclarationDescriptor> referenceMap,
-            @NotNull final JetPsiFactory psiFactory
+            @NotNull final KtPsiFactory psiFactory
     ) {
         if (referenceMap.isEmpty() || resolvedCall == null) return expression;
 
-        JetExpression newExpression = (JetExpression) expression.copy();
+        KtExpression newExpression = (KtExpression) expression.copy();
 
-        Map<JetSimpleNameExpression, JetSimpleNameExpression> nameCounterpartMap =
+        Map<KtSimpleNameExpression, KtSimpleNameExpression> nameCounterpartMap =
                 ExtractorUtilKt.createNameCounterpartMap(expression, newExpression);
 
         Map<ValueParameterDescriptor, ResolvedValueArgument> valueArguments = resolvedCall.getValueArguments();
 
-        List<Pair<JetElement, JetElement>> replacements = new ArrayList<Pair<JetElement, JetElement>>();
+        List<Pair<KtElement, KtElement>> replacements = new ArrayList<Pair<KtElement, KtElement>>();
         for (Map.Entry<PsiReference, DeclarationDescriptor> e : referenceMap.entrySet()) {
             DeclarationDescriptor descriptor = e.getValue();
 
-            JetExpression argumentExpression;
+            KtExpression argumentExpression;
             boolean addReceiver = false;
             if (descriptor instanceof ValueParameterDescriptor) { // Ordinary parameter
                 // Find corresponding parameter in the current function (may differ from 'descriptor' if original function is part of override hierarchy)
@@ -256,19 +256,19 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
             //noinspection unchecked
             if (needSeparateVariable(argumentExpression) &&
                 PsiTreeUtil.getNonStrictParentOfType(getElement(),
-                                                     JetConstructorDelegationCall.class,
-                                                     JetDelegationSpecifier.class,
-                                                     JetParameter.class) == null) {
+                                                     KtConstructorDelegationCall.class,
+                                                     KtDelegationSpecifier.class,
+                                                     KtParameter.class) == null) {
 
-                final Ref<JetExpression> newExpressionRef = new Ref<JetExpression>();
+                final Ref<KtExpression> newExpressionRef = new Ref<KtExpression>();
                 KotlinIntroduceVariableHandler.doRefactoring(
                         getProject(),
                         null,
                         argumentExpression,
                         Collections.singletonList(argumentExpression),
-                        new Function1<JetProperty, Unit>() {
+                        new Function1<KtProperty, Unit>() {
                             @Override
-                            public Unit invoke(JetProperty property) {
+                            public Unit invoke(KtProperty property) {
                                 //noinspection ConstantConditions
                                 newExpressionRef.set(psiFactory.createExpression(property.getName()));
                                 return null;
@@ -279,47 +279,47 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
             }
 
             //noinspection SuspiciousMethodCalls
-            JetExpression expressionToReplace = nameCounterpartMap.get(e.getKey().getElement());
+            KtExpression expressionToReplace = nameCounterpartMap.get(e.getKey().getElement());
             if (expressionToReplace == null) continue;
             PsiElement parent = expressionToReplace.getParent();
-            if (parent instanceof JetThisExpression) {
-                expressionToReplace = (JetThisExpression) parent;
+            if (parent instanceof KtThisExpression) {
+                expressionToReplace = (KtThisExpression) parent;
             }
 
             if (addReceiver) {
-                JetCallExpression callExpression = PsiTreeUtil.getParentOfType(expressionToReplace, JetCallExpression.class, true);
+                KtCallExpression callExpression = PsiTreeUtil.getParentOfType(expressionToReplace, KtCallExpression.class, true);
                 if (callExpression != null && PsiTreeUtil.isAncestor(callExpression.getCalleeExpression(), expressionToReplace, false)) {
                     expressionToReplace = callExpression;
                 } else {
                     // Do not substitute operation references in infix/prefix calls
-                    if (parent instanceof JetOperationExpression
-                        && ((JetOperationExpression) parent).getOperationReference() == expressionToReplace) {
+                    if (parent instanceof KtOperationExpression
+                        && ((KtOperationExpression) parent).getOperationReference() == expressionToReplace) {
                         continue;
                     }
                 }
                 replacements.add(
-                        new Pair<JetElement, JetElement>(
+                        new Pair<KtElement, KtElement>(
                                 expressionToReplace,
                                 psiFactory.createExpression(argumentExpression.getText() + "." + expressionToReplace.getText())
                         )
                 );
             }
             else {
-                replacements.add(new Pair<JetElement, JetElement>(expressionToReplace, argumentExpression));
+                replacements.add(new Pair<KtElement, KtElement>(expressionToReplace, argumentExpression));
             }
         }
 
         // Sort by descending offset so that call arguments are replaced before call itself
         ContainerUtil.sort(replacements, REVERSED_TEXT_OFFSET_COMPARATOR);
-        for (Pair<JetElement, JetElement> replacement : replacements) {
+        for (Pair<KtElement, KtElement> replacement : replacements) {
             replacement.getFirst().replace(replacement.getSecond());
         }
 
         return newExpression;
     }
 
-    private void updateArgumentsAndReceiver(JetChangeInfo changeInfo, JetCallElement element, @NotNull UsageInfo[] allUsages) {
-        JetValueArgumentList arguments = element.getValueArgumentList();
+    private void updateArgumentsAndReceiver(JetChangeInfo changeInfo, KtCallElement element, @NotNull UsageInfo[] allUsages) {
+        KtValueArgumentList arguments = element.getValueArgumentList();
         assert arguments != null : "Argument list is expected: " + element.getText();
         List<? extends ValueArgument> oldArguments = element.getValueArguments();
 
@@ -334,7 +334,7 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
 
         TIntArrayList indicesOfArgumentsWithDefaultValues = new TIntArrayList();
 
-        JetPsiFactory psiFactory = new JetPsiFactory(element.getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(element.getProject());
 
         List<JetParameterInfo> newSignatureParameters = changeInfo.getNonReceiverParameters();
         for (JetParameterInfo parameterInfo : newSignatureParameters) {
@@ -345,7 +345,7 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
                 parametersBuilder.append(',');
             }
 
-            JetExpression defaultValueForCall = parameterInfo.getDefaultValueForCall();
+            KtExpression defaultValueForCall = parameterInfo.getDefaultValueForCall();
 
             String defaultValueText;
             if (ChangeSignatureUtilsKt.isInsideOfCallerBody(element, allUsages)) {
@@ -368,7 +368,7 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
         }
 
         parametersBuilder.append(')');
-        JetValueArgumentList newArgumentList = JetPsiFactoryKt.JetPsiFactory(getProject()).createCallArguments(parametersBuilder.toString());
+        KtValueArgumentList newArgumentList = KtPsiFactoryKt.KtPsiFactory(getProject()).createCallArguments(parametersBuilder.toString());
 
         Map<Integer, ? extends ValueArgument> argumentMap = getParamIndexToArgumentMap(changeInfo, oldArguments);
 
@@ -380,22 +380,22 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
 
         PsiElement elementToReplace = element;
         PsiElement parent = element.getParent();
-        if (parent instanceof JetQualifiedExpression && ((JetQualifiedExpression) parent).getSelectorExpression() == element) {
+        if (parent instanceof KtQualifiedExpression && ((KtQualifiedExpression) parent).getSelectorExpression() == element) {
             elementToReplace = parent;
         }
 
         // Do not add extension receiver to calls with explicit dispatch receiver
         if (newReceiverInfo != null
-            && elementToReplace instanceof JetQualifiedExpression
+            && elementToReplace instanceof KtQualifiedExpression
             && dispatchReceiver instanceof ExpressionReceiver) return;
 
-        List<JetValueArgument> newArguments = newArgumentList.getArguments();
+        List<KtValueArgument> newArguments = newArgumentList.getArguments();
         int actualIndex = 0;
         for (int i = 0; i < newArguments.size(); i++) {
-            JetValueArgument newArgument = newArguments.get(i);
+            KtValueArgument newArgument = newArguments.get(i);
             JetParameterInfo parameterInfo = newSignatureParameters.get(i);
             if (parameterInfo == originalReceiverInfo) {
-                JetExpression receiverExpression = getReceiverExpression(extensionReceiver, psiFactory);
+                KtExpression receiverExpression = getReceiverExpression(extensionReceiver, psiFactory);
                 if (receiverExpression != null) {
                     newArgument.replace(receiverExpression);
                 }
@@ -407,10 +407,10 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
 
             if (oldArgument != null) {
                 ValueArgumentName argumentName = oldArgument.getArgumentName();
-                JetSimpleNameExpression argumentNameExpression = argumentName != null ? argumentName.getReferenceExpression() : null;
+                KtSimpleNameExpression argumentNameExpression = argumentName != null ? argumentName.getReferenceExpression() : null;
                 changeArgumentName(argumentNameExpression, parameterInfo);
                 //noinspection ConstantConditions
-                newArgument.replace(oldArgument instanceof JetFunctionLiteralArgument
+                newArgument.replace(oldArgument instanceof KtFunctionLiteralArgument
                                     ? psiFactory.createArgument(oldArgument.getArgumentExpression(), null, false)
                                     : oldArgument.asElement());
             }
@@ -428,20 +428,20 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
             }
         }
 
-        List<JetFunctionLiteralArgument> lambdaArguments = element.getFunctionLiteralArguments();
+        List<KtFunctionLiteralArgument> lambdaArguments = element.getFunctionLiteralArguments();
         if (!lambdaArguments.isEmpty()) {
             element.deleteChildRange(CollectionsKt.first(lambdaArguments), CollectionsKt.last(lambdaArguments));
         }
 
         //TODO: this is not correct!
-        JetValueArgument lastArgument = CollectionsKt.lastOrNull(newArgumentList.getArguments());
+        KtValueArgument lastArgument = CollectionsKt.lastOrNull(newArgumentList.getArguments());
         boolean hasTrailingLambdaInArgumentListAfter =
-                lastArgument != null && JetFunctionLiteralArgumentKt.unpackFunctionLiteral(lastArgument.getArgumentExpression()) != null;
+                lastArgument != null && KtFunctionLiteralArgumentKt.unpackFunctionLiteral(lastArgument.getArgumentExpression()) != null;
 
-        arguments = (JetValueArgumentList) arguments.replace(newArgumentList);
+        arguments = (KtValueArgumentList) arguments.replace(newArgumentList);
 
-        final List<JetElement> argumentsToShorten = new ArrayList<JetElement>(indicesOfArgumentsWithDefaultValues.size());
-        final List<JetValueArgument> argumentList = arguments.getArguments();
+        final List<KtElement> argumentsToShorten = new ArrayList<KtElement>(indicesOfArgumentsWithDefaultValues.size());
+        final List<KtValueArgument> argumentList = arguments.getArguments();
         indicesOfArgumentsWithDefaultValues.forEach(
                 new TIntProcedure() {
                     @Override
@@ -452,18 +452,18 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
                 }
         );
 
-        for (JetElement argument : argumentsToShorten) {
+        for (KtElement argument : argumentsToShorten) {
             ShortenWaitingSetKt.addToShorteningWaitSet(argument, SHORTEN_ARGUMENTS_OPTIONS);
         }
 
-        JetElement newElement = element;
+        KtElement newElement = element;
         if (newReceiverInfo != originalReceiverInfo) {
             PsiElement replacingElement;
             if (newReceiverInfo != null) {
                 ValueArgument receiverArgument = argumentMap.get(newReceiverInfo.getOldIndex());
-                JetExpression extensionReceiverExpression = receiverArgument != null ? receiverArgument.getArgumentExpression() : null;
-                JetExpression defaultValueForCall = newReceiverInfo.getDefaultValueForCall();
-                JetExpression receiver =
+                KtExpression extensionReceiverExpression = receiverArgument != null ? receiverArgument.getArgumentExpression() : null;
+                KtExpression defaultValueForCall = newReceiverInfo.getDefaultValueForCall();
+                KtExpression receiver =
                         extensionReceiverExpression != null ? psiFactory.createExpression(extensionReceiverExpression.getText())
                         : defaultValueForCall != null ? defaultValueForCall
                         : psiFactory.createExpression("_");
@@ -474,40 +474,40 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
                 replacingElement = psiFactory.createExpression(element.getText());
             }
 
-            newElement = (JetElement) elementToReplace.replace(replacingElement);
+            newElement = (KtElement) elementToReplace.replace(replacingElement);
         }
 
         if (hasTrailingLambdaInArgumentListAfter) {
-            JetCallExpression newCallExpression =
-                    (JetCallExpression) (newElement instanceof JetQualifiedExpression
-                                      ? ((JetQualifiedExpression) newElement).getSelectorExpression()
+            KtCallExpression newCallExpression =
+                    (KtCallExpression) (newElement instanceof KtQualifiedExpression
+                                      ? ((KtQualifiedExpression) newElement).getSelectorExpression()
                                       : newElement);
             PsiModificationUtilsKt.moveFunctionLiteralOutsideParentheses(newCallExpression);
         }
     }
 
-    private static void updateJavaPropertyCall(JetChangeInfo changeInfo, JetCallElement element) {
+    private static void updateJavaPropertyCall(JetChangeInfo changeInfo, KtCallElement element) {
         JetParameterInfo newReceiverInfo = changeInfo.getReceiverParameterInfo();
         JetParameterInfo originalReceiverInfo = changeInfo.getMethodDescriptor().getReceiver();
         if (newReceiverInfo == originalReceiverInfo) return;
 
-        JetValueArgumentList arguments = element.getValueArgumentList();
+        KtValueArgumentList arguments = element.getValueArgumentList();
         assert arguments != null : "Argument list is expected: " + element.getText();
         List<? extends ValueArgument> oldArguments = element.getValueArguments();
 
-        JetPsiFactory psiFactory = new JetPsiFactory(element.getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(element.getProject());
 
-        JetValueArgument firstArgument = oldArguments.isEmpty() ? null : (JetValueArgument) oldArguments.get(0);
+        KtValueArgument firstArgument = oldArguments.isEmpty() ? null : (KtValueArgument) oldArguments.get(0);
 
         if (newReceiverInfo == null) {
             if (firstArgument != null) arguments.removeArgument(firstArgument);
         }
         else {
-            JetExpression defaultValueForCall = newReceiverInfo.getDefaultValueForCall();
+            KtExpression defaultValueForCall = newReceiverInfo.getDefaultValueForCall();
             if (defaultValueForCall == null) {
                 defaultValueForCall = psiFactory.createExpression("_");
             }
-            JetValueArgument newReceiverArgument = psiFactory.createArgument(defaultValueForCall, null, false);
+            KtValueArgument newReceiverArgument = psiFactory.createArgument(defaultValueForCall, null, false);
 
             if (originalReceiverInfo != null) {
                 if (firstArgument != null) firstArgument.replace(newReceiverArgument);
@@ -519,7 +519,7 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
     }
 
     @Nullable
-    private static JetExpression getReceiverExpression(@NotNull ReceiverValue receiver, @NotNull JetPsiFactory psiFactory) {
+    private static KtExpression getReceiverExpression(@NotNull ReceiverValue receiver, @NotNull KtPsiFactory psiFactory) {
         if (receiver instanceof ExpressionReceiver) {
             return ((ExpressionReceiver) receiver).getExpression();
         }
@@ -552,10 +552,10 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
         return argumentMap;
     }
 
-    private void changeArgumentNames(JetChangeInfo changeInfo, JetCallElement element) {
+    private void changeArgumentNames(JetChangeInfo changeInfo, KtCallElement element) {
         for (ValueArgument argument : element.getValueArguments()) {
             ValueArgumentName argumentName = argument.getArgumentName();
-            JetSimpleNameExpression argumentNameExpression = argumentName != null ? argumentName.getReferenceExpression() : null;
+            KtSimpleNameExpression argumentNameExpression = argumentName != null ? argumentName.getReferenceExpression() : null;
 
             if (argumentNameExpression != null) {
                 Integer oldParameterIndex = changeInfo.getOldParameterIndex(argumentNameExpression.getReferencedName());
@@ -568,12 +568,12 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
         }
     }
 
-    private void changeArgumentName(JetSimpleNameExpression argumentNameExpression, JetParameterInfo parameterInfo) {
+    private void changeArgumentName(KtSimpleNameExpression argumentNameExpression, JetParameterInfo parameterInfo) {
         PsiElement identifier = argumentNameExpression != null ? argumentNameExpression.getIdentifier() : null;
 
         if (identifier != null) {
             String newName = parameterInfo.getInheritedName(callee);
-            identifier.replace(JetPsiFactoryKt.JetPsiFactory(getProject()).createIdentifier(newName));
+            identifier.replace(KtPsiFactoryKt.KtPsiFactory(getProject()).createIdentifier(newName));
         }
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetImplicitThisToParameterUsage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetImplicitThisToParameterUsage.kt
index b85e7bcec7e..313f0182416 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetImplicitThisToParameterUsage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetImplicitThisToParameterUsage.kt
@@ -19,43 +19,43 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetQualifiedExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtQualifiedExpression
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.idea.codeInsight.shorten.addToShorteningWaitSet
 import org.jetbrains.kotlin.idea.util.ShortenReferences.Options
 
-public abstract class JetImplicitReceiverUsage(callElement: JetElement): JetUsageInfo<JetElement>(callElement) {
+public abstract class JetImplicitReceiverUsage(callElement: KtElement): JetUsageInfo<KtElement>(callElement) {
     protected abstract fun getNewReceiverText(): String
 
-    protected open fun processReplacedElement(element: JetElement) {
+    protected open fun processReplacedElement(element: KtElement) {
 
     }
 
-    override fun processUsage(changeInfo: JetChangeInfo, element: JetElement, allUsages: Array<out UsageInfo>): Boolean {
-        val newQualifiedCall = JetPsiFactory(element.getProject()).createExpression(
+    override fun processUsage(changeInfo: JetChangeInfo, element: KtElement, allUsages: Array<out UsageInfo>): Boolean {
+        val newQualifiedCall = KtPsiFactory(element.getProject()).createExpression(
                 "${getNewReceiverText()}.${element.getText()}"
-        ) as JetQualifiedExpression
-        processReplacedElement(element.replace(newQualifiedCall) as JetElement)
+        ) as KtQualifiedExpression
+        processReplacedElement(element.replace(newQualifiedCall) as KtElement)
         return false
     }
 }
 
 public class JetImplicitThisToParameterUsage(
-        callElement: JetElement,
+        callElement: KtElement,
         val parameterInfo: JetParameterInfo,
         val containingCallable: JetCallableDefinitionUsage<*>
 ): JetImplicitReceiverUsage(callElement) {
     override fun getNewReceiverText(): String = parameterInfo.getInheritedName(containingCallable)
 
-    override fun processReplacedElement(element: JetElement) {
+    override fun processReplacedElement(element: KtElement) {
         element.addToShorteningWaitSet(Options(removeThisLabels = true))
     }
 }
 
 public class JetImplicitThisUsage(
-        callElement: JetElement,
+        callElement: KtElement,
         val targetDescriptor: DeclarationDescriptor
 ): JetImplicitReceiverUsage(callElement) {
     override fun getNewReceiverText(): String {
@@ -63,7 +63,7 @@ public class JetImplicitThisUsage(
         return if (name.isSpecial()) "this" else "this@${name.asString()}"
     }
 
-    override fun processReplacedElement(element: JetElement) {
+    override fun processReplacedElement(element: KtElement) {
         element.addToShorteningWaitSet(Options(removeThisLabels = true, removeThis = true))
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetParameterUsage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetParameterUsage.kt
index a0db09323bd..afa88b22b78 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetParameterUsage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetParameterUsage.kt
@@ -17,41 +17,41 @@
 package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 
 import com.intellij.usageView.UsageInfo
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.codeInsight.shorten.addToShorteningWaitSet
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
-import org.jetbrains.kotlin.psi.JetQualifiedExpression
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetThisExpression
+import org.jetbrains.kotlin.psi.KtQualifiedExpression
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtThisExpression
 import org.jetbrains.kotlin.idea.util.ShortenReferences.Options
 
 // Explicit reference to function parameter or outer this
-public abstract class JetExplicitReferenceUsage<T : JetElement>(element: T) : JetUsageInfo<T>(element) {
+public abstract class JetExplicitReferenceUsage<T : KtElement>(element: T) : JetUsageInfo<T>(element) {
     abstract fun getReplacementText(changeInfo: JetChangeInfo): String
 
-    protected open fun processReplacedElement(element: JetElement) {
+    protected open fun processReplacedElement(element: KtElement) {
 
     }
 
     override fun processUsage(changeInfo: JetChangeInfo, element: T, allUsages: Array<out UsageInfo>): Boolean {
-        val newElement = JetPsiFactory(element.getProject()).createExpression(getReplacementText(changeInfo))
-        val elementToReplace = (element.getParent() as? JetThisExpression) ?: element
-        processReplacedElement(elementToReplace.replace(newElement) as JetElement)
+        val newElement = KtPsiFactory(element.getProject()).createExpression(getReplacementText(changeInfo))
+        val elementToReplace = (element.getParent() as? KtThisExpression) ?: element
+        processReplacedElement(elementToReplace.replace(newElement) as KtElement)
         return false
     }
 }
 
 public class JetParameterUsage(
-        element: JetElement,
+        element: KtElement,
         private val parameterInfo: JetParameterInfo,
         val containingCallable: JetCallableDefinitionUsage<*>
-) : JetExplicitReferenceUsage<JetElement>(element) {
-    override fun processReplacedElement(element: JetElement) {
-        val qualifiedExpression = element.getParent() as? JetQualifiedExpression
+) : JetExplicitReferenceUsage<KtElement>(element) {
+    override fun processReplacedElement(element: KtElement) {
+        val qualifiedExpression = element.getParent() as? KtQualifiedExpression
         val elementToShorten = if (qualifiedExpression?.getReceiverExpression() == element) qualifiedExpression!! else element
         elementToShorten.addToShorteningWaitSet(Options(removeThis = true, removeThisLabels = true))
     }
@@ -67,10 +67,10 @@ public class JetParameterUsage(
 }
 
 public class JetNonQualifiedOuterThisUsage(
-        element: JetThisExpression,
+        element: KtThisExpression,
         val targetDescriptor: DeclarationDescriptor
-) : JetExplicitReferenceUsage<JetThisExpression>(element) {
-    override fun processReplacedElement(element: JetElement) {
+) : JetExplicitReferenceUsage<KtThisExpression>(element) {
+    override fun processReplacedElement(element: KtElement) {
         element.addToShorteningWaitSet(Options(removeThisLabels = true))
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetPropertyCallUsage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetPropertyCallUsage.kt
index cc55146954c..823eb72d420 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetPropertyCallUsage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetPropertyCallUsage.kt
@@ -20,30 +20,30 @@ import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
 import org.jetbrains.kotlin.idea.references.mainReference
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetQualifiedExpression
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtQualifiedExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.createExpressionByPattern
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelectorOrThis
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 
-public class JetPropertyCallUsage(element: JetSimpleNameExpression): JetUsageInfo<JetSimpleNameExpression>(element) {
+public class JetPropertyCallUsage(element: KtSimpleNameExpression): JetUsageInfo<KtSimpleNameExpression>(element) {
     private val resolvedCall = element.getResolvedCall(element.analyze())
 
-    override fun processUsage(changeInfo: JetChangeInfo, element: JetSimpleNameExpression, allUsages: Array<out UsageInfo>): Boolean {
+    override fun processUsage(changeInfo: JetChangeInfo, element: KtSimpleNameExpression, allUsages: Array<out UsageInfo>): Boolean {
         updateName(changeInfo, element)
         updateReceiver(changeInfo, element)
         return true
     }
 
-    private fun updateName(changeInfo: JetChangeInfo, element: JetSimpleNameExpression) {
+    private fun updateName(changeInfo: JetChangeInfo, element: KtSimpleNameExpression) {
         if (changeInfo.isNameChanged()) {
             element.mainReference.handleElementRename(changeInfo.getNewName())
         }
     }
 
-    private fun updateReceiver(changeInfo: JetChangeInfo, element: JetSimpleNameExpression) {
+    private fun updateReceiver(changeInfo: JetChangeInfo, element: KtSimpleNameExpression) {
         val newReceiver = changeInfo.receiverParameterInfo
         val oldReceiver = changeInfo.methodDescriptor.receiver
         if (newReceiver == oldReceiver) return
@@ -52,11 +52,11 @@ public class JetPropertyCallUsage(element: JetSimpleNameExpression): JetUsageInf
 
         // Do not add extension receiver to calls with explicit dispatch receiver
         if (newReceiver != null
-            && elementToReplace is JetQualifiedExpression
+            && elementToReplace is KtQualifiedExpression
             && resolvedCall?.getDispatchReceiver() is ExpressionReceiver) return
 
         val replacingElement = newReceiver?.let {
-            val psiFactory = JetPsiFactory(getProject())
+            val psiFactory = KtPsiFactory(getProject())
             val receiver = it.defaultValueForCall ?: psiFactory.createExpression("_")
             psiFactory.createExpressionByPattern("$0.$1", receiver, element)
         } ?: element
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinCallerUsages.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinCallerUsages.kt
index 885d03fe841..5b550dbf61a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinCallerUsages.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinCallerUsages.kt
@@ -25,17 +25,17 @@ import org.jetbrains.kotlin.idea.refactoring.changeSignature.isInsideOfCallerBod
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 
-public class KotlinCallerUsage(element: JetNamedDeclaration): JetUsageInfo<JetNamedDeclaration>(element) {
-    override fun processUsage(changeInfo: JetChangeInfo, element: JetNamedDeclaration, allUsages: Array<out UsageInfo>): Boolean {
+public class KotlinCallerUsage(element: KtNamedDeclaration): JetUsageInfo<KtNamedDeclaration>(element) {
+    override fun processUsage(changeInfo: JetChangeInfo, element: KtNamedDeclaration, allUsages: Array<out UsageInfo>): Boolean {
         // Do not process function twice
         if (changeInfo.getAffectedCallables().any { it is JetCallableDefinitionUsage<*> && it.getElement() == element }) return true
 
         val parameterList = when (element) {
-            is JetFunction -> element.getValueParameterList()
-            is JetClass -> element.createPrimaryConstructorParameterListIfAbsent()
+            is KtFunction -> element.getValueParameterList()
+            is KtClass -> element.createPrimaryConstructorParameterListIfAbsent()
             else -> null
         } ?: return true
-        val psiFactory = JetPsiFactory(getProject())
+        val psiFactory = KtPsiFactory(getProject())
         changeInfo.getNonReceiverParameters()
                 .withIndex()
                 .filter { it.value.isNewParameter }
@@ -50,10 +50,10 @@ public class KotlinCallerUsage(element: JetNamedDeclaration): JetUsageInfo<JetNa
     }
 }
 
-public class KotlinCallerCallUsage(element: JetCallElement): JetUsageInfo<JetCallElement>(element) {
-    override fun processUsage(changeInfo: JetChangeInfo, element: JetCallElement, allUsages: Array<out UsageInfo>): Boolean {
+public class KotlinCallerCallUsage(element: KtCallElement): JetUsageInfo<KtCallElement>(element) {
+    override fun processUsage(changeInfo: JetChangeInfo, element: KtCallElement, allUsages: Array<out UsageInfo>): Boolean {
         val argumentList = element.getValueArgumentList() ?: return true
-        val psiFactory = JetPsiFactory(getProject())
+        val psiFactory = KtPsiFactory(getProject())
         val isNamedCall = argumentList.getArguments().any { it.getArgumentName() != null }
         changeInfo.getNonReceiverParameters()
                 .filter { it.isNewParameter }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/copy/CopyKotlinFileHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/copy/CopyKotlinFileHandler.kt
index d97b4582796..b6358bff2aa 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/copy/CopyKotlinFileHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/copy/CopyKotlinFileHandler.kt
@@ -20,14 +20,14 @@ import com.intellij.psi.PsiDirectory
 import com.intellij.psi.PsiElement
 import com.intellij.refactoring.copy.CopyFilesOrDirectoriesHandler
 import com.intellij.refactoring.copy.CopyHandlerDelegateBase
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
 public class CopyKotlinFileHandler : CopyHandlerDelegateBase() {
     private val delegate = CopyFilesOrDirectoriesHandler()
 
     private fun adjustElements(elements: Array<out PsiElement>): Array<PsiElement>? {
         return elements
-                .map { it.getContainingFile() as? JetFile ?: return null }
+                .map { it.getContainingFile() as? KtFile ?: return null }
                 .toTypedArray()
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/inline/KotlinInlineValHandler.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/inline/KotlinInlineValHandler.java
index dc328f3d542..b7548ee2508 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/inline/KotlinInlineValHandler.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/inline/KotlinInlineValHandler.java
@@ -65,7 +65,7 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
 
 import java.util.List;
@@ -80,40 +80,40 @@ public class KotlinInlineValHandler extends InlineActionHandler {
 
     @Override
     public boolean canInlineElement(PsiElement element) {
-        if (!(element instanceof JetProperty)) {
+        if (!(element instanceof KtProperty)) {
             return false;
         }
-        JetProperty property = (JetProperty) element;
+        KtProperty property = (KtProperty) element;
         return property.getGetter() == null && property.getReceiverTypeReference() == null;
     }
 
     @Override
     public void inlineElement(final Project project, final Editor editor, PsiElement element) {
-        final JetProperty val = (JetProperty) element;
-        final JetFile file = val.getContainingJetFile();
+        final KtProperty val = (KtProperty) element;
+        final KtFile file = val.getContainingJetFile();
         String name = val.getName();
 
-        JetExpression initializerInDeclaration = val.getInitializer();
+        KtExpression initializerInDeclaration = val.getInitializer();
 
-        final List<JetExpression> referenceExpressions = findReferenceExpressions(val);
+        final List<KtExpression> referenceExpressions = findReferenceExpressions(val);
 
         final Set<PsiElement> assignments = Sets.newHashSet();
-        for (JetExpression expression : referenceExpressions) {
+        for (KtExpression expression : referenceExpressions) {
             PsiElement parent = expression.getParent();
 
-            JetBinaryExpression assignment = JetPsiUtilKt.getAssignmentByLHS(expression);
+            KtBinaryExpression assignment = JetPsiUtilKt.getAssignmentByLHS(expression);
             if (assignment != null) {
                 assignments.add(parent);
             }
 
             //noinspection SuspiciousMethodCalls
-            if (parent instanceof JetUnaryExpression &&
-                OperatorConventions.INCREMENT_OPERATIONS.contains(((JetUnaryExpression) parent).getOperationToken())) {
+            if (parent instanceof KtUnaryExpression &&
+                OperatorConventions.INCREMENT_OPERATIONS.contains(((KtUnaryExpression) parent).getOperationToken())) {
                 assignments.add(parent);
             }
         }
 
-        final JetExpression initializer;
+        final KtExpression initializer;
         if (initializerInDeclaration != null) {
             initializer = initializerInDeclaration;
             if (!assignments.isEmpty()) {
@@ -123,7 +123,7 @@ public class KotlinInlineValHandler extends InlineActionHandler {
         }
         else {
             if (assignments.size() == 1) {
-                initializer = ((JetBinaryExpression) assignments.iterator().next()).getRight();
+                initializer = ((KtBinaryExpression) assignments.iterator().next()).getRight();
             }
             else {
                 initializer = null;
@@ -139,9 +139,9 @@ public class KotlinInlineValHandler extends InlineActionHandler {
 
         final boolean canHighlight = CollectionsKt.all(
                 referenceExpressions,
-                new Function1<JetExpression, Boolean>() {
+                new Function1<KtExpression, Boolean>() {
                     @Override
-                    public Boolean invoke(JetExpression expression) {
+                    public Boolean invoke(KtExpression expression) {
                         return expression.getContainingFile() == file;
                     }
                 }
@@ -161,7 +161,7 @@ public class KotlinInlineValHandler extends InlineActionHandler {
             return;
         }
 
-        final List<JetExpression> inlinedExpressions = Lists.newArrayList();
+        final List<KtExpression> inlinedExpressions = Lists.newArrayList();
         CommandProcessor.getInstance().executeCommand(
                 project,
                 new Runnable() {
@@ -170,12 +170,12 @@ public class KotlinInlineValHandler extends InlineActionHandler {
                         ApplicationManager.getApplication().runWriteAction(new Runnable() {
                             @Override
                             public void run() {
-                                for (JetExpression referenceExpression : referenceExpressions) {
+                                for (KtExpression referenceExpression : referenceExpressions) {
                                     if (assignments.contains(referenceExpression.getParent())) {
                                         continue;
                                     }
 
-                                    inlinedExpressions.add((JetExpression) referenceExpression.replace(initializer));
+                                    inlinedExpressions.add((KtExpression) referenceExpression.replace(initializer));
                                 }
 
                                 for (PsiElement assignment : assignments) {
@@ -233,14 +233,14 @@ public class KotlinInlineValHandler extends InlineActionHandler {
         highlightManager.addOccurrenceHighlights(editor, elementsArray, searchResultsAttributes, true, null);
     }
 
-    private static List<JetExpression> findReferenceExpressions(JetProperty val) {
-        List<JetExpression> result = Lists.newArrayList();
+    private static List<KtExpression> findReferenceExpressions(KtProperty val) {
+        List<KtExpression> result = Lists.newArrayList();
 
         for (PsiReference reference : ReferencesSearch.search(val, GlobalSearchScope.allScope(val.getProject()), false).findAll()) {
-            JetExpression expression = (JetExpression) reference.getElement();
+            KtExpression expression = (KtExpression) reference.getElement();
             PsiElement parent = expression.getParent();
-            if (parent instanceof JetQualifiedExpression && ((JetQualifiedExpression) parent).getSelectorExpression() == expression) {
-                result.add((JetQualifiedExpression) parent);
+            if (parent instanceof KtQualifiedExpression && ((KtQualifiedExpression) parent).getSelectorExpression() == expression) {
+                result.add((KtQualifiedExpression) parent);
             }
             else {
                 result.add(expression);
@@ -250,7 +250,7 @@ public class KotlinInlineValHandler extends InlineActionHandler {
         return result;
     }
 
-    private static boolean showDialog(Project project, String name, List<JetExpression> referenceExpressions) {
+    private static boolean showDialog(Project project, String name, List<KtExpression> referenceExpressions) {
         if (ApplicationManager.getApplication().isUnitTestMode()) {
             return true;
         }
@@ -269,8 +269,8 @@ public class KotlinInlineValHandler extends InlineActionHandler {
     }
 
     @Nullable
-    private static String getParametersForFunctionLiteral(JetExpression initializer) {
-        JetFunctionLiteralExpression functionLiteralExpression = getFunctionLiteralExpression(initializer);
+    private static String getParametersForFunctionLiteral(KtExpression initializer) {
+        KtFunctionLiteralExpression functionLiteralExpression = getFunctionLiteralExpression(initializer);
         if (functionLiteralExpression == null) {
             return null;
         }
@@ -290,24 +290,24 @@ public class KotlinInlineValHandler extends InlineActionHandler {
     }
 
     @Nullable
-    private static JetFunctionLiteralExpression getFunctionLiteralExpression(@NotNull JetExpression expression) {
-        if (expression instanceof JetParenthesizedExpression) {
-            JetExpression inner = ((JetParenthesizedExpression) expression).getExpression();
+    private static KtFunctionLiteralExpression getFunctionLiteralExpression(@NotNull KtExpression expression) {
+        if (expression instanceof KtParenthesizedExpression) {
+            KtExpression inner = ((KtParenthesizedExpression) expression).getExpression();
             return inner == null ? null : getFunctionLiteralExpression(inner);
         }
-        if (expression instanceof JetFunctionLiteralExpression) {
-            return (JetFunctionLiteralExpression) expression;
+        if (expression instanceof KtFunctionLiteralExpression) {
+            return (KtFunctionLiteralExpression) expression;
         }
         return null;
     }
 
-    private static void addFunctionLiteralParameterTypes(@NotNull String parameters, @NotNull List<JetExpression> inlinedExpressions) {
-        JetFile containingFile = inlinedExpressions.get(0).getContainingJetFile();
-        List<JetFunctionLiteralExpression> functionsToAddParameters = Lists.newArrayList();
+    private static void addFunctionLiteralParameterTypes(@NotNull String parameters, @NotNull List<KtExpression> inlinedExpressions) {
+        KtFile containingFile = inlinedExpressions.get(0).getContainingJetFile();
+        List<KtFunctionLiteralExpression> functionsToAddParameters = Lists.newArrayList();
 
         ResolutionFacade resolutionFacade = ResolutionUtils.getResolutionFacade(containingFile);
-        for (JetExpression inlinedExpression : inlinedExpressions) {
-            JetFunctionLiteralExpression functionLiteralExpression = getFunctionLiteralExpression(inlinedExpression);
+        for (KtExpression inlinedExpression : inlinedExpressions) {
+            KtFunctionLiteralExpression functionLiteralExpression = getFunctionLiteralExpression(inlinedExpression);
             assert functionLiteralExpression != null : "can't find function literal expression for " + inlinedExpression.getText();
 
             if (needToAddParameterTypes(functionLiteralExpression, resolutionFacade)) {
@@ -315,12 +315,12 @@ public class KotlinInlineValHandler extends InlineActionHandler {
             }
         }
 
-        JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(containingFile);
-        for (JetFunctionLiteralExpression functionLiteralExpression : functionsToAddParameters) {
-            JetFunctionLiteral functionLiteral = functionLiteralExpression.getFunctionLiteral();
+        KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(containingFile);
+        for (KtFunctionLiteralExpression functionLiteralExpression : functionsToAddParameters) {
+            KtFunctionLiteral functionLiteral = functionLiteralExpression.getFunctionLiteral();
 
-            JetParameterList currentParameterList = functionLiteral.getValueParameterList();
-            JetParameterList newParameterList = psiFactory.createParameterList("(" + parameters + ")");
+            KtParameterList currentParameterList = functionLiteral.getValueParameterList();
+            KtParameterList newParameterList = psiFactory.createParameterList("(" + parameters + ")");
             if (currentParameterList != null) {
                 currentParameterList.replace(newParameterList);
             }
@@ -344,17 +344,17 @@ public class KotlinInlineValHandler extends InlineActionHandler {
     }
 
     private static boolean needToAddParameterTypes(
-            @NotNull JetFunctionLiteralExpression functionLiteralExpression,
+            @NotNull KtFunctionLiteralExpression functionLiteralExpression,
             @NotNull ResolutionFacade resolutionFacade
     ) {
-        JetFunctionLiteral functionLiteral = functionLiteralExpression.getFunctionLiteral();
+        KtFunctionLiteral functionLiteral = functionLiteralExpression.getFunctionLiteral();
         BindingContext context = resolutionFacade.analyze(functionLiteralExpression, BodyResolveMode.FULL);
         for (Diagnostic diagnostic : context.getDiagnostics()) {
             DiagnosticFactory<?> factory = diagnostic.getFactory();
             PsiElement element = diagnostic.getPsiElement();
             boolean hasCantInferParameter = factory == Errors.CANNOT_INFER_PARAMETER_TYPE && element.getParent().getParent() == functionLiteral;
             boolean hasUnresolvedItOrThis = factory == Errors.UNRESOLVED_REFERENCE && element.getText().equals("it") &&
-                         PsiTreeUtil.getParentOfType(element, JetFunctionLiteral.class) == functionLiteral;
+                                            PsiTreeUtil.getParentOfType(element, KtFunctionLiteral.class) == functionLiteral;
             if (hasCantInferParameter || hasUnresolvedItOrThis) {
                 return true;
             }
@@ -362,44 +362,44 @@ public class KotlinInlineValHandler extends InlineActionHandler {
         return false;
     }
 
-    private static void addTypeArguments(@NotNull String typeArguments, @NotNull List<JetExpression> inlinedExpressions) {
-        JetFile containingFile = inlinedExpressions.get(0).getContainingJetFile();
-        List<JetCallExpression> callsToAddArguments = Lists.newArrayList();
+    private static void addTypeArguments(@NotNull String typeArguments, @NotNull List<KtExpression> inlinedExpressions) {
+        KtFile containingFile = inlinedExpressions.get(0).getContainingJetFile();
+        List<KtCallExpression> callsToAddArguments = Lists.newArrayList();
 
         ResolutionFacade resolutionFacade = ResolutionUtils.getResolutionFacade(containingFile);
-        for (JetExpression inlinedExpression : inlinedExpressions) {
+        for (KtExpression inlinedExpression : inlinedExpressions) {
             BindingContext context = resolutionFacade.analyze(inlinedExpression, BodyResolveMode.FULL);
             Call call = CallUtilKt.getCallWithAssert(inlinedExpression, context);
 
-            JetElement callElement = call.getCallElement();
-            if (callElement instanceof JetCallExpression && hasIncompleteTypeInferenceDiagnostic(call, context) &&
+            KtElement callElement = call.getCallElement();
+            if (callElement instanceof KtCallExpression && hasIncompleteTypeInferenceDiagnostic(call, context) &&
                     call.getTypeArgumentList() == null) {
-                callsToAddArguments.add((JetCallExpression) callElement);
+                callsToAddArguments.add((KtCallExpression) callElement);
             }
         }
 
-        JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(containingFile);
-        for (JetCallExpression call : callsToAddArguments) {
+        KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(containingFile);
+        for (KtCallExpression call : callsToAddArguments) {
             call.addAfter(psiFactory.createTypeArguments("<" + typeArguments + ">"), call.getCalleeExpression());
             ShortenReferences.DEFAULT.process(call.getTypeArgumentList());
         }
     }
 
     @Nullable
-    private static String getTypeArgumentsStringForCall(@NotNull JetExpression initializer) {
+    private static String getTypeArgumentsStringForCall(@NotNull KtExpression initializer) {
         BindingContext context = ResolutionUtils.analyze(initializer, BodyResolveMode.FULL);
         ResolvedCall<?> call = CallUtilKt.getResolvedCall(initializer, context);
         if (call == null) return null;
 
-        List<JetType> typeArguments = Lists.newArrayList();
-        Map<TypeParameterDescriptor, JetType> typeArgumentMap = call.getTypeArguments();
+        List<KtType> typeArguments = Lists.newArrayList();
+        Map<TypeParameterDescriptor, KtType> typeArgumentMap = call.getTypeArguments();
         for (TypeParameterDescriptor typeParameter : call.getCandidateDescriptor().getTypeParameters()) {
             typeArguments.add(typeArgumentMap.get(typeParameter));
         }
 
-        return StringUtil.join(typeArguments, new Function<JetType, String>() {
+        return StringUtil.join(typeArguments, new Function<KtType, String>() {
             @Override
-            public String fun(JetType type) {
+            public String fun(KtType type) {
                 return IdeDescriptorRenderers.SOURCE_CODE_FOR_TYPE_ARGUMENTS.renderType(type);
             }
         }, ", ");
@@ -409,7 +409,7 @@ public class KotlinInlineValHandler extends InlineActionHandler {
             @NotNull Call call,
             @NotNull BindingContext context
     ) {
-        JetExpression callee = call.getCalleeExpression();
+        KtExpression callee = call.getCalleeExpression();
         for (Diagnostic diagnostic : context.getDiagnostics()) {
             if (diagnostic.getFactory() == Errors.TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER && diagnostic.getPsiElement() == callee) {
                 return true;
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractIntroduceAction.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractIntroduceAction.kt
index 13665c440aa..6a6a3c96646 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractIntroduceAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractIntroduceAction.kt
@@ -28,5 +28,5 @@ public abstract class AbstractIntroduceAction : BasePlatformRefactoringAction()
     override fun isAvailableInEditorOnly(): Boolean = true
 
     protected override fun isEnabledOnElements(elements: Array<out PsiElement>): Boolean =
-            elements.all { it is JetElement }
+            elements.all { it is KtElement }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractKotlinInplaceIntroducer.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractKotlinInplaceIntroducer.kt
index 6027764c88b..270523e8be3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractKotlinInplaceIntroducer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractKotlinInplaceIntroducer.kt
@@ -25,25 +25,25 @@ import com.intellij.refactoring.introduce.inplace.AbstractInplaceIntroducer
 import com.intellij.refactoring.rename.inplace.InplaceRefactoring
 import com.intellij.ui.NonFocusableCheckBox
 import com.intellij.util.ui.FormBuilder
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import java.awt.BorderLayout
 
-public abstract class AbstractKotlinInplaceIntroducer<D: JetNamedDeclaration>(
+public abstract class AbstractKotlinInplaceIntroducer<D: KtNamedDeclaration>(
         localVariable: D?,
-        expression: JetExpression?,
-        occurrences: Array<JetExpression>,
+        expression: KtExpression?,
+        occurrences: Array<KtExpression>,
         title: String,
         project: Project,
         editor: Editor
-): AbstractInplaceIntroducer<D, JetExpression>(project, editor, expression, localVariable, occurrences, title, JetFileType.INSTANCE) {
+): AbstractInplaceIntroducer<D, KtExpression>(project, editor, expression, localVariable, occurrences, title, KotlinFileType.INSTANCE) {
     protected fun initFormComponents(init: FormBuilder.() -> Unit) {
         myWholePanel.setLayout(BorderLayout())
 
@@ -74,13 +74,13 @@ public abstract class AbstractKotlinInplaceIntroducer<D: JetNamedDeclaration>(
             declaration: D,
             marker: RangeMarker,
             exprText: String?
-    ): JetExpression? {
+    ): KtExpression? {
         if (exprText == null || !declaration.isValid()) return null
 
         return containingFile
                 .findElementAt(marker.getStartOffset())
-                ?.getNonStrictParentOfType<JetSimpleNameExpression>()
-                ?.replaced(JetPsiFactory(myProject).createExpression(exprText))
+                ?.getNonStrictParentOfType<KtSimpleNameExpression>()
+                ?.replaced(KtPsiFactory(myProject).createExpression(exprText))
     }
 
     override fun updateTitle(declaration: D?) = updateTitle(declaration, null)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ExtractKotlinFunctionHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ExtractKotlinFunctionHandler.kt
index 9593834d373..12d9499a094 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ExtractKotlinFunctionHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ExtractKotlinFunctionHandler.kt
@@ -25,10 +25,10 @@ import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.idea.core.refactoring.getExtractionContainers
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractFunction.ui.KotlinExtractFunctionDialog
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetBlockExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtBlockExpression
 import kotlin.test.fail
-import org.jetbrains.kotlin.psi.JetFunctionLiteral
+import org.jetbrains.kotlin.psi.KtFunctionLiteral
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.toRange
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.*
 import org.jetbrains.kotlin.idea.refactoring.introduce.*
@@ -52,11 +52,11 @@ public class ExtractKotlinFunctionHandler(
 
     fun doInvoke(
             editor: Editor,
-            file: JetFile,
+            file: KtFile,
             elements: List<PsiElement>,
             targetSibling: PsiElement
     ) {
-        val adjustedElements = (elements.singleOrNull() as? JetBlockExpression)?.getStatements() ?: elements
+        val adjustedElements = (elements.singleOrNull() as? KtBlockExpression)?.getStatements() ?: elements
         val extractionData = ExtractionData(file, adjustedElements.toRange(false), targetSibling)
         ExtractionEngine(helper).run(editor, extractionData) {
             processDuplicates(it.duplicateReplacers, file.getProject(), editor)
@@ -74,7 +74,7 @@ public class ExtractKotlinFunctionHandler(
     }
 
     override fun invoke(project: Project, editor: Editor, file: PsiFile, dataContext: DataContext?) {
-        if (file !is JetFile) return
+        if (file !is KtFile) return
         selectElements(editor, file) { elements, targetSibling -> doInvoke(editor, file, elements, targetSibling) }
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ui/KotlinExtractFunctionDialog.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ui/KotlinExtractFunctionDialog.java
index 39bade5702e..2e3cde3ad6f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ui/KotlinExtractFunctionDialog.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ui/KotlinExtractFunctionDialog.java
@@ -29,13 +29,13 @@ import kotlin.jvm.functions.Function0;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester;
 import org.jetbrains.kotlin.idea.core.refactoring.JetRefactoringUtilKt;
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle;
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.*;
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import javax.swing.*;
 import java.awt.*;
@@ -129,7 +129,7 @@ public class KotlinExtractFunctionDialog extends DialogWrapper {
         functionNameField = new NameSuggestionsField(
                 ArrayUtil.toStringArray(extractableCodeDescriptor.getSuggestedNames()),
                 project,
-                JetFileType.INSTANCE
+                KotlinFileType.INSTANCE
         );
         functionNameField.addDataChangedListener(
                 new NameSuggestionsField.DataChanged() {
@@ -142,7 +142,7 @@ public class KotlinExtractFunctionDialog extends DialogWrapper {
         functionNamePanel.add(functionNameField, BorderLayout.CENTER);
         functionNameLabel.setLabelFor(functionNameField);
 
-        List<JetType> possibleReturnTypes = ExtractableCodeDescriptorKt.getPossibleReturnTypes(extractableCodeDescriptor.getControlFlow());
+        List<KtType> possibleReturnTypes = ExtractableCodeDescriptorKt.getPossibleReturnTypes(extractableCodeDescriptor.getControlFlow());
         if (possibleReturnTypes.size() > 1) {
             DefaultComboBoxModel returnTypeBoxModel = new DefaultComboBoxModel(possibleReturnTypes.toArray());
             returnTypeBox.setModel(returnTypeBoxModel);
@@ -158,7 +158,7 @@ public class KotlinExtractFunctionDialog extends DialogWrapper {
                                 boolean cellHasFocus
                         ) {
                             super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
-                            setText(IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType((JetType) value));
+                            setText(IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType((KtType) value));
                             return this;
                         }
                     }
@@ -262,7 +262,7 @@ public class KotlinExtractFunctionDialog extends DialogWrapper {
                                    getVisibility(),
                                    parameterTablePanel.getReceiverInfo(),
                                    parameterTablePanel.getParameterInfos(),
-                                   (JetType) returnTypeBox.getSelectedItem());
+                                   (KtType) returnTypeBox.getSelectedItem());
     }
 
     @NotNull
@@ -276,7 +276,7 @@ public class KotlinExtractFunctionDialog extends DialogWrapper {
             @NotNull String newVisibility,
             @Nullable KotlinParameterTablePanel.ParameterInfo newReceiverInfo,
             @NotNull List<KotlinParameterTablePanel.ParameterInfo> newParameterInfos,
-            @Nullable JetType returnType
+            @Nullable KtType returnType
     ) {
         Map<Parameter, Parameter> oldToNewParameters = ContainerUtil.newLinkedHashMap();
         for (KotlinParameterTablePanel.ParameterInfo parameterInfo : newParameterInfos) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ui/KotlinFunctionSignatureComponent.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ui/KotlinFunctionSignatureComponent.kt
index 8299817c295..581ec950476 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ui/KotlinFunctionSignatureComponent.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ui/KotlinFunctionSignatureComponent.kt
@@ -17,13 +17,13 @@
 package org.jetbrains.kotlin.idea.refactoring.introduce.extractFunction.ui
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import com.intellij.refactoring.ui.MethodSignatureComponent
 
 public class KotlinFunctionSignatureComponent(
         signature: String, project: Project
-) : MethodSignatureComponent(signature, project, JetFileType.INSTANCE) {
-    private val myFileName = "dummy." + JetFileType.EXTENSION
+) : MethodSignatureComponent(signature, project, KotlinFileType.INSTANCE) {
+    private val myFileName = "dummy." + KotlinFileType.EXTENSION
 
     override fun getFileName(): String = myFileName
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ui/KotlinParameterTablePanel.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ui/KotlinParameterTablePanel.java
index cba1727fd56..e16214a7760 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ui/KotlinParameterTablePanel.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ui/KotlinParameterTablePanel.java
@@ -33,7 +33,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester;
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.Parameter;
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import javax.swing.*;
 import javax.swing.table.AbstractTableModel;
@@ -51,7 +51,7 @@ public class KotlinParameterTablePanel extends JPanel {
         private final Parameter originalParameter;
         private final boolean receiver;
         private String name;
-        private JetType type;
+        private KtType type;
         private boolean enabled = true;
 
         public ParameterInfo(Parameter originalParameter, boolean receiver) {
@@ -85,11 +85,11 @@ public class KotlinParameterTablePanel extends JPanel {
             this.name = name;
         }
 
-        public JetType getType() {
+        public KtType getType() {
             return type;
         }
 
-        public void setType(JetType type) {
+        public void setType(KtType type) {
             this.type = type;
         }
 
@@ -156,7 +156,7 @@ public class KotlinParameterTablePanel extends JPanel {
             public Component getTableCellRendererComponent(
                     @NotNull JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column
             ) {
-                myLabel.setText(IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType((JetType) value));
+                myLabel.setText(IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType((KtType) value));
                 myLabel.setBackground(isSelected ? table.getSelectionBackground() : table.getBackground());
                 myLabel.setForeground(isSelected ? table.getSelectionForeground() : table.getForeground());
                 if (isSelected) {
@@ -189,7 +189,7 @@ public class KotlinParameterTablePanel extends JPanel {
                 myEditorComponent.setToString(new Function<Object, String>() {
                     @Override
                     public String fun(Object o) {
-                        return IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType((JetType) o);
+                        return IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType((KtType) o);
                     }
                 });
 
@@ -352,7 +352,7 @@ public class KotlinParameterTablePanel extends JPanel {
                     break;
                 }
                 case PARAMETER_TYPE_COLUMN: {
-                    info.setType((JetType) aValue);
+                    info.setType((KtType) aValue);
                     updateSignature();
                     break;
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractableCodeDescriptor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractableCodeDescriptor.kt
index e520d1689c1..a76122bdead 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractableCodeDescriptor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractableCodeDescriptor.kt
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.Analysis
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.OutputValue.ExpressionValue
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.OutputValue.Initializer
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.OutputValue.Jump
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference.ShorteningMode
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference.ShorteningMode
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.approximateFlexibleTypes
 import org.jetbrains.kotlin.idea.util.isAnnotatedNotNull
@@ -58,21 +58,21 @@ interface Parameter {
     val mirrorVarName: String?
     val receiverCandidate: Boolean
 
-    fun getParameterType(allowSpecialClassNames: Boolean): JetType
+    fun getParameterType(allowSpecialClassNames: Boolean): KtType
 
-    fun getParameterTypeCandidates(allowSpecialClassNames: Boolean): List<JetType>
+    fun getParameterTypeCandidates(allowSpecialClassNames: Boolean): List<KtType>
 
-    fun copy(name: String, parameterType: JetType): Parameter
+    fun copy(name: String, parameterType: KtType): Parameter
 }
 
 val Parameter.nameForRef: String get() = mirrorVarName ?: name
 
 data class TypeParameter(
-        val originalDeclaration: JetTypeParameter,
-        val originalConstraints: List<JetTypeConstraint>
+        val originalDeclaration: KtTypeParameter,
+        val originalConstraints: List<KtTypeConstraint>
 )
 
-interface Replacement: Function2<ExtractableCodeDescriptor, JetElement, JetElement>
+interface Replacement: Function2<ExtractableCodeDescriptor, KtElement, KtElement>
 
 interface ParameterReplacement : Replacement {
     val parameter: Parameter
@@ -82,15 +82,15 @@ interface ParameterReplacement : Replacement {
 class RenameReplacement(override val parameter: Parameter): ParameterReplacement {
     override fun copy(parameter: Parameter) = RenameReplacement(parameter)
 
-    override fun invoke(descriptor: ExtractableCodeDescriptor, e: JetElement): JetElement {
-        var expressionToReplace = (e.getParent() as? JetThisExpression ?: e).let { it.getQualifiedExpressionForSelector() ?: it }
-        val parameterName = JetPsiUtil.unquoteIdentifier(parameter.nameForRef)
+    override fun invoke(descriptor: ExtractableCodeDescriptor, e: KtElement): KtElement {
+        var expressionToReplace = (e.getParent() as? KtThisExpression ?: e).let { it.getQualifiedExpressionForSelector() ?: it }
+        val parameterName = KtPsiUtil.unquoteIdentifier(parameter.nameForRef)
         val replacingName =
                 if (e.getText().startsWith('`') || !KotlinNameSuggester.isIdentifier(parameterName)) "`$parameterName`" else parameterName
-        val psiFactory = JetPsiFactory(e)
+        val psiFactory = KtPsiFactory(e)
         val replacement = when {
             parameter == descriptor.receiverParameter -> psiFactory.createExpression("this")
-            expressionToReplace is JetOperationReferenceExpression -> psiFactory.createOperationName(replacingName)
+            expressionToReplace is KtOperationReferenceExpression -> psiFactory.createOperationName(replacingName)
             else -> psiFactory.createSimpleName(replacingName)
         }
         return expressionToReplace.replaced(replacement)
@@ -100,83 +100,83 @@ class RenameReplacement(override val parameter: Parameter): ParameterReplacement
 class AddPrefixReplacement(override val parameter: Parameter): ParameterReplacement {
     override fun copy(parameter: Parameter) = AddPrefixReplacement(parameter)
 
-    override fun invoke(descriptor: ExtractableCodeDescriptor, e: JetElement): JetElement {
+    override fun invoke(descriptor: ExtractableCodeDescriptor, e: KtElement): KtElement {
         if (descriptor.receiverParameter == parameter) return e
 
-        val selector = (e.parent as? JetCallExpression) ?: e
-        val replacingExpression = JetPsiFactory(e).createExpression("${parameter.nameForRef}.${selector.text}")
-        val newExpr = (selector.replace(replacingExpression) as JetQualifiedExpression).selectorExpression!!
-        return (newExpr as? JetCallExpression)?.calleeExpression ?: newExpr
+        val selector = (e.parent as? KtCallExpression) ?: e
+        val replacingExpression = KtPsiFactory(e).createExpression("${parameter.nameForRef}.${selector.text}")
+        val newExpr = (selector.replace(replacingExpression) as KtQualifiedExpression).selectorExpression!!
+        return (newExpr as? KtCallExpression)?.calleeExpression ?: newExpr
     }
 }
 
 class FqNameReplacement(val fqName: FqName): Replacement {
-    override fun invoke(descriptor: ExtractableCodeDescriptor, e: JetElement): JetElement {
-        val thisExpr = e.getParent() as? JetThisExpression
+    override fun invoke(descriptor: ExtractableCodeDescriptor, e: KtElement): KtElement {
+        val thisExpr = e.getParent() as? KtThisExpression
         if (thisExpr != null) {
-            return thisExpr.replaced(JetPsiFactory(e).createExpression(fqName.asString())).getQualifiedElementSelector()!!
+            return thisExpr.replaced(KtPsiFactory(e).createExpression(fqName.asString())).getQualifiedElementSelector()!!
         }
 
-        val newExpr = (e as? JetSimpleNameExpression)?.mainReference?.bindToFqName(fqName, ShorteningMode.NO_SHORTENING) as JetElement
-        return if (newExpr is JetQualifiedExpression) newExpr.getSelectorExpression()!! else newExpr
+        val newExpr = (e as? KtSimpleNameExpression)?.mainReference?.bindToFqName(fqName, ShorteningMode.NO_SHORTENING) as KtElement
+        return if (newExpr is KtQualifiedExpression) newExpr.getSelectorExpression()!! else newExpr
     }
 }
 
 interface OutputValue {
-    val originalExpressions: List<JetExpression>
-    val valueType: JetType
+    val originalExpressions: List<KtExpression>
+    val valueType: KtType
 
     class ExpressionValue(
             val callSiteReturn: Boolean,
-            override val originalExpressions: List<JetExpression>,
-            override val valueType: JetType
+            override val originalExpressions: List<KtExpression>,
+            override val valueType: KtType
     ): OutputValue
 
     class Jump(
-            val elementsToReplace: List<JetExpression>,
-            val elementToInsertAfterCall: JetElement?,
+            val elementsToReplace: List<KtExpression>,
+            val elementToInsertAfterCall: KtElement?,
             val conditional: Boolean,
             private val builtIns: KotlinBuiltIns
     ): OutputValue {
-        override val originalExpressions: List<JetExpression> get() = elementsToReplace
-        override val valueType: JetType = with(builtIns) { if (conditional) booleanType else unitType }
+        override val originalExpressions: List<KtExpression> get() = elementsToReplace
+        override val valueType: KtType = with(builtIns) { if (conditional) booleanType else unitType }
     }
 
     class ParameterUpdate(
             val parameter: Parameter,
-            override val originalExpressions: List<JetExpression>
+            override val originalExpressions: List<KtExpression>
     ): OutputValue {
-        override val valueType: JetType get() = parameter.getParameterType(false)
+        override val valueType: KtType get() = parameter.getParameterType(false)
     }
 
     class Initializer(
-            val initializedDeclaration: JetProperty,
-            override val valueType: JetType
+            val initializedDeclaration: KtProperty,
+            override val valueType: KtType
     ): OutputValue {
-        override val originalExpressions: List<JetExpression> get() = Collections.singletonList(initializedDeclaration)
+        override val originalExpressions: List<KtExpression> get() = Collections.singletonList(initializedDeclaration)
     }
 }
 
 abstract class OutputValueBoxer(val outputValues: List<OutputValue>) {
-    val outputValueTypes: List<JetType> get() = outputValues.map { it.valueType }
+    val outputValueTypes: List<KtType> get() = outputValues.map { it.valueType }
 
-    abstract val returnType: JetType
+    abstract val returnType: KtType
 
     protected abstract fun getBoxingExpressionText(arguments: List<String>): String?
 
     abstract val boxingRequired: Boolean
 
-    fun getReturnExpression(arguments: List<String>, psiFactory: JetPsiFactory): JetReturnExpression? {
+    fun getReturnExpression(arguments: List<String>, psiFactory: KtPsiFactory): KtReturnExpression? {
         val expressionText = getBoxingExpressionText(arguments) ?: return null
-        return psiFactory.createExpression("return $expressionText") as JetReturnExpression
+        return psiFactory.createExpression("return $expressionText") as KtReturnExpression
     }
 
-    protected abstract fun extractExpressionByIndex(boxedExpression: JetExpression, index: Int): JetExpression?
+    protected abstract fun extractExpressionByIndex(boxedExpression: KtExpression, index: Int): KtExpression?
 
-    protected fun extractArgumentExpressionByIndex(boxedExpression: JetExpression, index: Int): JetExpression? {
-        val call: JetCallExpression? = when (boxedExpression) {
-            is JetCallExpression -> boxedExpression
-            is JetQualifiedExpression -> boxedExpression.getSelectorExpression() as? JetCallExpression
+    protected fun extractArgumentExpressionByIndex(boxedExpression: KtExpression, index: Int): KtExpression? {
+        val call: KtCallExpression? = when (boxedExpression) {
+            is KtCallExpression -> boxedExpression
+            is KtQualifiedExpression -> boxedExpression.getSelectorExpression() as? KtCallExpression
             else -> null
         }
         val arguments = call?.getValueArguments()
@@ -185,7 +185,7 @@ abstract class OutputValueBoxer(val outputValues: List<OutputValue>) {
         return arguments[index].getArgumentExpression()
     }
 
-    fun extractExpressionByValue(boxedExpression: JetExpression, value: OutputValue): JetExpression? {
+    fun extractExpressionByValue(boxedExpression: KtExpression, value: OutputValue): KtExpression? {
         val index = outputValues.indexOf(value)
         if (index < 0) return null
 
@@ -206,8 +206,8 @@ abstract class OutputValueBoxer(val outputValues: List<OutputValue>) {
             private val selectors = arrayOf("first", "second", "third")
         }
 
-        override val returnType: JetType by lazy {
-            fun getType(): JetType {
+        override val returnType: KtType by lazy {
+            fun getType(): KtType {
                 val boxingClass = when (outputValues.size()) {
                     1 -> return outputValues.first().valueType
                     2 -> module.resolveTopLevelClass(FqName("kotlin.Pair"), NoLookupLocation.FROM_IDE)!!
@@ -233,7 +233,7 @@ abstract class OutputValueBoxer(val outputValues: List<OutputValue>) {
             }
         }
 
-        override fun extractExpressionByIndex(boxedExpression: JetExpression, index: Int): JetExpression? {
+        override fun extractExpressionByIndex(boxedExpression: KtExpression, index: Int): KtExpression? {
             if (outputValues.size() == 1) return boxedExpression
             return extractArgumentExpressionByIndex(boxedExpression, index)
         }
@@ -251,7 +251,7 @@ abstract class OutputValueBoxer(val outputValues: List<OutputValue>) {
     }
 
     class AsList(outputValues: List<OutputValue>): OutputValueBoxer(outputValues) {
-        override val returnType: JetType by lazy {
+        override val returnType: KtType by lazy {
             assert(outputValues.isNotEmpty())
             val builtIns = outputValues.first().valueType.builtIns
             TypeUtils.substituteParameters(
@@ -267,7 +267,7 @@ abstract class OutputValueBoxer(val outputValues: List<OutputValue>) {
             return arguments.joinToString(prefix = "kotlin.listOf(", separator = ", ", postfix = ")")
         }
 
-        override fun extractExpressionByIndex(boxedExpression: JetExpression, index: Int): JetExpression? {
+        override fun extractExpressionByIndex(boxedExpression: KtExpression, index: Int): KtExpression? {
             return extractArgumentExpressionByIndex(boxedExpression, index)
         }
 
@@ -281,7 +281,7 @@ abstract class OutputValueBoxer(val outputValues: List<OutputValue>) {
 data class ControlFlow(
         val outputValues: List<OutputValue>,
         val boxerFactory: (List<OutputValue>) -> OutputValueBoxer,
-        val declarationsToCopy: List<JetDeclaration>
+        val declarationsToCopy: List<KtDeclaration>
 ) {
     val outputValueBoxer = boxerFactory(outputValues)
 
@@ -302,7 +302,7 @@ data class ControlFlow(
     }
 }
 
-val ControlFlow.possibleReturnTypes: List<JetType>
+val ControlFlow.possibleReturnTypes: List<KtType>
     get() {
         val returnType = outputValueBoxer.returnType
         return when {
@@ -328,7 +328,7 @@ data class ExtractableCodeDescriptor(
         val typeParameters: List<TypeParameter>,
         val replacementMap: Map<Int, Replacement>,
         val controlFlow: ControlFlow,
-        val returnType: JetType
+        val returnType: KtType
 ) {
     val name: String get() = suggestedNames.firstOrNull() ?: ""
     val duplicates: List<DuplicateInfo> by lazy { findDuplicates() }
@@ -374,13 +374,13 @@ enum class ExtractionTarget(val targetName: String) {
 
     companion object {
         fun checkNotTrait(descriptor: ExtractableCodeDescriptor): Boolean {
-            val parent = descriptor.extractionData.targetSibling.getStrictParentOfType<JetDeclaration>()
-            return !(parent is JetClass && parent.isInterface())
+            val parent = descriptor.extractionData.targetSibling.getStrictParentOfType<KtDeclaration>()
+            return !(parent is KtClass && parent.isInterface())
         }
 
         fun checkSimpleBody(descriptor: ExtractableCodeDescriptor): Boolean {
             val expression = descriptor.extractionData.getExpressions().singleOrNull()
-            return expression != null && expression !is JetDeclaration && expression !is JetBlockExpression
+            return expression != null && expression !is KtDeclaration && expression !is KtBlockExpression
         }
 
         fun checkSimpleControlFlow(descriptor: ExtractableCodeDescriptor): Boolean {
@@ -393,7 +393,7 @@ enum class ExtractionTarget(val targetName: String) {
             if (descriptor.returnType.isUnit()) return false
 
             val parent = descriptor.extractionData.targetSibling.getParent()
-            return (parent is JetFile || parent is JetClassBody)
+            return (parent is KtFile || parent is KtClassBody)
         }
     }
 }
@@ -421,9 +421,9 @@ data class ExtractionGeneratorConfiguration(
 
 data class ExtractionResult(
         val config: ExtractionGeneratorConfiguration,
-        val declaration: JetNamedDeclaration,
+        val declaration: KtNamedDeclaration,
         val duplicateReplacers: Map<JetPsiRange, () -> Unit>,
-        val nameByOffset: Map<Int, JetElement>
+        val nameByOffset: Map<Int, KtElement>
 )
 
 class AnalysisResult (
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractionData.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractionData.kt
index f5c8ec97a11..fdaed361f99 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractionData.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractionData.kt
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver
 import org.jetbrains.kotlin.resolve.source.getPsi
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.util.*
 
 data class ExtractionOptions(
@@ -61,22 +61,22 @@ data class ExtractionOptions(
 }
 
 data class ResolveResult(
-        val originalRefExpr: JetSimpleNameExpression,
+        val originalRefExpr: KtSimpleNameExpression,
         val declaration: PsiNameIdentifierOwner,
         val descriptor: DeclarationDescriptor,
         val resolvedCall: ResolvedCall<*>?
 )
 
 data class ResolvedReferenceInfo(
-        val refExpr: JetSimpleNameExpression,
+        val refExpr: KtSimpleNameExpression,
         val offsetInBody: Int,
         val resolveResult: ResolveResult,
-        val smartCast: JetType?,
-        val possibleTypes: Set<JetType>
+        val smartCast: KtType?,
+        val possibleTypes: Set<KtType>
 )
 
 data class ExtractionData(
-        val originalFile: JetFile,
+        val originalFile: KtFile,
         val originalRange: JetPsiRange,
         val targetSibling: PsiElement,
         val duplicateContainer: PsiElement? = null,
@@ -86,11 +86,11 @@ data class ExtractionData(
     val originalElements: List<PsiElement> = originalRange.elements
 
     val insertBefore: Boolean = options.extractAsProperty
-                                || targetSibling.getStrictParentOfType<JetDeclaration>()?.let {
-                                    it is JetDeclarationWithBody || it is JetClassInitializer
+                                || targetSibling.getStrictParentOfType<KtDeclaration>()?.let {
+                                    it is KtDeclarationWithBody || it is KtClassInitializer
                                 } ?: false
 
-    fun getExpressions(): List<JetExpression> = originalElements.filterIsInstance<JetExpression>()
+    fun getExpressions(): List<KtExpression> = originalElements.filterIsInstance<KtExpression>()
 
     private fun getCodeFragmentTextRange(): TextRange? {
         val originalElements = originalElements
@@ -112,17 +112,17 @@ data class ExtractionData(
     val originalStartOffset: Int?
         get() = originalElements.firstOrNull()?.let { e -> e.getTextRange()!!.getStartOffset() }
 
-    val commonParent = PsiTreeUtil.findCommonParent(originalElements) as JetElement
+    val commonParent = PsiTreeUtil.findCommonParent(originalElements) as KtElement
 
     val bindingContext: BindingContext? by lazy { commonParent.getContextForContainingDeclarationBody() }
 
-    private val itFakeDeclaration by lazy { JetPsiFactory(originalFile).createParameter("it: Any?") }
-    private val synthesizedInvokeDeclaration by lazy { JetPsiFactory(originalFile).createFunction("fun invoke() {}") }
+    private val itFakeDeclaration by lazy { KtPsiFactory(originalFile).createParameter("it: Any?") }
+    private val synthesizedInvokeDeclaration by lazy { KtPsiFactory(originalFile).createFunction("fun invoke() {}") }
 
     val refOffsetToDeclaration by lazy {
         fun isExtractableIt(descriptor: DeclarationDescriptor, context: BindingContext): Boolean {
             if (!(descriptor is ValueParameterDescriptor && (context[BindingContext.AUTO_CREATED_IT, descriptor] ?: false))) return false
-            val function = DescriptorToSourceUtils.descriptorToDeclaration(descriptor.getContainingDeclaration()) as? JetFunctionLiteral
+            val function = DescriptorToSourceUtils.descriptorToDeclaration(descriptor.getContainingDeclaration()) as? KtFunctionLiteral
             return function == null || !function.isInsideOf(originalElements)
         }
 
@@ -146,8 +146,8 @@ data class ExtractionData(
         if (originalStartOffset != null && context != null) {
             val resultMap = HashMap<Int, ResolveResult>()
 
-            val visitor = object: JetTreeVisitorVoid() {
-                override fun visitQualifiedExpression(expression: JetQualifiedExpression) {
+            val visitor = object: KtTreeVisitorVoid() {
+                override fun visitQualifiedExpression(expression: KtQualifiedExpression) {
                     if (context[BindingContext.SMARTCAST, expression] != null) {
                         expression.getSelectorExpression()?.accept(this)
                         return
@@ -156,9 +156,9 @@ data class ExtractionData(
                     super.visitQualifiedExpression(expression)
                 }
 
-                override fun visitSimpleNameExpression(ref: JetSimpleNameExpression) {
-                    if (ref !is JetSimpleNameExpression) return
-                    if (ref.getParent() is JetValueArgumentName) return
+                override fun visitSimpleNameExpression(ref: KtSimpleNameExpression) {
+                    if (ref !is KtSimpleNameExpression) return
+                    if (ref.getParent() is KtValueArgumentName) return
 
                     val resolvedCall = ref.getResolvedCall(context)
                     val descriptor = context[BindingContext.REFERENCE_TARGET, ref] ?: return
@@ -175,7 +175,7 @@ data class ExtractionData(
         else Collections.emptyMap<Int, ResolveResult>()
     }
 
-    fun getPossibleTypes(expression: JetExpression, resolvedCall: ResolvedCall<*>?, context: BindingContext): Set<JetType> {
+    fun getPossibleTypes(expression: KtExpression, resolvedCall: ResolvedCall<*>?, context: BindingContext): Set<KtType> {
         val typeInfo = context[BindingContext.EXPRESSION_TYPE_INFO, expression] ?: return emptySet()
 
         (resolvedCall?.getImplicitReceiverValue() as? ThisReceiver)?.let {
@@ -188,7 +188,7 @@ data class ExtractionData(
         return typeInfo.dataFlowInfo.getPossibleTypes(dataFlowValue)
     }
 
-    fun getBrokenReferencesInfo(body: JetBlockExpression): List<ResolvedReferenceInfo> {
+    fun getBrokenReferencesInfo(body: KtBlockExpression): List<ResolvedReferenceInfo> {
         val originalContext = bindingContext ?: return listOf()
 
         val startOffset = body.getBlockContentOffset()
@@ -196,25 +196,25 @@ data class ExtractionData(
         val referencesInfo = ArrayList<ResolvedReferenceInfo>()
         val refToContextMap = JetFileReferencesResolver.resolve(body)
         for ((ref, context) in refToContextMap) {
-            if (ref !is JetSimpleNameExpression) continue
+            if (ref !is KtSimpleNameExpression) continue
 
             val offset = ref.getTextRange()!!.getStartOffset() - startOffset
             val originalResolveResult = refOffsetToDeclaration[offset] ?: continue
 
-            val smartCast: JetType?
-            val possibleTypes: Set<JetType>
+            val smartCast: KtType?
+            val possibleTypes: Set<KtType>
 
             // Qualified property reference: a.b
             val qualifiedExpression = ref.getQualifiedExpressionForSelector()
             if (qualifiedExpression != null) {
-                val smartCastTarget = originalResolveResult.originalRefExpr.getParent() as JetExpression
+                val smartCastTarget = originalResolveResult.originalRefExpr.getParent() as KtExpression
                 smartCast = originalContext[BindingContext.SMARTCAST, smartCastTarget]
                 possibleTypes = getPossibleTypes(smartCastTarget, originalResolveResult.resolvedCall, originalContext)
                 val receiverDescriptor =
                         (originalResolveResult.resolvedCall?.getDispatchReceiver() as? ThisReceiver)?.getDeclarationDescriptor()
                 if (smartCast == null
                     && !DescriptorUtils.isCompanionObject(receiverDescriptor)
-                    && qualifiedExpression.getReceiverExpression() !is JetSuperExpression) continue
+                    && qualifiedExpression.getReceiverExpression() !is KtSuperExpression) continue
             }
             else {
                 smartCast = originalContext[BindingContext.SMARTCAST, originalResolveResult.originalRefExpr]
@@ -224,7 +224,7 @@ data class ExtractionData(
             val parent = ref.getParent()
 
             // Skip P in type references like 'P.Q'
-            if (parent is JetUserType && (parent.getParent() as? JetUserType)?.getQualifier() == parent) continue
+            if (parent is KtUserType && (parent.getParent() as? KtUserType)?.getQualifier() == parent) continue
 
             val descriptor = context[BindingContext.REFERENCE_TARGET, ref]
             val isBadRef = !(compareDescriptors(project, originalResolveResult.descriptor, descriptor)
@@ -257,8 +257,8 @@ data class ExtractionData(
 // Hack:
 // we can't get first element offset through getStatement()/getChildren() since they skip comments and whitespaces
 // So we take offset of the left brace instead and increase it by 2 (which is length of "{\n" separating block start and its first element)
-internal fun JetExpression.getBlockContentOffset(): Int {
-    (this as? JetBlockExpression)?.getLBrace()?.let {
+internal fun KtExpression.getBlockContentOffset(): Int {
+    (this as? KtBlockExpression)?.getLBrace()?.let {
         return it.getTextRange()!!.getStartOffset() + 2
     }
     return getTextRange()!!.getStartOffset()
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt
index ac7f4881c8b..9c62dbac14b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt
@@ -60,7 +60,7 @@ import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.approximateWithResolvableType
 import org.jetbrains.kotlin.idea.util.isResolvableInScope
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-import org.jetbrains.kotlin.lexer.JetToken
+import org.jetbrains.kotlin.lexer.KtToken
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.*
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
@@ -80,7 +80,7 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver
 import org.jetbrains.kotlin.resolve.scopes.utils.asJetScope
 import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.types.typeUtil.makeNullable
 import org.jetbrains.kotlin.utils.DFS
@@ -89,8 +89,8 @@ import org.jetbrains.kotlin.utils.DFS.Neighbors
 import org.jetbrains.kotlin.utils.DFS.VisitedWithSet
 import java.util.*
 
-internal val KotlinBuiltIns.defaultReturnType: JetType get() = unitType
-internal val KotlinBuiltIns.defaultParameterType: JetType get() = nullableAnyType
+internal val KotlinBuiltIns.defaultReturnType: KtType get() = unitType
+internal val KotlinBuiltIns.defaultParameterType: KtType get() = nullableAnyType
 
 private fun DeclarationDescriptor.renderForMessage(): String =
         IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.render(this)
@@ -99,17 +99,17 @@ private val TYPE_RENDERER = DescriptorRenderer.FQ_NAMES_IN_TYPES.withOptions {
     typeNormalizer = IdeDescriptorRenderers.APPROXIMATE_FLEXIBLE_TYPES
 }
 
-private fun JetType.renderForMessage(): String = TYPE_RENDERER.renderType(this)
+private fun KtType.renderForMessage(): String = TYPE_RENDERER.renderType(this)
 
-private fun JetDeclaration.renderForMessage(bindingContext: BindingContext): String? =
+private fun KtDeclaration.renderForMessage(bindingContext: BindingContext): String? =
     bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, this]?.renderForMessage()
 
-internal fun JetType.isDefault(): Boolean = KotlinBuiltIns.isUnit(this)
+internal fun KtType.isDefault(): Boolean = KotlinBuiltIns.isUnit(this)
 
-private fun List<Instruction>.getModifiedVarDescriptors(bindingContext: BindingContext): Map<VariableDescriptor, List<JetExpression>> {
-    val result = HashMap<VariableDescriptor, MutableList<JetExpression>>()
+private fun List<Instruction>.getModifiedVarDescriptors(bindingContext: BindingContext): Map<VariableDescriptor, List<KtExpression>> {
+    val result = HashMap<VariableDescriptor, MutableList<KtExpression>>()
     for (instruction in filterIsInstance<WriteValueInstruction>()) {
-        val expression = instruction.element as? JetExpression
+        val expression = instruction.element as? KtExpression
         val descriptor = PseudocodeUtil.extractVariableDescriptorIfAny(instruction, false, bindingContext)
         if (expression != null && descriptor != null) {
             result.getOrPut(descriptor) { ArrayList() }.add(expression)
@@ -149,25 +149,25 @@ private fun List<Instruction>.getResultTypeAndExpressions(
         targetScope: LexicalScope?,
         options: ExtractionOptions,
         module: ModuleDescriptor
-): Pair<JetType, List<JetExpression>> {
-    fun instructionToExpression(instruction: Instruction, unwrapReturn: Boolean): JetExpression? {
+): Pair<KtType, List<KtExpression>> {
+    fun instructionToExpression(instruction: Instruction, unwrapReturn: Boolean): KtExpression? {
         return when (instruction) {
             is ReturnValueInstruction ->
-                (if (unwrapReturn) null else instruction.returnExpressionIfAny) ?: instruction.returnedValue.element as? JetExpression
+                (if (unwrapReturn) null else instruction.returnExpressionIfAny) ?: instruction.returnedValue.element as? KtExpression
             is InstructionWithValue ->
-                instruction.outputValue?.element as? JetExpression
+                instruction.outputValue?.element as? KtExpression
             else -> null
         }
     }
 
-    fun instructionToType(instruction: Instruction): JetType? {
+    fun instructionToType(instruction: Instruction): KtType? {
         val expression = instructionToExpression(instruction, true)
 
         if (expression == null) return null
         if (options.inferUnitTypeForUnusedValues && expression.isUsedAsStatement(bindingContext)) return null
 
         return bindingContext.getType(expression)
-               ?: (expression as? JetReferenceExpression)?.let {
+               ?: (expression as? KtReferenceExpression)?.let {
                    (bindingContext[BindingContext.REFERENCE_TARGET, it] as? CallableDescriptor)?.getReturnType()
                }
     }
@@ -214,7 +214,7 @@ private fun getCommonNonTrivialSuccessorIfAny(instructions: List<Instruction>):
     return singleSuccessorCheckingVisitor.target ?: instructions.firstOrNull()?.owner?.getSinkInstruction()
 }
 
-private fun JetType.isMeaningful(): Boolean {
+private fun KtType.isMeaningful(): Boolean {
     return !KotlinBuiltIns.isUnit(this) && !KotlinBuiltIns.isNothing(this)
 }
 
@@ -222,13 +222,13 @@ private fun ExtractionData.getLocalDeclarationsWithNonLocalUsages(
         pseudocode: Pseudocode,
         localInstructions: List<Instruction>,
         bindingContext: BindingContext
-): List<JetNamedDeclaration> {
-    val declarations = HashSet<JetNamedDeclaration>()
+): List<KtNamedDeclaration> {
+    val declarations = HashSet<KtNamedDeclaration>()
     pseudocode.traverse(TraversalOrder.FORWARD) { instruction ->
         if (instruction !in localInstructions) {
             instruction.getPrimaryDeclarationDescriptorIfAny(bindingContext)?.let { descriptor ->
                 val declaration = DescriptorToSourceUtilsIde.getAnyDeclaration(project, descriptor)
-                if (declaration is JetNamedDeclaration && declaration.isInsideOf(originalElements)) {
+                if (declaration is KtNamedDeclaration && declaration.isInsideOf(originalElements)) {
                     declarations.add(declaration)
                 }
             }
@@ -242,7 +242,7 @@ private fun ExtractionData.analyzeControlFlow(
         pseudocode: Pseudocode,
         module: ModuleDescriptor,
         bindingContext: BindingContext,
-        modifiedVarDescriptors: Map<VariableDescriptor, List<JetExpression>>,
+        modifiedVarDescriptors: Map<VariableDescriptor, List<KtExpression>>,
         options: ExtractionOptions,
         targetScope: LexicalScope?,
         parameters: Set<Parameter>
@@ -258,7 +258,7 @@ private fun ExtractionData.analyzeControlFlow(
                 when {
                     it !is ReturnValueInstruction && it !is ReturnNoValueInstruction && it.owner != pseudocode ->
                         null
-                    e != null && e !is JetBreakExpression && e !is JetContinueExpression ->
+                    e != null && e !is KtBreakExpression && e !is KtContinueExpression ->
                         it.previousInstructions.firstOrNull()
                     else ->
                         it
@@ -278,12 +278,12 @@ private fun ExtractionData.analyzeControlFlow(
 
             is AbstractJumpInstruction -> {
                 val element = insn.element
-                if ((element is JetReturnExpression && insn.owner == pseudocode)
-                        || element is JetBreakExpression
-                        || element is JetContinueExpression) {
+                if ((element is KtReturnExpression && insn.owner == pseudocode)
+                        || element is KtBreakExpression
+                        || element is KtContinueExpression) {
                     jumpExits.add(insn)
                 }
-                else if (element !is JetThrowExpression) {
+                else if (element !is KtThrowExpression) {
                     defaultExits.add(insn)
                 }
             }
@@ -295,7 +295,7 @@ private fun ExtractionData.analyzeControlFlow(
     }
 
     val nonLocallyUsedDeclarations = getLocalDeclarationsWithNonLocalUsages(pseudocode, localInstructions, bindingContext)
-    val (declarationsToCopy, declarationsToReport) = nonLocallyUsedDeclarations.partition { it is JetProperty && it.isLocal() }
+    val (declarationsToCopy, declarationsToReport) = nonLocallyUsedDeclarations.partition { it is KtProperty && it.isLocal() }
 
     val (typeOfDefaultFlow, defaultResultExpressions) = defaultExits.getResultTypeAndExpressions(bindingContext, targetScope, options, module)
     val (returnValueType, valuedReturnExpressions) = valuedReturnExits.getResultTypeAndExpressions(bindingContext, targetScope, options, module)
@@ -341,7 +341,7 @@ private fun ExtractionData.analyzeControlFlow(
             if (modifiedValueCount != 0) return outputAndExitsError
             if (valuedReturnExits.size() != 1) return multipleExitsError
 
-            val element = valuedReturnExits.first().element as JetExpression
+            val element = valuedReturnExits.first().element as KtExpression
             return controlFlow.copy(outputValues = Collections.singletonList(Jump(listOf(element), element, true, module.builtIns))) to null
         }
 
@@ -351,7 +351,7 @@ private fun ExtractionData.analyzeControlFlow(
 
     outDeclarations.mapTo(outputValues) {
         val descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, it] as? CallableDescriptor
-        Initializer(it as JetProperty, descriptor?.getReturnType() ?: module.builtIns.defaultParameterType)
+        Initializer(it as KtProperty, descriptor?.getReturnType() ?: module.builtIns.defaultParameterType)
     }
     outParameters.mapTo(outputValues) { ParameterUpdate(it, modifiedVarDescriptors[it.originalDescriptor]!!) }
 
@@ -381,7 +381,7 @@ private fun ExtractionData.analyzeControlFlow(
 
         val singleExit = getCommonNonTrivialSuccessorIfAny(defaultExits) == jumpTarget
         val conditional = !singleExit && defaultExits.isNotEmpty()
-        val elements = jumpExits.map { it.element as JetExpression }
+        val elements = jumpExits.map { it.element as KtExpression }
         val elementToInsertAfterCall = if (singleExit) null else elements.first()
         return controlFlow.copy(outputValues = Collections.singletonList(Jump(elements, elementToInsertAfterCall, conditional, module.builtIns))) to null
     }
@@ -389,7 +389,7 @@ private fun ExtractionData.analyzeControlFlow(
     return controlFlow to null
 }
 
-fun ExtractionData.createTemporaryDeclaration(functionText: String): JetNamedDeclaration {
+fun ExtractionData.createTemporaryDeclaration(functionText: String): KtNamedDeclaration {
     val textRange = targetSibling.getTextRange()!!
 
     val insertText: String
@@ -409,36 +409,36 @@ fun ExtractionData.createTemporaryDeclaration(functionText: String): JetNamedDec
     val tmpFile = originalFile.createTempCopy { text ->
         StringBuilder(text).insert(insertPosition, insertText).toString()
     }
-    return tmpFile.findElementAt(lookupPosition)?.getNonStrictParentOfType<JetNamedDeclaration>()!!
+    return tmpFile.findElementAt(lookupPosition)?.getNonStrictParentOfType<KtNamedDeclaration>()!!
 }
 
-private fun ExtractionData.createTemporaryCodeBlock(): JetBlockExpression =
-        (createTemporaryDeclaration("fun() {\n$codeFragmentText\n}\n") as JetNamedFunction).getBodyExpression() as JetBlockExpression
+private fun ExtractionData.createTemporaryCodeBlock(): KtBlockExpression =
+        (createTemporaryDeclaration("fun() {\n$codeFragmentText\n}\n") as KtNamedFunction).getBodyExpression() as KtBlockExpression
 
-private fun JetType.collectReferencedTypes(processTypeArguments: Boolean): List<JetType> {
+private fun KtType.collectReferencedTypes(processTypeArguments: Boolean): List<KtType> {
     if (!processTypeArguments) return Collections.singletonList(this)
     return DFS.dfsFromNode(
             this,
-            object: Neighbors<JetType> {
-                override fun getNeighbors(current: JetType): Iterable<JetType> = current.getArguments().map { it.getType() }
+            object: Neighbors<KtType> {
+                override fun getNeighbors(current: KtType): Iterable<KtType> = current.getArguments().map { it.getType() }
             },
             VisitedWithSet(),
-            object: CollectingNodeHandler<JetType, JetType, ArrayList<JetType>>(ArrayList()) {
-                override fun afterChildren(current: JetType) {
+            object: CollectingNodeHandler<KtType, KtType, ArrayList<KtType>>(ArrayList()) {
+                override fun afterChildren(current: KtType) {
                     result.add(current)
                 }
             }
     )!!
 }
 
-fun JetTypeParameter.collectRelevantConstraints(): List<JetTypeConstraint> {
-    val typeConstraints = getNonStrictParentOfType<JetTypeParameterListOwner>()?.getTypeConstraints()
+fun KtTypeParameter.collectRelevantConstraints(): List<KtTypeConstraint> {
+    val typeConstraints = getNonStrictParentOfType<KtTypeParameterListOwner>()?.getTypeConstraints()
     if (typeConstraints == null) return Collections.emptyList()
     return typeConstraints.filter { it.getSubjectTypeParameterName()?.mainReference?.resolve() == this}
 }
 
-fun TypeParameter.collectReferencedTypes(bindingContext: BindingContext): List<JetType> {
-    val typeRefs = ArrayList<JetTypeReference>()
+fun TypeParameter.collectReferencedTypes(bindingContext: BindingContext): List<KtType> {
+    val typeRefs = ArrayList<KtTypeReference>()
     originalDeclaration.getExtendsBound()?.let { typeRefs.add(it) }
     originalConstraints
             .map { it.getBoundTypeReference() }
@@ -449,20 +449,20 @@ fun TypeParameter.collectReferencedTypes(bindingContext: BindingContext): List<J
             .filterNotNull()
 }
 
-private fun JetType.isExtractable(targetScope: LexicalScope?): Boolean {
+private fun KtType.isExtractable(targetScope: LexicalScope?): Boolean {
     return collectReferencedTypes(true).fold(true) { extractable, typeToCheck ->
         val parameterTypeDescriptor = typeToCheck.getConstructor().getDeclarationDescriptor() as? TypeParameterDescriptor
         val typeParameter = parameterTypeDescriptor?.let {
             DescriptorToSourceUtils.descriptorToDeclaration(it)
-        } as? JetTypeParameter
+        } as? KtTypeParameter
 
         extractable && (typeParameter != null || typeToCheck.isResolvableInScope(targetScope, false))
     }
 }
 
-private fun JetType.processTypeIfExtractable(
+private fun KtType.processTypeIfExtractable(
         typeParameters: MutableSet<TypeParameter>,
-        nonDenotableTypes: MutableSet<JetType>,
+        nonDenotableTypes: MutableSet<KtType>,
         options: ExtractionOptions,
         targetScope: LexicalScope?,
         processTypeArguments: Boolean = true
@@ -471,7 +471,7 @@ private fun JetType.processTypeIfExtractable(
         val parameterTypeDescriptor = typeToCheck.getConstructor().getDeclarationDescriptor() as? TypeParameterDescriptor
         val typeParameter = parameterTypeDescriptor?.let {
             DescriptorToSourceUtils.descriptorToDeclaration(it)
-        } as? JetTypeParameter
+        } as? KtTypeParameter
 
         when {
             typeToCheck.isResolvableInScope(targetScope, true) ->
@@ -501,17 +501,17 @@ private class MutableParameter(
         override val originalDescriptor: DeclarationDescriptor,
         override val receiverCandidate: Boolean,
         private val targetScope: LexicalScope?,
-        private val originalType: JetType,
-        private val possibleTypes: Set<JetType>
+        private val originalType: KtType,
+        private val possibleTypes: Set<KtType>
 ): Parameter {
     // All modifications happen in the same thread
     private var writable: Boolean = true
-    private val defaultTypes = LinkedHashSet<JetType>()
+    private val defaultTypes = LinkedHashSet<KtType>()
     private val typePredicates = HashSet<TypePredicate>()
 
     var refCount: Int = 0
 
-    fun addDefaultType(jetType: JetType) {
+    fun addDefaultType(jetType: KtType) {
         assert(writable) { "Can't add type to non-writable parameter $currentName" }
 
         if (jetType in possibleTypes) {
@@ -529,22 +529,22 @@ private class MutableParameter(
 
     override var mirrorVarName: String? = null
 
-    private val defaultType: JetType by lazy {
+    private val defaultType: KtType by lazy {
         writable = false
         if (defaultTypes.isNotEmpty()) {
-            TypeIntersector.intersectTypes(JetTypeChecker.DEFAULT, defaultTypes)!!
+            TypeIntersector.intersectTypes(KotlinTypeChecker.DEFAULT, defaultTypes)!!
         }
         else originalType
     }
 
-    private val parameterTypeCandidates: List<JetType> by lazy {
+    private val parameterTypeCandidates: List<KtType> by lazy {
         writable = false
 
         val typePredicate = and(typePredicates)
 
         val typeSet = if (defaultType.isFlexible()) {
             val bounds = defaultType.getCapability(javaClass<Flexibility>())!!
-            LinkedHashSet<JetType>().apply {
+            LinkedHashSet<KtType>().apply {
                 if (typePredicate(bounds.upperBound)) add(bounds.upperBound)
                 if (typePredicate(bounds.lowerBound)) add(bounds.lowerBound)
             }
@@ -564,7 +564,7 @@ private class MutableParameter(
         typeSet.toList()
     }
 
-    override fun getParameterTypeCandidates(allowSpecialClassNames: Boolean): List<JetType> {
+    override fun getParameterTypeCandidates(allowSpecialClassNames: Boolean): List<KtType> {
             return if (!allowSpecialClassNames) {
                 parameterTypeCandidates.filter { it.isExtractable(targetScope) }
             } else {
@@ -572,29 +572,29 @@ private class MutableParameter(
             }
     }
 
-    override fun getParameterType(allowSpecialClassNames: Boolean): JetType {
+    override fun getParameterType(allowSpecialClassNames: Boolean): KtType {
         return getParameterTypeCandidates(allowSpecialClassNames).firstOrNull() ?: defaultType
     }
 
-    override fun copy(name: String, parameterType: JetType): Parameter = DelegatingParameter(this, name, parameterType)
+    override fun copy(name: String, parameterType: KtType): Parameter = DelegatingParameter(this, name, parameterType)
 }
 
 private class DelegatingParameter(
         val original: Parameter,
         override val name: String,
-        val parameterType: JetType
+        val parameterType: KtType
 ): Parameter by original {
-    override fun copy(name: String, parameterType: JetType): Parameter = DelegatingParameter(original, name, parameterType)
+    override fun copy(name: String, parameterType: KtType): Parameter = DelegatingParameter(original, name, parameterType)
     override fun getParameterType(allowSpecialClassNames: Boolean) = parameterType
 }
 
 private class ParametersInfo {
     var errorMessage: ErrorMessage? = null
     val replacementMap: MutableMap<Int, Replacement> = HashMap()
-    val originalRefToParameter: MutableMap<JetSimpleNameExpression, MutableParameter> = HashMap()
+    val originalRefToParameter: MutableMap<KtSimpleNameExpression, MutableParameter> = HashMap()
     val parameters: MutableSet<MutableParameter> = HashSet()
     val typeParameters: MutableSet<TypeParameter> = HashSet()
-    val nonDenotableTypes: MutableSet<JetType> = HashSet()
+    val nonDenotableTypes: MutableSet<KtType> = HashSet()
 }
 
 private fun ExtractionData.inferParametersInfo(
@@ -611,11 +611,11 @@ private fun ExtractionData.inferParametersInfo(
     fun suggestParameterType(
             extractFunctionRef: Boolean,
             originalDescriptor: DeclarationDescriptor,
-            parameterExpression: JetExpression?,
+            parameterExpression: KtExpression?,
             receiverToExtract: ReceiverValue,
             resolvedCall: ResolvedCall<*>?,
             useSmartCastsIfPossible: Boolean
-    ): JetType {
+    ): KtType {
         val builtIns = originalDescriptor.builtIns
         return when {
                    extractFunctionRef -> {
@@ -628,7 +628,7 @@ private fun ExtractionData.inferParametersInfo(
                    parameterExpression != null ->
                        (if (useSmartCastsIfPossible) bindingContext[BindingContext.SMARTCAST, parameterExpression] else null)
                        ?: bindingContext.getType(parameterExpression)
-                       ?: (parameterExpression as? JetReferenceExpression)?.let {
+                       ?: (parameterExpression as? KtReferenceExpression)?.let {
                            (bindingContext[BindingContext.REFERENCE_TARGET, it] as? CallableDescriptor)?.getReturnType()
                        }
                        ?: if (receiverToExtract.exists()) receiverToExtract.getType() else null
@@ -651,8 +651,8 @@ private fun ExtractionData.inferParametersInfo(
         val (originalRef, originalDeclaration, originalDescriptor, resolvedCall) = refInfo.resolveResult
         val ref = refInfo.refExpr
 
-        val selector = (ref.getParent() as? JetCallExpression) ?: ref
-        val superExpr = (selector.getParent() as? JetQualifiedExpression)?.getReceiverExpression() as? JetSuperExpression
+        val selector = (ref.getParent() as? KtCallExpression) ?: ref
+        val superExpr = (selector.getParent() as? KtQualifiedExpression)?.getReceiverExpression() as? KtSuperExpression
         if (superExpr != null) {
             info.errorMessage = ErrorMessage.SUPER_CALL
             return info
@@ -667,7 +667,7 @@ private fun ExtractionData.inferParametersInfo(
 
         val thisDescriptor = (receiverToExtract as? ThisReceiver)?.getDeclarationDescriptor()
         val hasThisReceiver = thisDescriptor != null
-        val thisExpr = ref.getParent() as? JetThisExpression
+        val thisExpr = ref.getParent() as? KtThisExpression
 
         if (hasThisReceiver
             && DescriptorToSourceUtilsIde.getAllDeclarations(project, thisDescriptor!!).all { it.isInsideOf(originalElements) }) {
@@ -680,7 +680,7 @@ private fun ExtractionData.inferParametersInfo(
                     when(it.getKind()) {
                         ClassKind.OBJECT, ClassKind.ENUM_CLASS -> it as ClassifierDescriptor
                         ClassKind.ENUM_ENTRY -> it.getContainingDeclaration() as? ClassDescriptor
-                        else -> if (ref.getNonStrictParentOfType<JetTypeReference>() != null) it as ClassifierDescriptor else null
+                        else -> if (ref.getNonStrictParentOfType<KtTypeReference>() != null) it as ClassifierDescriptor else null
                     }
 
                 is TypeParameterDescriptor -> it as ClassifierDescriptor
@@ -703,14 +703,14 @@ private fun ExtractionData.inferParametersInfo(
         else {
             val extractThis = (hasThisReceiver && refInfo.smartCast == null) || thisExpr != null
             val extractOrdinaryParameter =
-                    originalDeclaration is JetMultiDeclarationEntry ||
-                            originalDeclaration is JetProperty ||
-                            originalDeclaration is JetParameter
+                    originalDeclaration is KtMultiDeclarationEntry ||
+                            originalDeclaration is KtProperty ||
+                            originalDeclaration is KtParameter
 
             val extractFunctionRef =
                     options.captureLocalFunctions
                     && originalRef.getReferencedName() == originalDescriptor.getName().asString() // to forbid calls by convention
-                    && originalDeclaration is JetNamedFunction && originalDeclaration.isLocal()
+                    && originalDeclaration is KtNamedFunction && originalDeclaration.isLocal()
                     && (targetScope == null || originalDescriptor !in targetScope.asJetScope().getFunctions(originalDescriptor.name, NoLookupLocation.FROM_IDE))
 
             val descriptorToExtract = (if (extractThis) thisDescriptor else null) ?: originalDescriptor
@@ -721,10 +721,10 @@ private fun ExtractionData.inferParametersInfo(
                     receiverToExtract is ExpressionReceiver -> {
                         val receiverExpression = receiverToExtract.getExpression()
                         // If p.q has a smart-cast, then extract entire qualified expression
-                        if (refInfo.smartCast != null) receiverExpression.getParent() as JetExpression else receiverExpression
+                        if (refInfo.smartCast != null) receiverExpression.getParent() as KtExpression else receiverExpression
                     }
                     receiverToExtract.exists() && refInfo.smartCast == null -> null
-                    else -> (originalRef.getParent() as? JetThisExpression) ?: originalRef
+                    else -> (originalRef.getParent() as? KtThisExpression) ?: originalRef
                 }
 
                 val parameterType = suggestParameterType(extractFunctionRef, originalDescriptor, parameterExpression, receiverToExtract, resolvedCall, true)
@@ -737,10 +737,10 @@ private fun ExtractionData.inferParametersInfo(
                             }
                             else {
                                 val argumentExpr = (thisExpr ?: ref).getQualifiedExpressionForSelectorOrThis()
-                                if (argumentExpr is JetOperationReferenceExpression) {
+                                if (argumentExpr is KtOperationReferenceExpression) {
                                     val nameElement = argumentExpr.getReferencedNameElement()
                                     val nameElementType = nameElement.node.elementType
-                                    (nameElementType as? JetToken)?.let {
+                                    (nameElementType as? KtToken)?.let {
                                         OperatorConventions.getNameForOperationSymbol(it)?.asString()
                                     } ?: nameElement.getText()
                                 }
@@ -748,7 +748,7 @@ private fun ExtractionData.inferParametersInfo(
                                      ?: throw AssertionError("reference shouldn't be empty: code fragment = $codeFragmentText")
                             }
                     if (extractFunctionRef) {
-                        val receiverTypeText = (originalDeclaration as JetCallableDeclaration).getReceiverTypeReference()?.getText() ?: ""
+                        val receiverTypeText = (originalDeclaration as KtCallableDeclaration).getReceiverTypeReference()?.getText() ?: ""
                         argumentText = "$receiverTypeText::$argumentText"
                     }
 
@@ -790,7 +790,7 @@ private fun ExtractionData.inferParametersInfo(
     }
 
     val varNameValidator = NewDeclarationNameValidator(
-            commonParent.getNonStrictParentOfType<JetExpression>()!!,
+            commonParent.getNonStrictParentOfType<KtExpression>()!!,
             originalElements.firstOrNull(),
             NewDeclarationNameValidator.Target.VARIABLES
     )
@@ -809,7 +809,7 @@ private fun ExtractionData.inferParametersInfo(
         }
     }
 
-    for (typeToCheck in info.typeParameters.flatMapTo(HashSet<JetType>()) { it.collectReferencedTypes(bindingContext) }) {
+    for (typeToCheck in info.typeParameters.flatMapTo(HashSet<KtType>()) { it.collectReferencedTypes(bindingContext) }) {
         typeToCheck.processTypeIfExtractable(info.typeParameters, info.nonDenotableTypes, options, targetScope)
     }
 
@@ -818,18 +818,18 @@ private fun ExtractionData.inferParametersInfo(
 }
 
 private fun ExtractionData.checkDeclarationsMovingOutOfScope(
-        enclosingDeclaration: JetDeclaration,
+        enclosingDeclaration: KtDeclaration,
         controlFlow: ControlFlow,
         bindingContext: BindingContext
 ): ErrorMessage? {
-    val declarationsOutOfScope = HashSet<JetNamedDeclaration>()
+    val declarationsOutOfScope = HashSet<KtNamedDeclaration>()
     controlFlow.jumpOutputValue?.elementToInsertAfterCall?.accept(
-            object : JetTreeVisitorVoid() {
-                override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+            object : KtTreeVisitorVoid() {
+                override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
                     val target = expression.mainReference.resolve()
-                    if (target is JetNamedDeclaration
+                    if (target is KtNamedDeclaration
                         && target.isInsideOf(originalElements)
-                        && target.getStrictParentOfType<JetDeclaration>() == enclosingDeclaration) {
+                        && target.getStrictParentOfType<KtDeclaration>() == enclosingDeclaration) {
                         declarationsOutOfScope.add(target)
                     }
                 }
@@ -856,7 +856,7 @@ private fun ExtractionData.getLocalInstructions(pseudocode: Pseudocode): List<In
 
 fun ExtractionData.isVisibilityApplicable(): Boolean {
     return when (targetSibling.getParent()) {
-        is JetClassBody, is JetFile -> true
+        is KtClassBody, is KtFile -> true
         else -> false
     }
 }
@@ -864,8 +864,8 @@ fun ExtractionData.isVisibilityApplicable(): Boolean {
 fun ExtractionData.getDefaultVisibility(): String {
     if (!isVisibilityApplicable()) return ""
 
-    val parent = targetSibling.getStrictParentOfType<JetDeclaration>()
-    if (parent is JetClass && parent.isInterface()) return ""
+    val parent = targetSibling.getStrictParentOfType<KtDeclaration>()
+    if (parent is KtClass && parent.isInterface()) return ""
 
     return "private"
 }
@@ -917,12 +917,12 @@ fun ExtractionData.performAnalysis(): AnalysisResult {
         )
     }
 
-    val enclosingDeclaration = commonParent.getStrictParentOfType<JetDeclaration>()!!
+    val enclosingDeclaration = commonParent.getStrictParentOfType<KtDeclaration>()!!
     checkDeclarationsMovingOutOfScope(enclosingDeclaration, controlFlow, bindingContext)?.let { messages.add(it) }
 
     controlFlow.jumpOutputValue?.elementToInsertAfterCall?.accept(
-            object : JetTreeVisitorVoid() {
-                override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+            object : KtTreeVisitorVoid() {
+                override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
                     paramsInfo.originalRefToParameter[expression]?.let { it.refCount-- }
                 }
             }
@@ -951,13 +951,13 @@ fun ExtractionData.performAnalysis(): AnalysisResult {
     )
 }
 
-private fun ExtractionData.suggestFunctionNames(returnType: JetType): List<String> {
+private fun ExtractionData.suggestFunctionNames(returnType: KtType): List<String> {
     val functionNames = LinkedHashSet<String>()
 
     val validator =
             NewDeclarationNameValidator(
                     targetSibling.getParent(),
-                    if (targetSibling is JetClassInitializer) targetSibling.getParent() else targetSibling,
+                    if (targetSibling is KtClassInitializer) targetSibling.getParent() else targetSibling,
                     if (options.extractAsProperty) NewDeclarationNameValidator.Target.VARIABLES else NewDeclarationNameValidator.Target.FUNCTIONS_AND_CLASSES
             )
     if (!returnType.isDefault()) {
@@ -965,7 +965,7 @@ private fun ExtractionData.suggestFunctionNames(returnType: JetType): List<Strin
     }
 
     getExpressions().singleOrNull()?.let { expr ->
-        val property = expr.getStrictParentOfType<JetProperty>()
+        val property = expr.getStrictParentOfType<KtProperty>()
         if (property?.getInitializer() == expr) {
             property?.getName()?.let { functionNames.add(KotlinNameSuggester.suggestNameByName("get" + it.capitalize(), validator)) }
         }
@@ -974,17 +974,17 @@ private fun ExtractionData.suggestFunctionNames(returnType: JetType): List<Strin
     return functionNames.toList()
 }
 
-internal fun JetNamedDeclaration.getGeneratedBody() =
+internal fun KtNamedDeclaration.getGeneratedBody() =
         when (this) {
-            is JetNamedFunction -> getBodyExpression()
+            is KtNamedFunction -> getBodyExpression()
             else -> {
-                val property = this as JetProperty
+                val property = this as KtProperty
 
                 property.getGetter()?.getBodyExpression()?.let { return it }
                 property.getInitializer()?.let { return it }
                 // We assume lazy property here with delegate expression 'by Delegates.lazy { body }'
                 property.getDelegateExpression()?.let {
-                    val call = it.getCalleeExpressionIfAny()?.getParent() as? JetCallExpression
+                    val call = it.getCalleeExpressionIfAny()?.getParent() as? KtCallExpression
                     call?.getFunctionLiteralArguments()?.singleOrNull()?.getFunctionLiteral()?.getBodyExpression()
                 }
             }
@@ -1003,8 +1003,8 @@ fun ExtractableCodeDescriptor.validate(): ExtractableCodeDescriptorWithConflicts
             ExtractionGeneratorOptions(inTempFile = true, allowExpressionBody = false)
     ).generateDeclaration()
 
-    val valueParameterList = (result.declaration as? JetNamedFunction)?.getValueParameterList()
-    val typeParameterList = (result.declaration as? JetNamedFunction)?.getTypeParameterList()
+    val valueParameterList = (result.declaration as? KtNamedFunction)?.getValueParameterList()
+    val typeParameterList = (result.declaration as? KtNamedFunction)?.getTypeParameterList()
     val body = result.declaration.getGeneratedBody()
     val bindingContext = body.analyzeFully()
 
@@ -1013,18 +1013,18 @@ fun ExtractableCodeDescriptor.validate(): ExtractableCodeDescriptorWithConflicts
             if (resolveResult.declaration.isInsideOf(extractionData.originalElements)) continue
 
             val currentRefExpr = result.nameByOffset[originalOffset]?.let {
-                (it as? JetThisExpression)?.instanceReference ?: it as? JetSimpleNameExpression
+                (it as? KtThisExpression)?.instanceReference ?: it as? KtSimpleNameExpression
             } ?: continue
 
-            if (currentRefExpr.getParent() is JetThisExpression) continue
+            if (currentRefExpr.getParent() is KtThisExpression) continue
 
             val diagnostics = bindingContext.getDiagnostics().forElement(currentRefExpr)
 
             val currentDescriptor = bindingContext[BindingContext.REFERENCE_TARGET, currentRefExpr]
             val currentTarget =
                     currentDescriptor?.let { DescriptorToSourceUtilsIde.getAnyDeclaration(extractionData.project, it) } as? PsiNamedElement
-            if (currentTarget is JetParameter && currentTarget.getParent() == valueParameterList) continue
-            if (currentTarget is JetTypeParameter && currentTarget.getParent() == typeParameterList) continue
+            if (currentTarget is KtParameter && currentTarget.getParent() == valueParameterList) continue
+            if (currentTarget is KtTypeParameter && currentTarget.getParent() == typeParameterList) continue
             if (currentDescriptor is LocalVariableDescriptor
                 && parameters.any { it.mirrorVarName == currentDescriptor.getName().asString() }) continue
 
@@ -1052,8 +1052,8 @@ fun ExtractableCodeDescriptor.validate(): ExtractableCodeDescriptorWithConflicts
     }
 
     result.declaration.accept(
-            object : JetTreeVisitorVoid() {
-                override fun visitUserType(userType: JetUserType) {
+            object : KtTreeVisitorVoid() {
+                override fun visitUserType(userType: KtUserType) {
                     val refExpr = userType.getReferenceExpression() ?: return
                     val declaration = refExpr.mainReference.resolve() as? PsiNamedElement ?: return
                     val diagnostics = bindingContext.getDiagnostics().forElement(refExpr)
@@ -1062,7 +1062,7 @@ fun ExtractableCodeDescriptor.validate(): ExtractableCodeDescriptorWithConflicts
                     }
                 }
 
-                override fun visitJetElement(element: JetElement) {
+                override fun visitJetElement(element: KtElement) {
                     if (element == body) {
                         validateBody()
                         return
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractorUtil.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractorUtil.kt
index b4e90d7b38f..110b7bcf1ef 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractorUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractorUtil.kt
@@ -42,7 +42,7 @@ import org.jetbrains.kotlin.idea.util.psi.patternMatching.UnificationResult.Stro
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.UnificationResult.WeaklyMatched
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.UnifierParameter
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.JetPsiFactory.CallableBuilder
+import org.jetbrains.kotlin.psi.KtPsiFactory.CallableBuilder
 import org.jetbrains.kotlin.psi.codeFragmentUtil.DEBUG_TYPE_REFERENCE_STRING
 import org.jetbrains.kotlin.psi.codeFragmentUtil.debugTypeInfo
 import org.jetbrains.kotlin.psi.codeFragmentUtil.suppressDiagnosticsInDebugMode
@@ -50,7 +50,7 @@ import org.jetbrains.kotlin.psi.psiUtil.*
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.callUtil.getCalleeExpressionIfAny
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.isFlexible
 import org.jetbrains.kotlin.types.typeUtil.builtIns
 import java.util.ArrayList
@@ -84,7 +84,7 @@ fun ExtractionGeneratorConfiguration.getDeclarationText(
                 }
         )
 
-        fun JetType.typeAsString(): String {
+        fun KtType.typeAsString(): String {
             return if (descriptor.extractionData.options.allowSpecialClassNames && isSpecial()) DEBUG_TYPE_REFERENCE_STRING else descriptorRenderer.renderType(this)
         }
 
@@ -127,20 +127,20 @@ fun ExtractionGeneratorConfiguration.getDeclarationText(
     }
 }
 
-fun JetType.isSpecial(): Boolean {
+fun KtType.isSpecial(): Boolean {
     val classDescriptor = this.constructor.declarationDescriptor as? ClassDescriptor ?: return false
     return classDescriptor.name.isSpecial || DescriptorUtils.isLocal(classDescriptor)
 }
 
-fun createNameCounterpartMap(from: JetElement, to: JetElement): Map<JetSimpleNameExpression, JetSimpleNameExpression> {
-    val map = HashMap<JetSimpleNameExpression, JetSimpleNameExpression>()
+fun createNameCounterpartMap(from: KtElement, to: KtElement): Map<KtSimpleNameExpression, KtSimpleNameExpression> {
+    val map = HashMap<KtSimpleNameExpression, KtSimpleNameExpression>()
 
     val fromOffset = from.getTextRange()!!.getStartOffset()
     from.accept(
-            object : JetTreeVisitorVoid() {
-                override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+            object : KtTreeVisitorVoid() {
+                override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
                     val offset = expression.getTextRange()!!.getStartOffset() - fromOffset
-                    val newExpression = to.findElementAt(offset)?.getNonStrictParentOfType<JetSimpleNameExpression>()
+                    val newExpression = to.findElementAt(offset)?.getNonStrictParentOfType<KtSimpleNameExpression>()
                     assert(newExpression != null) { "Couldn't find expression at $offset in '${to.getText()}'" }
 
                     map[expression] = newExpression!!
@@ -230,23 +230,23 @@ private fun ExtractableCodeDescriptor.getOccurrenceContainer(): PsiElement? {
 
 private fun makeCall(
         extractableDescriptor: ExtractableCodeDescriptor,
-        declaration: JetNamedDeclaration,
+        declaration: KtNamedDeclaration,
         controlFlow: ControlFlow,
         rangeToReplace: JetPsiRange,
         arguments: List<String>) {
-    fun insertCall(anchor: PsiElement, wrappedCall: JetExpression) {
-        val firstExpression = rangeToReplace.elements.firstOrNull { it is JetExpression } as? JetExpression
+    fun insertCall(anchor: PsiElement, wrappedCall: KtExpression) {
+        val firstExpression = rangeToReplace.elements.firstOrNull { it is KtExpression } as? KtExpression
         if (firstExpression?.isFunctionLiteralOutsideParentheses() ?: false) {
-            val functionLiteralArgument = firstExpression?.getStrictParentOfType<JetFunctionLiteralArgument>()!!
+            val functionLiteralArgument = firstExpression?.getStrictParentOfType<KtFunctionLiteralArgument>()!!
             functionLiteralArgument.moveInsideParenthesesAndReplaceWith(wrappedCall, extractableDescriptor.originalContext)
             return
         }
 
-        if (anchor is JetOperationReferenceExpression) {
-            val operationExpression = anchor.parent as? JetOperationExpression ?: return
+        if (anchor is KtOperationReferenceExpression) {
+            val operationExpression = anchor.parent as? KtOperationExpression ?: return
             val newNameExpression = when (operationExpression) {
-                is JetUnaryExpression -> OperatorToFunctionIntention.convert(operationExpression).second
-                is JetBinaryExpression -> {
+                is KtUnaryExpression -> OperatorToFunctionIntention.convert(operationExpression).second
+                is KtBinaryExpression -> {
                     InfixCallToOrdinaryIntention.convert(operationExpression).getCalleeExpressionIfAny()
                 }
                 else -> null
@@ -272,7 +272,7 @@ private fun makeCall(
 
     val calleeName = declaration.getName()
     val callText = when (declaration) {
-        is JetNamedFunction -> {
+        is KtNamedFunction -> {
             val argumentsText = arguments.joinToString(separator = ", ", prefix = "(", postfix = ")")
             val typeArguments = extractableDescriptor.typeParameters.map { it.originalDeclaration.name }
             val typeArgumentsText = with(typeArguments) {
@@ -283,10 +283,10 @@ private fun makeCall(
         else -> calleeName
     }
 
-    val anchorInBlock = sequence(anchor) { it.getParent() }.firstOrNull { it.getParent() is JetBlockExpression }
-    val block = (anchorInBlock?.getParent() as? JetBlockExpression) ?: anchorParent
+    val anchorInBlock = sequence(anchor) { it.getParent() }.firstOrNull { it.getParent() is KtBlockExpression }
+    val block = (anchorInBlock?.getParent() as? KtBlockExpression) ?: anchorParent
 
-    val psiFactory = JetPsiFactory(anchor.getProject())
+    val psiFactory = KtPsiFactory(anchor.getProject())
     val newLine = psiFactory.createNewLine()
 
     if (controlFlow.outputValueBoxer is AsTuple && controlFlow.outputValues.size() > 1 && controlFlow.outputValues.all { it is Initializer }) {
@@ -294,7 +294,7 @@ private fun makeCall(
         val isVar = declarationsToMerge.first().isVar()
         if (declarationsToMerge.all { it.isVar() == isVar }) {
             controlFlow.declarationsToCopy.subtract(declarationsToMerge).forEach {
-                block.addBefore(psiFactory.createDeclaration<JetDeclaration>(it.getText()!!), anchorInBlock) as JetDeclaration
+                block.addBefore(psiFactory.createDeclaration<KtDeclaration>(it.getText()!!), anchorInBlock) as KtDeclaration
                 block.addBefore(newLine, anchorInBlock)
             }
 
@@ -320,10 +320,10 @@ private fun makeCall(
                 controlFlow.outputValueBoxer.getUnboxingExpressions(resultVal)
             }
 
-    val copiedDeclarations = HashMap<JetDeclaration, JetDeclaration>()
+    val copiedDeclarations = HashMap<KtDeclaration, KtDeclaration>()
     for (decl in controlFlow.declarationsToCopy) {
-        val declCopy = psiFactory.createDeclaration<JetDeclaration>(decl.getText()!!)
-        copiedDeclarations[decl] = block.addBefore(declCopy, anchorInBlock) as JetDeclaration
+        val declCopy = psiFactory.createDeclaration<KtDeclaration>(decl.getText()!!)
+        copiedDeclarations[decl] = block.addBefore(declCopy, anchorInBlock) as KtDeclaration
         block.addBefore(newLine, anchorInBlock)
     }
 
@@ -336,7 +336,7 @@ private fun makeCall(
         return when (outputValue) {
             is OutputValue.ExpressionValue -> {
                 val exprText = if (outputValue.callSiteReturn) {
-                    val firstReturn = outputValue.originalExpressions.filterIsInstance<JetReturnExpression>().firstOrNull()
+                    val firstReturn = outputValue.originalExpressions.filterIsInstance<KtReturnExpression>().firstOrNull()
                     val label = firstReturn?.getTargetLabel()?.getText() ?: ""
                     "return$label $callText"
                 }
@@ -370,7 +370,7 @@ private fun makeCall(
             }
 
             is Initializer -> {
-                val newProperty = copiedDeclarations[outputValue.initializedDeclaration] as JetProperty
+                val newProperty = copiedDeclarations[outputValue.initializedDeclaration] as KtProperty
                 newProperty.setInitializer(psiFactory.createExpression(callText))
                 Collections.emptyList()
             }
@@ -398,7 +398,7 @@ private fun makeCall(
         if (!inlinableCall) {
             block.addBefore(newLine, anchorInBlock)
         }
-        insertCall(anchor, wrapCall(it, unboxingExpressions[it]!!).first() as JetExpression)
+        insertCall(anchor, wrapCall(it, unboxingExpressions[it]!!).first() as KtExpression)
     }
 
     if (anchor.isValid()) {
@@ -407,12 +407,12 @@ private fun makeCall(
 }
 
 fun ExtractionGeneratorConfiguration.generateDeclaration(
-        declarationToReplace: JetNamedDeclaration? = null
+        declarationToReplace: KtNamedDeclaration? = null
 ): ExtractionResult{
-    val psiFactory = JetPsiFactory(descriptor.extractionData.originalFile)
-    val nameByOffset = HashMap<Int, JetElement>()
+    val psiFactory = KtPsiFactory(descriptor.extractionData.originalFile)
+    val nameByOffset = HashMap<Int, KtElement>()
 
-    fun createDeclaration(): JetNamedDeclaration {
+    fun createDeclaration(): KtNamedDeclaration {
         return with(descriptor.extractionData) {
             if (generatorOptions.inTempFile) {
                 createTemporaryDeclaration("${getDeclarationText()}\n")
@@ -423,7 +423,7 @@ fun ExtractionGeneratorConfiguration.generateDeclaration(
         }
     }
 
-    fun getReturnArguments(resultExpression: JetExpression?): List<String> {
+    fun getReturnArguments(resultExpression: KtExpression?): List<String> {
         return descriptor.controlFlow.outputValues
                 .map {
                     when (it) {
@@ -438,12 +438,12 @@ fun ExtractionGeneratorConfiguration.generateDeclaration(
     }
 
     fun replaceWithReturn(
-            originalExpression: JetExpression,
-            replacingExpression: JetReturnExpression,
-            expressionToUnifyWith: JetExpression?
+            originalExpression: KtExpression,
+            replacingExpression: KtReturnExpression,
+            expressionToUnifyWith: KtExpression?
     ) {
         val currentResultExpression =
-                if (originalExpression is JetReturnExpression) originalExpression.getReturnedExpression() else originalExpression
+                if (originalExpression is KtReturnExpression) originalExpression.getReturnedExpression() else originalExpression
         if (currentResultExpression == null) return
 
         val newResultExpression = descriptor.controlFlow.defaultOutputValue?.let {
@@ -458,10 +458,10 @@ fun ExtractionGeneratorConfiguration.generateDeclaration(
         nameByOffset.entrySet().forEach { e -> counterpartMap[e.getValue()]?.let { e.setValue(it) } }
     }
 
-    fun getCounterparts<T : JetExpression>(originalExpressions: Collection<T>,
-                                           body: JetExpression,
-                                           bodyOffset: Int,
-                                           file: PsiFile): List<T> {
+    fun getCounterparts<T : KtExpression>(originalExpressions: Collection<T>,
+                                                                   body: KtExpression,
+                                                                   bodyOffset: Int,
+                                                                   file: PsiFile): List<T> {
         return originalExpressions.map { originalExpression ->
             val offsetInBody = originalExpression.getTextRange()!!.getStartOffset() - descriptor.extractionData.originalStartOffset!!
             file.findElementAt(bodyOffset + offsetInBody)?.getNonStrictParentOfType(originalExpression.javaClass)
@@ -469,11 +469,11 @@ fun ExtractionGeneratorConfiguration.generateDeclaration(
         }
     }
 
-    fun adjustDeclarationBody(declaration: JetNamedDeclaration) {
+    fun adjustDeclarationBody(declaration: KtNamedDeclaration) {
         val body = declaration.getGeneratedBody()
 
-        val exprReplacementMap = HashMap<JetElement, (ExtractableCodeDescriptor, JetElement) -> JetElement>()
-        val originalOffsetByExpr = LinkedHashMap<JetElement, Int>()
+        val exprReplacementMap = HashMap<KtElement, (ExtractableCodeDescriptor, KtElement) -> KtElement>()
+        val originalOffsetByExpr = LinkedHashMap<KtElement, Int>()
 
         val bodyOffset = body.getBlockContentOffset()
         val file = body.getContainingFile()!!
@@ -483,7 +483,7 @@ fun ExtractionGeneratorConfiguration.generateDeclaration(
          * before calls/types themselves
          */
         for ((offsetInBody, resolveResult) in descriptor.extractionData.refOffsetToDeclaration.entrySet().sortedByDescending { it.key }) {
-            val expr = file.findElementAt(bodyOffset + offsetInBody)?.getNonStrictParentOfType<JetSimpleNameExpression>()
+            val expr = file.findElementAt(bodyOffset + offsetInBody)?.getNonStrictParentOfType<KtSimpleNameExpression>()
             assert(expr != null) { "Couldn't find expression at $offsetInBody in '${body.getText()}'" }
 
             originalOffsetByExpr[expr!!] = offsetInBody
@@ -493,11 +493,11 @@ fun ExtractionGeneratorConfiguration.generateDeclaration(
             }
         }
 
-        val replacingReturn: JetExpression?
-        val expressionsToReplaceWithReturn: List<JetElement>
+        val replacingReturn: KtExpression?
+        val expressionsToReplaceWithReturn: List<KtElement>
 
         val returnsForLabelRemoval = descriptor.controlFlow.outputValues
-                .flatMapTo(ArrayList<JetReturnExpression>()) { it.originalExpressions.filterIsInstance<JetReturnExpression>() }
+                .flatMapTo(ArrayList<KtReturnExpression>()) { it.originalExpressions.filterIsInstance<KtReturnExpression>() }
 
         val jumpValue = descriptor.controlFlow.jumpOutputValue
         if (jumpValue != null) {
@@ -526,7 +526,7 @@ fun ExtractionGeneratorConfiguration.generateDeclaration(
 
         if (generatorOptions.target == ExtractionTarget.PROPERTY_WITH_INITIALIZER) return
 
-        if (body !is JetBlockExpression) throw AssertionError("Block body expected: ${descriptor.extractionData.codeFragmentText}")
+        if (body !is KtBlockExpression) throw AssertionError("Block body expected: ${descriptor.extractionData.codeFragmentText}")
 
         val firstExpression = body.getStatements().firstOrNull()
         if (firstExpression != null) {
@@ -541,13 +541,13 @@ fun ExtractionGeneratorConfiguration.generateDeclaration(
         val defaultValue = descriptor.controlFlow.defaultOutputValue
 
         val lastExpression = body.getStatements().lastOrNull()
-        if (lastExpression is JetReturnExpression) return
+        if (lastExpression is KtReturnExpression) return
 
         val (defaultExpression, expressionToUnifyWith) =
                 if (!generatorOptions.inTempFile && defaultValue != null && descriptor.controlFlow.outputValueBoxer.boxingRequired && lastExpression!!.isMultiLine()) {
                     val varNameValidator = NewDeclarationNameValidator(body, lastExpression, NewDeclarationNameValidator.Target.VARIABLES)
                     val resultVal = KotlinNameSuggester.suggestNamesByType(defaultValue.valueType, varNameValidator, null).first()
-                    val newDecl = body.addBefore(psiFactory.createDeclaration("val $resultVal = ${lastExpression!!.getText()}"), lastExpression) as JetProperty
+                    val newDecl = body.addBefore(psiFactory.createDeclaration("val $resultVal = ${lastExpression!!.getText()}"), lastExpression) as KtProperty
                     body.addBefore(psiFactory.createNewLine(), lastExpression)
                     psiFactory.createExpression(resultVal) to newDecl.getInitializer()!!
                 }
@@ -579,27 +579,27 @@ fun ExtractionGeneratorConfiguration.generateDeclaration(
         if (generatorOptions.allowExpressionBody) {
             val convertToExpressionBody = ConvertToExpressionBodyIntention()
             val bodyExpression = body.getStatements().singleOrNull()
-            val bodyOwner = body.getParent() as JetDeclarationWithBody
+            val bodyOwner = body.getParent() as KtDeclarationWithBody
             if (bodyExpression != null && !bodyExpression.isMultiLine() && convertToExpressionBody.isApplicableTo(bodyOwner)) {
                 convertToExpressionBody.applyTo(bodyOwner, !descriptor.returnType.isFlexible())
             }
         }
     }
 
-    fun insertDeclaration(declaration: JetNamedDeclaration, anchor: PsiElement): JetNamedDeclaration {
-        declarationToReplace?.let { return it.replace(declaration) as JetNamedDeclaration }
+    fun insertDeclaration(declaration: KtNamedDeclaration, anchor: PsiElement): KtNamedDeclaration {
+        declarationToReplace?.let { return it.replace(declaration) as KtNamedDeclaration }
 
         return with(descriptor.extractionData) {
             val targetContainer = anchor.getParent()!!
             val emptyLines = psiFactory.createWhiteSpace("\n\n")
             if (insertBefore) {
-                val declarationInFile = targetContainer.addBefore(declaration, anchor) as JetNamedDeclaration
+                val declarationInFile = targetContainer.addBefore(declaration, anchor) as KtNamedDeclaration
                 targetContainer.addBefore(emptyLines, anchor)
 
                 declarationInFile
             }
             else {
-                val declarationInFile = targetContainer.addAfter(declaration, anchor) as JetNamedDeclaration
+                val declarationInFile = targetContainer.addAfter(declaration, anchor) as KtNamedDeclaration
                 targetContainer.addAfter(emptyLines, anchor)
 
                 declarationInFile
@@ -629,7 +629,7 @@ fun ExtractionGeneratorConfiguration.generateDeclaration(
     val declaration = createDeclaration().let { if (shouldInsert) insertDeclaration(it, anchor) else it }
     adjustDeclarationBody(declaration)
 
-    if (declaration is JetNamedFunction && declaration.getContainingJetFile().suppressDiagnosticsInDebugMode) {
+    if (declaration is KtNamedFunction && declaration.getContainingJetFile().suppressDiagnosticsInDebugMode) {
         declaration.getReceiverTypeReference()?.debugTypeInfo = descriptor.receiverParameter?.getParameterType(true)
 
         for ((i, param) in declaration.getValueParameters().withIndex()) {
@@ -654,7 +654,7 @@ fun ExtractionGeneratorConfiguration.generateDeclaration(
 
     if (descriptor.typeParameters.isNotEmpty()) {
         for (ref in ReferencesSearch.search(declaration, LocalSearchScope(descriptor.getOccurrenceContainer()!!))) {
-            val typeArgumentList = (ref.element.parent as? JetCallExpression)?.typeArgumentList ?: continue
+            val typeArgumentList = (ref.element.parent as? KtCallExpression)?.typeArgumentList ?: continue
             if (RemoveExplicitTypeArgumentsIntention.isApplicableTo(typeArgumentList, false)) {
                 typeArgumentList.delete()
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinInplaceParameterIntroducer.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinInplaceParameterIntroducer.kt
index 2f60ddbc527..4c7119ae4ea 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinInplaceParameterIntroducer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinInplaceParameterIntroducer.kt
@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.psi.psiUtil.getValueParameterList
 import org.jetbrains.kotlin.psi.psiUtil.getValueParameters
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.typeUtil.supertypes
 import org.jetbrains.kotlin.utils.addToStdlib.singletonList
 import java.awt.Color
@@ -47,15 +47,15 @@ import javax.swing.JCheckBox
 
 public class KotlinInplaceParameterIntroducer(
         val originalDescriptor: IntroduceParameterDescriptor,
-        val parameterType: JetType,
+        val parameterType: KtType,
         val suggestedNames: Array<out String>,
         project: Project,
         editor: Editor
-): AbstractKotlinInplaceIntroducer<JetParameter>(
+): AbstractKotlinInplaceIntroducer<KtParameter>(
         null,
-        originalDescriptor.originalRange.elements.single() as JetExpression,
+        originalDescriptor.originalRange.elements.single() as KtExpression,
         originalDescriptor.occurrencesToReplace
-                .map { it.elements.single() as JetExpression }
+                .map { it.elements.single() as KtExpression }
                 .filterNotNull()
                 .toTypedArray(),
         INTRODUCE_PARAMETER,
@@ -95,7 +95,7 @@ public class KotlinInplaceParameterIntroducer(
         }
     }
 
-    private inner class Preview(addedParameter: JetParameter?, currentName: String?) {
+    private inner class Preview(addedParameter: KtParameter?, currentName: String?) {
         private val _rangesToRemove = ArrayList<TextRange>()
 
         var addedRange: TextRange? = null
@@ -117,7 +117,7 @@ public class KotlinInplaceParameterIntroducer(
             val builder = StringBuilder()
 
             with(descriptor) {
-                (callable as? JetFunction)?.getReceiverTypeReference()?.let { receiverTypeRef ->
+                (callable as? KtFunction)?.getReceiverTypeReference()?.let { receiverTypeRef ->
                     builder.append(receiverTypeRef.getText()).append('.')
                     if (!descriptor.withDefaultValue && receiverTypeRef in parametersToRemove) {
                         _rangesToRemove.add(TextRange(0, builder.length()))
@@ -200,22 +200,22 @@ public class KotlinInplaceParameterIntroducer(
 
     override fun getVariable() = originalDescriptor.callable.getValueParameters().lastOrNull()
 
-    override fun suggestNames(replaceAll: Boolean, variable: JetParameter?) = suggestedNames
+    override fun suggestNames(replaceAll: Boolean, variable: KtParameter?) = suggestedNames
 
-    override fun createFieldToStartTemplateOn(replaceAll: Boolean, names: Array<out String>): JetParameter? {
+    override fun createFieldToStartTemplateOn(replaceAll: Boolean, names: Array<out String>): KtParameter? {
         return runWriteAction {
             with(descriptor) {
                 val parameterList = callable.getValueParameterList()
-                                    ?: (callable as JetClass).createPrimaryConstructorParameterListIfAbsent()
-                val parameter = JetPsiFactory(myProject).createParameter("$newParameterName: $newParameterTypeText")
+                                    ?: (callable as KtClass).createPrimaryConstructorParameterListIfAbsent()
+                val parameter = KtPsiFactory(myProject).createParameter("$newParameterName: $newParameterTypeText")
                 parameterList.addParameter(parameter)
             }
         }
     }
 
-    override fun deleteTemplateField(psiField: JetParameter) {
+    override fun deleteTemplateField(psiField: KtParameter) {
         if (psiField.isValid()) {
-            (psiField.getParent() as? JetParameterList)?.removeParameter(psiField)
+            (psiField.getParent() as? KtParameterList)?.removeParameter(psiField)
         }
     }
 
@@ -227,7 +227,7 @@ public class KotlinInplaceParameterIntroducer(
 
     override fun getComponent() = myWholePanel
 
-    override fun updateTitle(addedParameter: JetParameter?, currentName: String?) {
+    override fun updateTitle(addedParameter: KtParameter?, currentName: String?) {
         val preview = Preview(addedParameter, currentName)
 
         val document = getPreviewEditor().getDocument()
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterDialog.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterDialog.kt
index a21bfdbe1ea..c76c6e0826f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterDialog.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterDialog.kt
@@ -29,7 +29,7 @@ import com.intellij.ui.NonFocusableCheckBox
 import com.intellij.ui.TitledSeparator
 import com.intellij.usageView.BaseUsageViewDescriptor
 import com.intellij.usageView.UsageInfo
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.core.refactoring.isMultiLine
 import org.jetbrains.kotlin.idea.core.refactoring.runRefactoringWithPostprocessing
 import org.jetbrains.kotlin.idea.core.refactoring.validateElement
@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.*
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.AnalyzingUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.awt.GridBagConstraints
 import java.awt.GridBagLayout
 import java.awt.Insets
@@ -56,7 +56,7 @@ public class KotlinIntroduceParameterDialog private constructor(
         val descriptor: IntroduceParameterDescriptor,
         val lambdaExtractionDescriptor: ExtractableCodeDescriptor?,
         nameSuggestions: Array<String>,
-        val typeSuggestions: List<JetType>,
+        val typeSuggestions: List<KtType>,
         val helper: KotlinIntroduceParameterHelper
 ): RefactoringDialog(project, true) {
     constructor(
@@ -64,7 +64,7 @@ public class KotlinIntroduceParameterDialog private constructor(
             editor: Editor,
             descriptor: IntroduceParameterDescriptor,
             nameSuggestions: Array<String>,
-            typeSuggestions: List<JetType>,
+            typeSuggestions: List<KtType>,
             helper: KotlinIntroduceParameterHelper
     ): this(project, editor, descriptor, null, nameSuggestions, typeSuggestions, helper)
 
@@ -87,11 +87,11 @@ public class KotlinIntroduceParameterDialog private constructor(
             .map { IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType(it) }
             .toTypedArray()
 
-    private val nameField = NameSuggestionsField(nameSuggestions, project, JetFileType.INSTANCE)
-    private val typeField = NameSuggestionsField(typeNameSuggestions, project, JetFileType.INSTANCE)
+    private val nameField = NameSuggestionsField(nameSuggestions, project, KotlinFileType.INSTANCE)
+    private val typeField = NameSuggestionsField(typeNameSuggestions, project, KotlinFileType.INSTANCE)
     private var replaceAllCheckBox: JCheckBox? = null
     private var defaultValueCheckBox: JCheckBox? = null
-    private val removeParamsCheckBoxes = LinkedHashMap<JCheckBox, JetElement>(descriptor.parametersToRemove.size())
+    private val removeParamsCheckBoxes = LinkedHashMap<JCheckBox, KtElement>(descriptor.parametersToRemove.size())
     private var parameterTablePanel: KotlinParameterTablePanel? = null
     private val commandName = if (lambdaExtractionDescriptor != null) INTRODUCE_LAMBDA_PARAMETER else INTRODUCE_PARAMETER
 
@@ -219,7 +219,7 @@ public class KotlinIntroduceParameterDialog private constructor(
         }
 
         for (parameter in descriptor.parametersToRemove) {
-            val removeWhat = if (parameter is JetParameter) "parameter '${parameter.getName()}'" else "receiver"
+            val removeWhat = if (parameter is KtParameter) "parameter '${parameter.getName()}'" else "receiver"
             val cb = NonFocusableCheckBox("Remove $removeWhat no longer used")
 
             removeParamsCheckBoxes[cb] = parameter
@@ -234,7 +234,7 @@ public class KotlinIntroduceParameterDialog private constructor(
     override fun createCenterPanel() = null
 
     override fun canRun() {
-        val psiFactory = JetPsiFactory(myProject)
+        val psiFactory = KtPsiFactory(myProject)
         psiFactory.createSimpleName(nameField.getEnteredName()).validateElement("Invalid parameter name")
         psiFactory.createType(typeField.getEnteredName()).validateElement("Invalid parameter type")
     }
@@ -249,8 +249,8 @@ public class KotlinIntroduceParameterDialog private constructor(
                     override fun findUsages() = UsageInfo.EMPTY_ARRAY
 
                     override fun performRefactoring(usages: Array<out UsageInfo>) {
-                        fun createLambdaForArgument(function: JetFunction): JetExpression {
-                            val statement = (function.getBodyExpression() as JetBlockExpression).getStatements().single()
+                        fun createLambdaForArgument(function: KtFunction): KtExpression {
+                            val statement = (function.getBodyExpression() as KtBlockExpression).getStatements().single()
                             val space = if (statement.isMultiLine()) "\n" else " "
                             val parameters = function.getValueParameters()
                             val parametersText = if (parameters.isNotEmpty()) {
@@ -258,7 +258,7 @@ public class KotlinIntroduceParameterDialog private constructor(
                             } else ""
                             val text = "{$parametersText$space${statement.getText()}$space}"
 
-                            return JetPsiFactory(myProject).createExpression(text)
+                            return KtPsiFactory(myProject).createExpression(text)
                         }
 
                         val chosenName = nameField.getEnteredName()
@@ -282,7 +282,7 @@ public class KotlinIntroduceParameterDialog private constructor(
                                     allowExpressionBody = false
                             )
                             with (ExtractionGeneratorConfiguration(newDescriptor, options).generateDeclaration()) {
-                                val function = declaration as JetFunction
+                                val function = declaration as KtFunction
                                 val receiverType = function.getReceiverTypeReference()?.getText()
                                 val parameterTypes = function
                                         .getValueParameters()
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterHandler.kt
index 2e24c518f42..05bac53fa6d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterHandler.kt
@@ -67,15 +67,15 @@ import kotlin.test.fail
 
 public data class IntroduceParameterDescriptor(
         val originalRange: JetPsiRange,
-        val callable: JetNamedDeclaration,
+        val callable: KtNamedDeclaration,
         val callableDescriptor: FunctionDescriptor,
         val newParameterName: String,
         val newParameterTypeText: String,
-        val newArgumentValue: JetExpression,
+        val newArgumentValue: KtExpression,
         val withDefaultValue: Boolean,
-        val parametersUsages: MultiMap<JetElement, JetElement>,
+        val parametersUsages: MultiMap<KtElement, KtElement>,
         val occurrencesToReplace: List<JetPsiRange>,
-        val parametersToRemove: List<JetElement> = getParametersToRemove(withDefaultValue, parametersUsages, occurrencesToReplace),
+        val parametersToRemove: List<KtElement> = getParametersToRemove(withDefaultValue, parametersUsages, occurrencesToReplace),
         val occurrenceReplacer: IntroduceParameterDescriptor.(JetPsiRange) -> Unit = {}
 ) {
     val originalOccurrence: JetPsiRange
@@ -83,14 +83,14 @@ public data class IntroduceParameterDescriptor(
     val valVar: JetValVar
 
     init {
-        valVar = if (callable is JetClass) {
+        valVar = if (callable is KtClass) {
             val modifierIsUnnecessary: (PsiElement) -> Boolean = {
                 when {
                     it.getParent() != callable.getBody() ->
                         false
-                    it is JetClassInitializer ->
+                    it is KtClassInitializer ->
                         true
-                    it is JetProperty && it.getInitializer()?.getTextRange()?.intersects(originalRange.getTextRange()) ?: false ->
+                    it is KtProperty && it.getInitializer()?.getTextRange()?.intersects(originalRange.getTextRange()) ?: false ->
                         true
                     else ->
                         false
@@ -106,9 +106,9 @@ public data class IntroduceParameterDescriptor(
 
 fun getParametersToRemove(
         withDefaultValue: Boolean,
-        parametersUsages: MultiMap<JetElement, JetElement>,
+        parametersUsages: MultiMap<KtElement, KtElement>,
         occurrencesToReplace: List<JetPsiRange>
-): List<JetElement> {
+): List<KtElement> {
     if (withDefaultValue) return Collections.emptyList()
 
     val occurrenceRanges = occurrencesToReplace.map { it.getTextRange() }
@@ -131,7 +131,7 @@ fun IntroduceParameterDescriptor.performRefactoring() {
                         val withReceiver = methodDescriptor.receiver != null
                         parametersToRemove
                                 .map {
-                                    if (it is JetParameter) {
+                                    if (it is KtParameter) {
                                         parameters.indexOf(it) + if (withReceiver) 1 else 0
                                     } else 0
                                 }
@@ -167,7 +167,7 @@ fun IntroduceParameterDescriptor.performRefactoring() {
     }
 }
 
-private fun isObjectOrNonInnerClass(e: PsiElement): Boolean = e is JetObjectDeclaration || (e is JetClass && !e.isInner())
+private fun isObjectOrNonInnerClass(e: PsiElement): Boolean = e is KtObjectDeclaration || (e is KtClass && !e.isInner())
 
 fun selectNewParameterContext(
         editor: Editor,
@@ -186,8 +186,8 @@ fun selectNewParameterContext(
 
                 (if (stopAt != null) parent.parents.takeWhile { it != stopAt } else parents)
                         .filter {
-                            ((it is JetClass && !it.isInterface() && it !is JetEnumEntry) || it is JetNamedFunction || it is JetSecondaryConstructor) &&
-                            ((it as JetNamedDeclaration).getValueParameterList() != null || it.getNameIdentifier() != null)
+                            ((it is KtClass && !it.isInterface() && it !is KtEnumEntry) || it is KtNamedFunction || it is KtSecondaryConstructor) &&
+                            ((it as KtNamedDeclaration).getValueParameterList() != null || it.getNameIdentifier() != null)
                         }
                         .toList()
             },
@@ -204,7 +204,7 @@ public interface KotlinIntroduceParameterHelper {
 public open class KotlinIntroduceParameterHandler(
         val helper: KotlinIntroduceParameterHelper = KotlinIntroduceParameterHelper.Default
 ): KotlinIntroduceHandlerBase() {
-    open fun invoke(project: Project, editor: Editor, expression: JetExpression, targetParent: JetNamedDeclaration) {
+    open fun invoke(project: Project, editor: Editor, expression: KtExpression, targetParent: KtNamedDeclaration) {
         val context = expression.analyze()
 
         val expressionType = context.getType(expression)
@@ -227,8 +227,8 @@ public open class KotlinIntroduceParameterHandler(
         val replacementType = expressionType.approximateWithResolvableType(targetParent.getResolutionScope(context, targetParent.getResolutionFacade()), false)
 
         val body = when (targetParent) {
-                       is JetFunction -> targetParent.getBodyExpression()
-                       is JetClass -> targetParent.getBody()
+                       is KtFunction -> targetParent.getBodyExpression()
+                       is KtClass -> targetParent.getBody()
                        else -> null
                    } ?: throw AssertionError("Body element is not found: ${targetParent.getElementTextWithContext()}")
         val nameValidator = NewDeclarationNameValidator(body, sequenceOf(body), NewDeclarationNameValidator.Target.VARIABLES)
@@ -237,7 +237,7 @@ public open class KotlinIntroduceParameterHandler(
         val parametersUsages = findInternalUsagesOfParametersAndReceiver(targetParent, functionDescriptor)
 
         val forbiddenRanges =
-                if (targetParent is JetClass) {
+                if (targetParent is KtClass) {
                     targetParent.getDeclarations().filter { isObjectOrNonInnerClass(it) }.map { it.getTextRange() }
                 }
                 else {
@@ -252,10 +252,10 @@ public open class KotlinIntroduceParameterHandler(
                 .map {
                     val matchedElement = it.range.elements.singleOrNull()
                     when (matchedElement) {
-                        is JetExpression -> matchedElement
-                        is JetStringTemplateEntryWithExpression -> matchedElement.getExpression()
+                        is KtExpression -> matchedElement
+                        is KtStringTemplateEntryWithExpression -> matchedElement.getExpression()
                         else -> null
-                    } as? JetExpression
+                    } as? KtExpression
                 }
                 .filterNotNull()
                 .map { it.toRange() }
@@ -266,12 +266,12 @@ public open class KotlinIntroduceParameterHandler(
                 fun() {
                     val isTestMode = ApplicationManager.getApplication().isUnitTestMode()
                     val haveLambdaArgumentsToReplace = occurrencesToReplace.any {
-                        it.elements.any { it is JetFunctionLiteralExpression && it.parent is JetFunctionLiteralArgument }
+                        it.elements.any { it is KtFunctionLiteralExpression && it.parent is KtFunctionLiteralArgument }
                     }
                     val inplaceIsAvailable = editor.settings.isVariableInplaceRenameEnabled && !isTestMode && !haveLambdaArgumentsToReplace
 
-                    val originalExpression = JetPsiUtil.safeDeparenthesize(expression)
-                    val psiFactory = JetPsiFactory(project)
+                    val originalExpression = KtPsiUtil.safeDeparenthesize(expression)
+                    val psiFactory = KtPsiFactory(project)
                     val introduceParameterDescriptor =
                             helper.configure(
                                     IntroduceParameterDescriptor(
@@ -285,11 +285,11 @@ public open class KotlinIntroduceParameterHandler(
                                             parametersUsages = parametersUsages,
                                             occurrencesToReplace = occurrencesToReplace,
                                             occurrenceReplacer = {
-                                                val expressionToReplace = it.elements.single() as JetExpression
+                                                val expressionToReplace = it.elements.single() as KtExpression
                                                 val replacingExpression = psiFactory.createExpression(newParameterName)
                                                 if (expressionToReplace.isFunctionLiteralOutsideParentheses()) {
                                                     expressionToReplace
-                                                            .getStrictParentOfType<JetFunctionLiteralArgument>()!!
+                                                            .getStrictParentOfType<KtFunctionLiteralArgument>()!!
                                                             .moveInsideParenthesesAndReplaceWith(replacingExpression, context)
                                                 }
                                                 else {
@@ -333,11 +333,11 @@ public open class KotlinIntroduceParameterHandler(
             return
         }
 
-        if (file !is JetFile) return
+        if (file !is KtFile) return
         selectNewParameterContext(editor, file) { elements, targetParent ->
-            val expression = ((elements.singleOrNull() as? JetBlockExpression)?.getStatements() ?: elements).singleOrNull()
-            if (expression is JetExpression) {
-                invoke(project, editor, expression, targetParent as JetNamedDeclaration)
+            val expression = ((elements.singleOrNull() as? KtBlockExpression)?.getStatements() ?: elements).singleOrNull()
+            if (expression is KtExpression) {
+                invoke(project, editor, expression, targetParent as KtNamedDeclaration)
             }
             else {
                 showErrorHintByKey(project, editor, "cannot.refactor.no.expression", INTRODUCE_PARAMETER)
@@ -350,7 +350,7 @@ public open class KotlinIntroduceParameterHandler(
     }
 }
 
-private fun DeclarationDescriptor?.toFunctionDescriptor(targetParent: JetNamedDeclaration): FunctionDescriptor {
+private fun DeclarationDescriptor?.toFunctionDescriptor(targetParent: KtNamedDeclaration): FunctionDescriptor {
     val functionDescriptor: FunctionDescriptor? =
             when (this) {
                 is FunctionDescriptor -> this
@@ -364,23 +364,23 @@ private fun DeclarationDescriptor?.toFunctionDescriptor(targetParent: JetNamedDe
 }
 
 private fun findInternalUsagesOfParametersAndReceiver(
-        targetParent: JetNamedDeclaration,
+        targetParent: KtNamedDeclaration,
         targetDescriptor: FunctionDescriptor
-): MultiMap<JetElement, JetElement> {
-    val usages = MultiMap<JetElement, JetElement>()
+): MultiMap<KtElement, KtElement> {
+    val usages = MultiMap<KtElement, KtElement>()
     targetParent.getValueParameters()
             .filter { !it.hasValOrVar() }
             .forEach {
-                val paramUsages = ReferencesSearch.search(it).map { it.getElement() as JetElement }
+                val paramUsages = ReferencesSearch.search(it).map { it.getElement() as KtElement }
                 if (paramUsages.isNotEmpty()) {
                     usages.put(it, paramUsages)
                 }
             }
-    val receiverTypeRef = (targetParent as? JetFunction)?.getReceiverTypeReference()
+    val receiverTypeRef = (targetParent as? KtFunction)?.getReceiverTypeReference()
     if (receiverTypeRef != null) {
         targetParent.acceptChildren(
-                object : JetTreeVisitorVoid() {
-                    override fun visitThisExpression(expression: JetThisExpression) {
+                object : KtTreeVisitorVoid() {
+                    override fun visitThisExpression(expression: KtThisExpression) {
                         super.visitThisExpression(expression)
 
                         if (expression.getInstanceReference().mainReference.resolve() == targetDescriptor) {
@@ -388,7 +388,7 @@ private fun findInternalUsagesOfParametersAndReceiver(
                         }
                     }
 
-                    override fun visitJetElement(element: JetElement) {
+                    override fun visitJetElement(element: KtElement) {
                         super.visitJetElement(element)
 
                         val bindingContext = element.analyze()
@@ -420,7 +420,7 @@ public open class KotlinIntroduceLambdaParameterHandler(
                 editor: Editor,
                 lambdaExtractionDescriptor: ExtractableCodeDescriptor
         ): KotlinIntroduceParameterDialog {
-            val callable = lambdaExtractionDescriptor.extractionData.targetSibling as JetNamedDeclaration
+            val callable = lambdaExtractionDescriptor.extractionData.targetSibling as KtNamedDeclaration
             val descriptor = callable.resolveToDescriptor()
             val callableDescriptor = descriptor.toFunctionDescriptor(callable)
             val originalRange = lambdaExtractionDescriptor.extractionData.originalRange
@@ -430,7 +430,7 @@ public open class KotlinIntroduceLambdaParameterHandler(
                     callableDescriptor = callableDescriptor,
                     newParameterName = "", // to be chosen in the dialog
                     newParameterTypeText = "", // to be chosen in the dialog
-                    newArgumentValue = JetPsiFactory(project).createExpression("{}"), // substituted later
+                    newArgumentValue = KtPsiFactory(project).createExpression("{}"), // substituted later
                     withDefaultValue = false,
                     parametersUsages = findInternalUsagesOfParametersAndReceiver(callable, callableDescriptor),
                     occurrencesToReplace = listOf(originalRange),
@@ -462,11 +462,11 @@ public open class KotlinIntroduceLambdaParameterHandler(
         }
     }
 
-    override fun invoke(project: Project, editor: Editor, expression: JetExpression, targetParent: JetNamedDeclaration) {
+    override fun invoke(project: Project, editor: Editor, expression: KtExpression, targetParent: KtNamedDeclaration) {
         val duplicateContainer =
                 when (targetParent) {
-                    is JetFunction -> targetParent.getBodyExpression()
-                    is JetClass -> targetParent.getBody()
+                    is KtFunction -> targetParent.getBodyExpression()
+                    is KtClass -> targetParent.getBody()
                     else -> null
                 } ?: throw AssertionError("Body element is not found: ${targetParent.getElementTextWithContext()}")
         val extractionData = ExtractionData(expression.getContainingJetFile(),
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterMethodUsageProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterMethodUsageProcessor.kt
index 2db302a125d..16e59492b2f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterMethodUsageProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterMethodUsageProcessor.kt
@@ -27,7 +27,7 @@ import com.intellij.util.containers.MultiMap
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.resolve.getJavaMethodDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.core.refactoring.j2k
@@ -48,8 +48,8 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import java.util.Collections
 
 public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMethodUsagesProcessor {
-    override fun isMethodUsage(usage: UsageInfo): Boolean = (usage.getElement() as? JetElement)?.let {
-        it.getParentOfTypeAndBranch<JetCallElement>(true) { getCalleeExpression() } != null
+    override fun isMethodUsage(usage: UsageInfo): Boolean = (usage.getElement() as? KtElement)?.let {
+        it.getParentOfTypeAndBranch<KtCallElement>(true) { getCalleeExpression() } != null
     } ?: false
 
     override fun findConflicts(data: IntroduceParameterData, usages: Array<UsageInfo>, conflicts: MultiMap<PsiElement, String>) {
@@ -58,7 +58,7 @@ public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMe
 
     private fun createChangeInfo(data: IntroduceParameterData, method: PsiElement): JetChangeInfo? {
         val psiMethodDescriptor = when (method) {
-            is JetFunction -> method.resolveToDescriptor() as? FunctionDescriptor
+            is KtFunction -> method.resolveToDescriptor() as? FunctionDescriptor
             is PsiMethod -> method.getJavaMethodDescriptor()
             else -> null
         } ?: return null
@@ -77,7 +77,7 @@ public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMe
     }
 
     override fun processChangeMethodSignature(data: IntroduceParameterData, usage: UsageInfo, usages: Array<out UsageInfo>): Boolean {
-        val element = usage.getElement() as? JetFunction ?: return true
+        val element = usage.getElement() as? KtFunction ?: return true
 
         val changeInfo = createChangeInfo(data, element) ?: return true
         // Java method is already updated at this point
@@ -85,12 +85,12 @@ public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMe
         changeInfo.getNewParameters().last().currentTypeText = IdeDescriptorRenderers.SOURCE_CODE.renderType(addedParameterType)
 
         val scope = element.getUseScope().let {
-            if (it is GlobalSearchScope) GlobalSearchScope.getScopeRestrictedByFileTypes(it, JetFileType.INSTANCE) else it
+            if (it is GlobalSearchScope) GlobalSearchScope.getScopeRestrictedByFileTypes(it, KotlinFileType.INSTANCE) else it
         }
         val kotlinFunctions = HierarchySearchRequest(element, scope)
                 .searchOverriders()
                 .map { it.unwrapped }
-                .filterIsInstance<JetFunction>()
+                .filterIsInstance<KtFunction>()
         return (kotlinFunctions + element).all {
             JetCallableDefinitionUsage(it, changeInfo.originalBaseFunctionDescriptor, null, null).processUsage(changeInfo, it, usages)
         }
@@ -99,11 +99,11 @@ public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMe
     override fun processChangeMethodUsage(data: IntroduceParameterData, usage: UsageInfo, usages: Array<out UsageInfo>): Boolean {
         val psiMethod = data.getMethodToReplaceIn()
         val changeInfo = createChangeInfo(data, psiMethod) ?: return true
-        val refElement = usage.getElement() as? JetReferenceExpression ?: return true
-        val callElement = refElement.getParentOfTypeAndBranch<JetCallElement>(true) { getCalleeExpression() } ?: return true
-        val delegateUsage = if (callElement is JetConstructorDelegationCall) {
+        val refElement = usage.getElement() as? KtReferenceExpression ?: return true
+        val callElement = refElement.getParentOfTypeAndBranch<KtCallElement>(true) { getCalleeExpression() } ?: return true
+        val delegateUsage = if (callElement is KtConstructorDelegationCall) {
             @Suppress("CAST_NEVER_SUCCEEDS")
-            (JetConstructorDelegationCallUsage(callElement, changeInfo) as JetUsageInfo<JetCallElement>)
+            (JetConstructorDelegationCallUsage(callElement, changeInfo) as JetUsageInfo<KtCallElement>)
         }
         else {
             JetFunctionCallUsage(callElement, changeInfo.methodDescriptor.originalPrimaryCallable)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceProperty/KotlinInplacePropertyIntroducer.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceProperty/KotlinInplacePropertyIntroducer.kt
index 04091bf31d6..b519867a694 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceProperty/KotlinInplacePropertyIntroducer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceProperty/KotlinInplacePropertyIntroducer.kt
@@ -30,27 +30,27 @@ import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.generate
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.processDuplicatesSilently
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable.KotlinInplaceVariableIntroducer
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable.KotlinInplaceVariableIntroducer.ControlWrapper
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import javax.swing.*
 import javax.swing.event.PopupMenuEvent
 
 public class KotlinInplacePropertyIntroducer(
-        property: JetProperty,
+        property: KtProperty,
         editor: Editor,
         project: Project,
         title: String,
         doNotChangeVar: Boolean,
-        exprType: JetType?,
+        exprType: KtType?,
         extractionResult: ExtractionResult,
         private val availableTargets: List<ExtractionTarget>
-): KotlinInplaceVariableIntroducer<JetProperty>(
-        property, editor, project, title, JetExpression.EMPTY_ARRAY, null, false, property, false, doNotChangeVar, exprType, false
+): KotlinInplaceVariableIntroducer<KtProperty>(
+        property, editor, project, title, KtExpression.EMPTY_ARRAY, null, false, property, false, doNotChangeVar, exprType, false
 ) {
     init {
         assert(availableTargets.isNotEmpty()) { "No targets available: ${property.getElementTextWithContext()}" }
@@ -66,7 +66,7 @@ public class KotlinInplacePropertyIntroducer(
             runWriteActionAndRestartRefactoring {
                 with (extractionResult.config) {
                     extractionResult = copy(generatorOptions = generatorOptions.copy(target = currentTarget)).generateDeclaration(property)
-                    property = extractionResult.declaration as JetProperty
+                    property = extractionResult.declaration as KtProperty
                     myElementToRename = property
                 }
             }
@@ -75,9 +75,9 @@ public class KotlinInplacePropertyIntroducer(
 
     private var replaceAll: Boolean = true
 
-    protected var property: JetProperty
+    protected var property: KtProperty
         get() = myDeclaration
-        set(value: JetProperty) {
+        set(value: KtProperty) {
             myDeclaration = value
         }
 
@@ -158,7 +158,7 @@ public class KotlinInplacePropertyIntroducer(
     }
 
     override fun checkLocalScope(): PsiElement? {
-        return myElementToRename.parentsWithSelf.first { it is JetClassOrObject || it is JetFile }
+        return myElementToRename.parentsWithSelf.first { it is KtClassOrObject || it is KtFile }
     }
 
     override fun moveOffsetAfter(success: Boolean) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceProperty/KotlinIntroducePropertyHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceProperty/KotlinIntroducePropertyHandler.kt
index 5701a34b76f..588d53f18f0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceProperty/KotlinIntroducePropertyHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceProperty/KotlinIntroducePropertyHandler.kt
@@ -59,19 +59,19 @@ public class KotlinIntroducePropertyHandler(
                 editor,
                 file,
                 { elements, parent ->
-                    parent.getExtractionContainers(strict = true, includeAll = true).filter { it is JetClassBody || it is JetFile }
+                    parent.getExtractionContainers(strict = true, includeAll = true).filter { it is KtClassBody || it is KtFile }
                 },
                 continuation
         )
     }
 
-    public fun doInvoke(project: Project, editor: Editor, file: JetFile, elements: List<PsiElement>, targetSibling: PsiElement) {
-        val adjustedElements = (elements.singleOrNull() as? JetBlockExpression)?.getStatements() ?: elements
+    public fun doInvoke(project: Project, editor: Editor, file: KtFile, elements: List<PsiElement>, targetSibling: PsiElement) {
+        val adjustedElements = (elements.singleOrNull() as? KtBlockExpression)?.getStatements() ?: elements
         if (adjustedElements.isNotEmpty()) {
             val options = ExtractionOptions(extractAsProperty = true)
             val extractionData = ExtractionData(file, adjustedElements.toRange(), targetSibling, null, options)
             ExtractionEngine(helper).run(editor, extractionData) {
-                val property = it.declaration as JetProperty
+                val property = it.declaration as KtProperty
                 val descriptor = it.config.descriptor
 
                 editor.getCaretModel().moveToOffset(property.getTextOffset())
@@ -105,7 +105,7 @@ public class KotlinIntroducePropertyHandler(
     }
 
     override fun invoke(project: Project, editor: Editor, file: PsiFile, dataContext: DataContext?) {
-        if (file !is JetFile) return
+        if (file !is KtFile) return
         selectElements(editor, file) { elements, targetSibling -> doInvoke(project, editor, file, elements, targetSibling) }
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceUtil.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceUtil.kt
index ee823127791..23d1336c22c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceUtil.kt
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
 import org.jetbrains.kotlin.idea.core.refactoring.chooseContainerElementIfNecessary
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.psiUtil.collectDescendantsOfType
 import org.jetbrains.kotlin.psi.psiUtil.findDescendantOfType
 import org.jetbrains.kotlin.psi.psiUtil.getOutermostParentContainedIn
@@ -130,8 +130,8 @@ fun selectElementsWithTargetParent(
     selectSingleExpression()
 }
 
-fun PsiElement.findExpressionByCopyableDataAndClearIt(key: Key<Boolean>): JetExpression {
-    val result = findDescendantOfType<JetExpression> { it.getCopyableUserData(key) != null }!!
+fun PsiElement.findExpressionByCopyableDataAndClearIt(key: Key<Boolean>): KtExpression {
+    val result = findDescendantOfType<KtExpression> { it.getCopyableUserData(key) != null }!!
     result.putCopyableUserData(key, null)
     return result
 }
@@ -142,8 +142,8 @@ fun PsiElement.findElementByCopyableDataAndClearIt(key: Key<Boolean>): PsiElemen
     return result
 }
 
-fun PsiElement.findExpressionsByCopyableDataAndClearIt(key: Key<Boolean>): List<JetExpression> {
-    val results = collectDescendantsOfType<JetExpression> { it.getCopyableUserData(key) != null }
+fun PsiElement.findExpressionsByCopyableDataAndClearIt(key: Key<Boolean>): List<KtExpression> {
+    val results = collectDescendantsOfType<KtExpression> { it.getCopyableUserData(key) != null }
     results.forEach { it.putCopyableUserData(key, null) }
     return results
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinInplaceVariableIntroducer.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinInplaceVariableIntroducer.java
index 647ce2c9003..b54376a1507 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinInplaceVariableIntroducer.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinInplaceVariableIntroducer.java
@@ -44,9 +44,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.intentions.SpecifyTypeExplicitlyIntention;
 import org.jetbrains.kotlin.idea.references.ReferenceUtilKt;
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import javax.swing.*;
 import java.awt.*;
@@ -57,7 +57,7 @@ import java.util.Collection;
 import java.util.LinkedHashSet;
 import java.util.List;
 
-public class KotlinInplaceVariableIntroducer<D extends JetCallableDeclaration> extends InplaceVariableIntroducer<JetExpression> {
+public class KotlinInplaceVariableIntroducer<D extends KtCallableDeclaration> extends InplaceVariableIntroducer<KtExpression> {
     private static final Key<KotlinInplaceVariableIntroducer> ACTIVE_INTRODUCER = Key.create("ACTIVE_INTRODUCER");
 
     public static final String TYPE_REFERENCE_VARIABLE_NAME = "TypeReferenceVariable";
@@ -120,17 +120,17 @@ public class KotlinInplaceVariableIntroducer<D extends JetCallableDeclaration> e
     protected D myDeclaration;
     private final boolean isVar;
     private final boolean myDoNotChangeVar;
-    @Nullable private final JetType myExprType;
+    @Nullable private final KtType myExprType;
     private final boolean noTypeInference;
     private final List<ControlWrapper> panelControls = new ArrayList<ControlWrapper>();
     private JPanel contentPanel;
 
     public KotlinInplaceVariableIntroducer(
             PsiNamedElement elementToRename, Editor editor, Project project,
-            String title, JetExpression[] occurrences,
-            @Nullable JetExpression expr, boolean replaceOccurrence,
+            String title, KtExpression[] occurrences,
+            @Nullable KtExpression expr, boolean replaceOccurrence,
             D declaration, boolean isVar, boolean doNotChangeVar,
-            @Nullable JetType exprType, boolean noTypeInference
+            @Nullable KtType exprType, boolean noTypeInference
     ) {
         super(elementToRename, editor, project, title, occurrences, expr);
         this.myReplaceOccurrence = replaceOccurrence;
@@ -226,7 +226,7 @@ public class KotlinInplaceVariableIntroducer<D extends JetCallableDeclaration> e
                                         if (exprTypeCheckbox.isSelected()) {
                                             String renderedType =
                                                     IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType(myExprType);
-                                            myDeclaration.setTypeReference(new JetPsiFactory(myProject).createType(renderedType));
+                                            myDeclaration.setTypeReference(new KtPsiFactory(myProject).createType(renderedType));
                                         }
                                         else {
                                             myDeclaration.setTypeReference(null);
@@ -260,12 +260,12 @@ public class KotlinInplaceVariableIntroducer<D extends JetCallableDeclaration> e
                             protected void run(@NotNull Result result) throws Throwable {
                                 PsiDocumentManager.getInstance(myProject).commitDocument(myEditor.getDocument());
 
-                                JetPsiFactory psiFactory = new JetPsiFactory(myProject);
+                                KtPsiFactory psiFactory = new KtPsiFactory(myProject);
                                 PsiElement keyword = varCheckbox.isSelected() ? psiFactory.createVarKeyword() : psiFactory.createValKeyword();
 
-                                PsiElement valOrVar = myDeclaration instanceof JetProperty
-                                                       ? ((JetProperty) myDeclaration).getValOrVarKeyword()
-                                                       : ((JetParameter) myDeclaration).getValOrVarKeyword();
+                                PsiElement valOrVar = myDeclaration instanceof KtProperty
+                                                       ? ((KtProperty) myDeclaration).getValOrVarKeyword()
+                                                       : ((KtParameter) myDeclaration).getValOrVarKeyword();
                                 valOrVar.replace(keyword);
                             }
                         }.execute();
@@ -284,7 +284,7 @@ public class KotlinInplaceVariableIntroducer<D extends JetCallableDeclaration> e
             protected void run(@NotNull Result result) throws Throwable {
                 PsiDocumentManager.getInstance(myProject).commitDocument(myEditor.getDocument());
 
-                ASTNode identifier = myDeclaration.getNode().findChildByType(JetTokens.IDENTIFIER);
+                ASTNode identifier = myDeclaration.getNode().findChildByType(KtTokens.IDENTIFIER);
                 if (identifier != null) {
                     TextRange range = identifier.getTextRange();
                     RangeHighlighter[] highlighters = myEditor.getMarkupModel().getAllHighlighters();
@@ -311,7 +311,7 @@ public class KotlinInplaceVariableIntroducer<D extends JetCallableDeclaration> e
         ApplicationManager.getApplication().runReadAction(new Runnable() {
             @Override
             public void run() {
-                ASTNode identifier = myDeclaration.getNode().findChildByType(JetTokens.IDENTIFIER);
+                ASTNode identifier = myDeclaration.getNode().findChildByType(KtTokens.IDENTIFIER);
                 if (identifier != null) {
                     TextRange range = identifier.getTextRange();
                     RangeHighlighter[] highlighters = myEditor.getMarkupModel().getAllHighlighters();
@@ -354,7 +354,7 @@ public class KotlinInplaceVariableIntroducer<D extends JetCallableDeclaration> e
     }
 
     protected void addTypeReferenceVariable(TemplateBuilderImpl builder) {
-        JetTypeReference typeReference = myDeclaration.getTypeReference();
+        KtTypeReference typeReference = myDeclaration.getTypeReference();
         if (typeReference != null) {
             builder.replaceElement(typeReference,
                                    TYPE_REFERENCE_VARIABLE_NAME,
@@ -392,10 +392,10 @@ public class KotlinInplaceVariableIntroducer<D extends JetCallableDeclaration> e
     @Override
     protected Collection<PsiReference> collectRefs(SearchScope referencesSearchScope) {
         return CollectionsKt.map(
-                ArraysKt.filterIsInstance(getOccurrences(), JetSimpleNameExpression.class),
-                new Function1<JetSimpleNameExpression, PsiReference>() {
+                ArraysKt.filterIsInstance(getOccurrences(), KtSimpleNameExpression.class),
+                new Function1<KtSimpleNameExpression, PsiReference>() {
                     @Override
-                    public PsiReference invoke(JetSimpleNameExpression expression) {
+                    public PsiReference invoke(KtSimpleNameExpression expression) {
                         return ReferenceUtilKt.getMainReference(expression);
                     }
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java
index cddfc255974..5126d0100b2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java
@@ -54,7 +54,7 @@ import org.jetbrains.kotlin.idea.util.ShortenReferences;
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.JetPsiRange;
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.JetPsiRangeKt;
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.JetPsiUnifier;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.JetPsiUtilKt;
 import org.jetbrains.kotlin.resolve.BindingContext;
@@ -63,9 +63,9 @@ import org.jetbrains.kotlin.resolve.ObservableBindingTrace;
 import org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilsKt;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.types.JetType;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
+import org.jetbrains.kotlin.types.KtType;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -80,7 +80,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
     public void invoke(@NotNull final Project project, @NotNull final Editor editor, @NotNull PsiFile file, DataContext dataContext) {
         JetRefactoringUtil.SelectExpressionCallback callback = new JetRefactoringUtil.SelectExpressionCallback() {
             @Override
-            public void run(@Nullable JetExpression expression) {
+            public void run(@Nullable KtExpression expression) {
                 doRefactoring(project, editor, expression, null, null);
             }
         };
@@ -96,32 +96,32 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
     public static void doRefactoring(
             @NotNull final Project project,
             @Nullable final Editor editor,
-            @Nullable JetExpression _expression,
-            @Nullable List<JetExpression> occurrencesToReplace,
-            @Nullable final Function1<JetProperty, Unit> onNonInteractiveFinish
+            @Nullable KtExpression _expression,
+            @Nullable List<KtExpression> occurrencesToReplace,
+            @Nullable final Function1<KtProperty, Unit> onNonInteractiveFinish
     ) {
         if (_expression == null) {
             showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.no.expression"));
             return;
         }
-        if (_expression.getParent() instanceof JetParenthesizedExpression) {
-            _expression = (JetExpression)_expression.getParent();
+        if (_expression.getParent() instanceof KtParenthesizedExpression) {
+            _expression = (KtExpression)_expression.getParent();
         }
-        final JetExpression expression = _expression;
+        final KtExpression expression = _expression;
         boolean noTypeInference = false;
-        if (expression.getParent() instanceof JetQualifiedExpression) {
-            JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression)expression.getParent();
+        if (expression.getParent() instanceof KtQualifiedExpression) {
+            KtQualifiedExpression qualifiedExpression = (KtQualifiedExpression)expression.getParent();
             if (qualifiedExpression.getReceiverExpression() != expression) {
                 showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.no.expression"));
                 return;
             }
         }
-        else if (expression instanceof JetStatementExpression) {
+        else if (expression instanceof KtStatementExpression) {
             showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.no.expression"));
             return;
         }
-        else if (expression.getParent() instanceof JetOperationExpression) {
-            JetOperationExpression operationExpression = (JetOperationExpression)expression.getParent();
+        else if (expression.getParent() instanceof KtOperationExpression) {
+            KtOperationExpression operationExpression = (KtOperationExpression)expression.getParent();
             if (operationExpression.getOperationReference() == expression) {
                 showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.no.expression"));
                 return;
@@ -130,24 +130,24 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
 
         //noinspection unchecked
         if (PsiTreeUtil.getNonStrictParentOfType(expression,
-                                                 JetTypeReference.class, JetConstructorCalleeExpression.class, JetSuperExpression.class) != null) {
+                                                 KtTypeReference.class, KtConstructorCalleeExpression.class, KtSuperExpression.class) != null) {
             showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.no.container"));
             return;
         }
 
         AnalysisResult analysisResult = ResolutionUtils.analyzeAndGetResult(expression);
         final BindingContext bindingContext = analysisResult.getBindingContext();
-        final JetType expressionType = bindingContext.getType(expression); //can be null or error type
-        JetScope scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, expression);
+        final KtType expressionType = bindingContext.getType(expression); //can be null or error type
+        KtScope scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, expression);
         if (scope != null) {
             DataFlowInfo dataFlowInfo = BindingContextUtilsKt.getDataFlowInfo(bindingContext, expression);
 
             ObservableBindingTrace bindingTrace = new ObservableBindingTrace(new BindingTraceContext());
-            JetType typeNoExpectedType = AnalyzerUtilKt.computeTypeInfoInContext(
+            KtType typeNoExpectedType = AnalyzerUtilKt.computeTypeInfoInContext(
                     expression, scope, expression, bindingTrace, dataFlowInfo
             ).getType();
-            if (expressionType != null && typeNoExpectedType != null && !JetTypeChecker.DEFAULT.equalTypes(expressionType,
-                                                                                                           typeNoExpectedType)) {
+            if (expressionType != null && typeNoExpectedType != null && !KotlinTypeChecker.DEFAULT.equalTypes(expressionType,
+                                                                                                              typeNoExpectedType)) {
                 noTypeInference = true;
             }
         }
@@ -157,7 +157,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
             return;
         }
         if (expressionType != null &&
-            JetTypeChecker.DEFAULT.equalTypes(analysisResult.getModuleDescriptor().getBuiltIns().getUnitType(), expressionType)) {
+            KotlinTypeChecker.DEFAULT.equalTypes(analysisResult.getModuleDescriptor().getBuiltIns().getUnitType(), expressionType)) {
             showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.expression.has.unit.type"));
             return;
         }
@@ -176,7 +176,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
             editor.getSettings().isVariableInplaceRenameEnabled() &&
             !ApplicationManager.getApplication().isUnitTestMode();
 
-        final List<JetExpression> allOccurrences;
+        final List<KtExpression> allOccurrences;
         if (occurrencesToReplace == null) {
             allOccurrences = findOccurrences(occurrenceContainer, expression);
         }
@@ -189,7 +189,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
             @Override
             public void pass(OccurrencesChooser.ReplaceChoice replaceChoice) {
                 boolean replaceOccurrence = shouldReplaceOccurrence(expression, bindingContext, container);
-                List<JetExpression> allReplaces;
+                List<KtExpression> allReplaces;
                 if (OccurrencesChooser.ReplaceChoice.ALL == replaceChoice) {
                     if (allOccurrences.size() > 1) replaceOccurrence = true;
                     allReplaces = allOccurrences;
@@ -207,9 +207,9 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
                 );
                 final Collection<String> suggestedNames = KotlinNameSuggester.INSTANCE$.suggestNamesByExpressionAndType(
                         expression, ResolutionUtils.analyze(expression, BodyResolveMode.PARTIAL), validator, "value");
-                final Ref<JetProperty> propertyRef = new Ref<JetProperty>();
-                final ArrayList<JetExpression> references = new ArrayList<JetExpression>();
-                final Ref<JetExpression> reference = new Ref<JetExpression>();
+                final Ref<KtProperty> propertyRef = new Ref<KtProperty>();
+                final ArrayList<KtExpression> references = new ArrayList<KtExpression>();
+                final Ref<KtExpression> reference = new Ref<KtExpression>();
                 final Runnable introduceRunnable = introduceVariable(
                         expression, suggestedNames.iterator().next(), allReplaces, commonContainer,
                         commonParent, replaceOccurrence, propertyRef, references,
@@ -218,7 +218,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
                     @Override
                     public void run() {
                         ApplicationManager.getApplication().runWriteAction(introduceRunnable);
-                        JetProperty property = propertyRef.get();
+                        KtProperty property = propertyRef.get();
                         if (property != null) {
                             if (editor != null) {
                                 editor.getCaretModel().moveToOffset(property.getTextOffset());
@@ -230,7 +230,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
                                     KotlinVariableInplaceIntroducer variableIntroducer =
                                             new KotlinVariableInplaceIntroducer(property,
                                                                                 reference.get(),
-                                                                                references.toArray(new JetExpression[references.size()]),
+                                                                                references.toArray(new KtExpression[references.size()]),
                                                                                 suggestedNames,
                                                                                 /*todo*/ false,
                                                                                 /*todo*/ false,
@@ -250,7 +250,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
             }
         };
         if (isInplaceAvailableOnDataContext && occurrencesToReplace == null) {
-            OccurrencesChooser.<JetExpression>simpleChooser(editor).
+            OccurrencesChooser.<KtExpression>simpleChooser(editor).
                 showChooser(expression, allOccurrences, callback);
         }
         else {
@@ -261,45 +261,45 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
     private static Key<Boolean> OCCURRENCE = Key.create("OCCURRENCE");
 
     private static Runnable introduceVariable(
-            final JetExpression expression,
+            final KtExpression expression,
             final String nameSuggestion,
-            final List<JetExpression> allReplaces,
+            final List<KtExpression> allReplaces,
             final PsiElement commonContainer,
             final PsiElement commonParent,
             final boolean replaceOccurrence,
-            final Ref<JetProperty> propertyRef,
-            final ArrayList<JetExpression> references,
-            final Ref<JetExpression> reference,
+            final Ref<KtProperty> propertyRef,
+            final ArrayList<KtExpression> references,
+            final Ref<KtExpression> reference,
             final boolean noTypeInference,
-            final JetType expressionType,
+            final KtType expressionType,
             final BindingContext bindingContext
     ) {
-        final JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(expression);
+        final KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(expression);
         return new Runnable() {
             @Override
             public void run() {
-                if (commonContainer instanceof JetDeclarationWithBody) {
-                    JetDeclarationWithBody originalDeclaration = (JetDeclarationWithBody) commonContainer;
-                    final JetExpression originalBody = originalDeclaration.getBodyExpression();
+                if (commonContainer instanceof KtDeclarationWithBody) {
+                    KtDeclarationWithBody originalDeclaration = (KtDeclarationWithBody) commonContainer;
+                    final KtExpression originalBody = originalDeclaration.getBodyExpression();
                     assert originalBody != null : "Original body is not found: " + originalDeclaration;
 
                     Key<Boolean> EXPRESSION_KEY = Key.create("EXPRESSION_KEY");
                     Key<Boolean> REPLACE_KEY = Key.create("REPLACE_KEY");
                     Key<Boolean> COMMON_PARENT_KEY = Key.create("COMMON_PARENT_KEY");
                     expression.putCopyableUserData(EXPRESSION_KEY, true);
-                    for (JetExpression replace : allReplaces) {
+                    for (KtExpression replace : allReplaces) {
                         replace.putCopyableUserData(REPLACE_KEY, true);
                     }
                     commonParent.putCopyableUserData(COMMON_PARENT_KEY, true);
 
-                    JetDeclarationWithBody newDeclaration = ConvertToBlockBodyIntention.Companion.convert(originalDeclaration);
+                    KtDeclarationWithBody newDeclaration = ConvertToBlockBodyIntention.Companion.convert(originalDeclaration);
 
-                    JetBlockExpression newCommonContainer = (JetBlockExpression) newDeclaration.getBodyExpression();
+                    KtBlockExpression newCommonContainer = (KtBlockExpression) newDeclaration.getBodyExpression();
                     assert newCommonContainer != null : "New body is not found: " + newDeclaration;
 
-                    JetExpression newExpression = IntroduceUtilKt.findExpressionByCopyableDataAndClearIt(newCommonContainer, EXPRESSION_KEY);
+                    KtExpression newExpression = IntroduceUtilKt.findExpressionByCopyableDataAndClearIt(newCommonContainer, EXPRESSION_KEY);
                     PsiElement newCommonParent = IntroduceUtilKt.findElementByCopyableDataAndClearIt(newCommonContainer, COMMON_PARENT_KEY);
-                    List<JetExpression> newAllReplaces = IntroduceUtilKt
+                    List<KtExpression> newAllReplaces = IntroduceUtilKt
                             .findExpressionsByCopyableDataAndClearIt(newCommonContainer, REPLACE_KEY);
 
                     run(newExpression, newCommonContainer, newCommonParent, newAllReplaces);
@@ -310,19 +310,19 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
             }
 
             private void run(
-                    JetExpression expression,
+                    KtExpression expression,
                     PsiElement commonContainer,
                     PsiElement commonParent,
-                    List<JetExpression> allReplaces
+                    List<KtExpression> allReplaces
             ) {
                 String variableText = "val " + nameSuggestion;
                 if (noTypeInference) {
                     variableText += ": " + IdeDescriptorRenderers.SOURCE_CODE.renderType(expressionType);
                 }
                 variableText += " = ";
-                if (expression instanceof JetParenthesizedExpression) {
-                    JetParenthesizedExpression parenthesizedExpression = (JetParenthesizedExpression)expression;
-                    JetExpression innerExpression = parenthesizedExpression.getExpression();
+                if (expression instanceof KtParenthesizedExpression) {
+                    KtParenthesizedExpression parenthesizedExpression = (KtParenthesizedExpression)expression;
+                    KtExpression innerExpression = parenthesizedExpression.getExpression();
                     if (innerExpression != null) {
                         variableText += innerExpression.getText();
                     }
@@ -333,22 +333,22 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
                 else {
                     variableText += expression.getText();
                 }
-                JetProperty property = psiFactory.createProperty(variableText);
+                KtProperty property = psiFactory.createProperty(variableText);
                 PsiElement anchor = calculateAnchor(commonParent, commonContainer, allReplaces);
                 if (anchor == null) return;
-                boolean needBraces = !(commonContainer instanceof JetBlockExpression);
+                boolean needBraces = !(commonContainer instanceof KtBlockExpression);
                 if (!needBraces) {
-                    property = (JetProperty)commonContainer.addBefore(property, anchor);
+                    property = (KtProperty)commonContainer.addBefore(property, anchor);
                     commonContainer.addBefore(psiFactory.createNewLine(), anchor);
                 }
                 else {
-                    JetExpression emptyBody = psiFactory.createEmptyBody();
+                    KtExpression emptyBody = psiFactory.createEmptyBody();
                     PsiElement firstChild = emptyBody.getFirstChild();
                     emptyBody.addAfter(psiFactory.createNewLine(), firstChild);
 
                     if (replaceOccurrence && commonContainer != null) {
-                        for (JetExpression replace : allReplaces) {
-                            JetExpression exprAfterReplace = replaceExpression(replace, false);
+                        for (KtExpression replace : allReplaces) {
+                            KtExpression exprAfterReplace = replaceExpression(replace, false);
                             exprAfterReplace.putCopyableUserData(OCCURRENCE, true);
                             if (anchor == replace) {
                                 anchor = exprAfterReplace;
@@ -356,46 +356,46 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
                         }
 
                         PsiElement oldElement = commonContainer;
-                        if (commonContainer instanceof JetWhenEntry) {
-                            JetExpression body = ((JetWhenEntry)commonContainer).getExpression();
+                        if (commonContainer instanceof KtWhenEntry) {
+                            KtExpression body = ((KtWhenEntry)commonContainer).getExpression();
                             if (body != null) {
                                 oldElement = body;
                             }
                         }
-                        else if (commonContainer instanceof JetContainerNode) {
-                            JetContainerNode container = (JetContainerNode)commonContainer;
+                        else if (commonContainer instanceof KtContainerNode) {
+                            KtContainerNode container = (KtContainerNode)commonContainer;
                             PsiElement[] children = container.getChildren();
                             for (PsiElement child : children) {
-                                if (child instanceof JetExpression) {
+                                if (child instanceof KtExpression) {
                                     oldElement = child;
                                 }
                             }
                         }
                         //ugly logic to make sure we are working with right actual expression
-                        JetExpression actualExpression = reference.get();
+                        KtExpression actualExpression = reference.get();
                         int diff = actualExpression.getTextRange().getStartOffset() - oldElement.getTextRange().getStartOffset();
                         String actualExpressionText = actualExpression.getText();
                         PsiElement newElement = emptyBody.addAfter(oldElement, firstChild);
                         PsiElement elem = findElementByOffsetAndText(diff, actualExpressionText, newElement);
                         if (elem != null) {
-                            reference.set((JetExpression)elem);
+                            reference.set((KtExpression)elem);
                         }
                         emptyBody.addAfter(psiFactory.createNewLine(), firstChild);
-                        property = (JetProperty)emptyBody.addAfter(property, firstChild);
+                        property = (KtProperty)emptyBody.addAfter(property, firstChild);
                         emptyBody.addAfter(psiFactory.createNewLine(), firstChild);
                         actualExpression = reference.get();
                         diff = actualExpression.getTextRange().getStartOffset() - emptyBody.getTextRange().getStartOffset();
                         actualExpressionText = actualExpression.getText();
-                        emptyBody = (JetBlockExpression) anchor.replace(emptyBody);
+                        emptyBody = (KtBlockExpression) anchor.replace(emptyBody);
                         elem = findElementByOffsetAndText(diff, actualExpressionText, emptyBody);
                         if (elem != null) {
-                            reference.set((JetExpression)elem);
+                            reference.set((KtExpression)elem);
                         }
 
                         emptyBody.accept(
-                                new JetTreeVisitorVoid() {
+                                new KtTreeVisitorVoid() {
                                     @Override
-                                    public void visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression) {
+                                    public void visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression) {
                                         if (expression.getCopyableUserData(OCCURRENCE) == null) return;
 
                                         expression.putCopyableUserData(OCCURRENCE, null);
@@ -409,26 +409,26 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
                         PsiElement copyTo = parent.getLastChild();
                         PsiElement copyFrom = anchor.getNextSibling();
 
-                        property = (JetProperty)emptyBody.addAfter(property, firstChild);
+                        property = (KtProperty)emptyBody.addAfter(property, firstChild);
                         emptyBody.addAfter(psiFactory.createNewLine(), firstChild);
                         if (copyFrom != null && copyTo != null) {
                             emptyBody.addRangeAfter(copyFrom, copyTo, property);
                             parent.deleteChildRange(copyFrom, copyTo);
                         }
-                        emptyBody = (JetBlockExpression) anchor.replace(emptyBody);
+                        emptyBody = (KtBlockExpression) anchor.replace(emptyBody);
                     }
                     for (PsiElement child : emptyBody.getChildren()) {
-                        if (child instanceof JetProperty) {
-                            property = (JetProperty)child;
+                        if (child instanceof KtProperty) {
+                            property = (KtProperty)child;
                         }
                     }
-                    if (commonContainer instanceof JetContainerNode) {
-                        JetContainerNode node = (JetContainerNode)commonContainer;
-                        if (node.getParent() instanceof JetIfExpression) {
+                    if (commonContainer instanceof KtContainerNode) {
+                        KtContainerNode node = (KtContainerNode)commonContainer;
+                        if (node.getParent() instanceof KtIfExpression) {
                             PsiElement next = node.getNextSibling();
                             if (next != null) {
                                 PsiElement nextnext = next.getNextSibling();
-                                if (nextnext != null && nextnext.getNode().getElementType() == JetTokens.ELSE_KEYWORD) {
+                                if (nextnext != null && nextnext.getNode().getElementType() == KtTokens.ELSE_KEYWORD) {
                                     if (next instanceof PsiWhiteSpace) {
                                         next.replace(psiFactory.createWhiteSpace());
                                     }
@@ -439,7 +439,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
                 }
                 if (!needBraces) {
                     for (int i = 0; i < allReplaces.size(); i++) {
-                        JetExpression replace = allReplaces.get(i);
+                        KtExpression replace = allReplaces.get(i);
 
                         if (i != 0 ? replaceOccurrence : shouldReplaceOccurrence(replace, bindingContext, commonContainer)) {
                             replaceExpression(replace, true);
@@ -463,33 +463,33 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
 
             private PsiElement findElementByOffsetAndText(int offset, String text, PsiElement newContainer) {
                 PsiElement elem = newContainer.findElementAt(offset);
-                while (elem != null && !(elem instanceof JetExpression && text.equals(elem.getText()))) {
+                while (elem != null && !(elem instanceof KtExpression && text.equals(elem.getText()))) {
                     elem = elem.getParent();
                 }
                 return elem;
             }
 
-            private JetExpression replaceExpression(JetExpression replace, boolean addToReferences) {
+            private KtExpression replaceExpression(KtExpression replace, boolean addToReferences) {
                 boolean isActualExpression = expression == replace;
 
-                JetExpression replacement = psiFactory.createExpression(nameSuggestion);
-                JetExpression result;
+                KtExpression replacement = psiFactory.createExpression(nameSuggestion);
+                KtExpression result;
                 if (JetPsiUtilKt.isFunctionLiteralOutsideParentheses(replace)) {
-                    JetFunctionLiteralArgument functionLiteralArgument =
-                            PsiTreeUtil.getParentOfType(replace, JetFunctionLiteralArgument.class);
-                    JetCallExpression newCallExpression = PsiModificationUtilsKt
+                    KtFunctionLiteralArgument functionLiteralArgument =
+                            PsiTreeUtil.getParentOfType(replace, KtFunctionLiteralArgument.class);
+                    KtCallExpression newCallExpression = PsiModificationUtilsKt
                             .moveInsideParenthesesAndReplaceWith(functionLiteralArgument, replacement, bindingContext);
                     result = CollectionsKt.last(newCallExpression.getValueArguments()).getArgumentExpression();
                 }
                 else {
-                    result = (JetExpression)replace.replace(replacement);
+                    result = (KtExpression)replace.replace(replacement);
                 }
 
                 PsiElement parent = result != null ? result.getParent() : null;
-                if (parent instanceof JetBlockStringTemplateEntry) {
+                if (parent instanceof KtBlockStringTemplateEntry) {
                     RemoveCurlyBracesFromTemplateIntention intention = new RemoveCurlyBracesFromTemplateIntention();
-                    JetBlockStringTemplateEntry entry = (JetBlockStringTemplateEntry) parent;
-                    JetStringTemplateEntryWithExpression newEntry = intention.isApplicableTo(entry) ? intention.applyTo(entry) : entry;
+                    KtBlockStringTemplateEntry entry = (KtBlockStringTemplateEntry) parent;
+                    KtStringTemplateEntryWithExpression newEntry = intention.isApplicableTo(entry) ? intention.applyTo(entry) : entry;
                     result = newEntry.getExpression();
                 }
 
@@ -504,7 +504,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
     }
 
     private static PsiElement calculateAnchor(PsiElement commonParent, PsiElement commonContainer,
-                                              List<JetExpression> allReplaces) {
+                                              List<KtExpression> allReplaces) {
         PsiElement anchor = commonParent;
         if (anchor != commonContainer) {
             while (anchor.getParent() != commonContainer) {
@@ -514,7 +514,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
         else {
             anchor = commonContainer.getFirstChild();
             int startOffset = commonContainer.getTextRange().getEndOffset();
-            for (JetExpression expr : allReplaces) {
+            for (KtExpression expr : allReplaces) {
                 int offset = expr.getTextRange().getStartOffset();
                 if (offset < startOffset) startOffset = offset;
             }
@@ -526,16 +526,16 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
         return anchor;
     }
 
-    private static List<JetExpression> findOccurrences(PsiElement occurrenceContainer, @NotNull JetExpression originalExpression) {
+    private static List<KtExpression> findOccurrences(PsiElement occurrenceContainer, @NotNull KtExpression originalExpression) {
         return CollectionsKt.map(
                 JetPsiRangeKt.toRange(originalExpression).match(occurrenceContainer, JetPsiUnifier.DEFAULT),
-                new Function1<JetPsiRange.Match, JetExpression>() {
+                new Function1<JetPsiRange.Match, KtExpression>() {
                     @Override
-                    public JetExpression invoke(JetPsiRange.Match match) {
+                    public KtExpression invoke(JetPsiRange.Match match) {
                         PsiElement candidate = ((JetPsiRange.ListRange) match.getRange()).getStartElement();
-                        if (candidate instanceof JetExpression) return (JetExpression) candidate;
-                        if (candidate instanceof JetStringTemplateEntryWithExpression)
-                            return ((JetStringTemplateEntryWithExpression) candidate).getExpression();
+                        if (candidate instanceof KtExpression) return (KtExpression) candidate;
+                        if (candidate instanceof KtStringTemplateEntryWithExpression)
+                            return ((KtStringTemplateEntryWithExpression) candidate).getExpression();
 
                         throw new AssertionError("Unexpected candidate element: " + candidate.getText());
                     }
@@ -544,7 +544,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
     }
 
     private static boolean shouldReplaceOccurrence(
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             @NotNull BindingContext bindingContext,
             @Nullable PsiElement container
     ) {
@@ -553,21 +553,21 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
 
     @Nullable
     private static PsiElement getContainer(PsiElement place) {
-        if (place instanceof JetBlockExpression) {
+        if (place instanceof KtBlockExpression) {
             return place;
         }
         while (place != null) {
             PsiElement parent = place.getParent();
-            if (parent instanceof JetContainerNode) {
-                if (!isBadContainerNode((JetContainerNode)parent, place)) {
+            if (parent instanceof KtContainerNode) {
+                if (!isBadContainerNode((KtContainerNode)parent, place)) {
                     return parent;
                 }
             }
-            if (parent instanceof JetBlockExpression
-                || (parent instanceof JetWhenEntry && place == ((JetWhenEntry) parent).getExpression())) {
+            if (parent instanceof KtBlockExpression
+                || (parent instanceof KtWhenEntry && place == ((KtWhenEntry) parent).getExpression())) {
                 return parent;
             }
-            if (parent instanceof JetDeclarationWithBody && ((JetDeclarationWithBody) parent).getBodyExpression() == place) {
+            if (parent instanceof KtDeclarationWithBody && ((KtDeclarationWithBody) parent).getBodyExpression() == place) {
                 return parent;
             }
             place = parent;
@@ -575,16 +575,16 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
         return null;
     }
 
-    private static boolean isBadContainerNode(JetContainerNode parent, PsiElement place) {
-        if (parent.getParent() instanceof JetIfExpression &&
-            ((JetIfExpression)parent.getParent()).getCondition() == place) {
+    private static boolean isBadContainerNode(KtContainerNode parent, PsiElement place) {
+        if (parent.getParent() instanceof KtIfExpression &&
+            ((KtIfExpression)parent.getParent()).getCondition() == place) {
             return true;
         }
-        else if (parent.getParent() instanceof JetLoopExpression &&
-                 ((JetLoopExpression)parent.getParent()).getBody() != place) {
+        else if (parent.getParent() instanceof KtLoopExpression &&
+                 ((KtLoopExpression)parent.getParent()).getBody() != place) {
             return true;
         }
-        else if (parent.getParent() instanceof JetArrayAccessExpression) {
+        else if (parent.getParent() instanceof KtArrayAccessExpression) {
             return true;
         }
         return false;
@@ -595,26 +595,26 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
         PsiElement result = null;
         while (place != null) {
             PsiElement parent = place.getParent();
-            if (parent instanceof JetContainerNode) {
-                if (!(place instanceof JetBlockExpression) && !isBadContainerNode((JetContainerNode)parent, place)) {
+            if (parent instanceof KtContainerNode) {
+                if (!(place instanceof KtBlockExpression) && !isBadContainerNode((KtContainerNode)parent, place)) {
                     result = parent;
                 }
             }
-            else if (parent instanceof JetClassBody || parent instanceof JetFile) {
+            else if (parent instanceof KtClassBody || parent instanceof KtFile) {
                 return result;
             }
-            else if (parent instanceof JetBlockExpression) {
+            else if (parent instanceof KtBlockExpression) {
                 result = parent;
             }
-            else if (parent instanceof JetWhenEntry) {
-                if (!(place instanceof JetBlockExpression)) {
+            else if (parent instanceof KtWhenEntry) {
+                if (!(place instanceof KtBlockExpression)) {
                     result = parent;
                 }
             }
-            else if (parent instanceof JetDeclarationWithBody) {
-                JetDeclarationWithBody function = (JetDeclarationWithBody)parent;
+            else if (parent instanceof KtDeclarationWithBody) {
+                KtDeclarationWithBody function = (KtDeclarationWithBody)parent;
                 if (function.getBodyExpression() == place) {
-                    if (!(place instanceof JetBlockExpression)) {
+                    if (!(place instanceof KtBlockExpression)) {
                         result = parent;
                     }
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinVariableInplaceIntroducer.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinVariableInplaceIntroducer.kt
index f7f2625a616..e015072c6d1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinVariableInplaceIntroducer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinVariableInplaceIntroducer.kt
@@ -33,25 +33,25 @@ import org.jetbrains.kotlin.idea.intentions.SpecifyTypeExplicitlyIntention
 import org.jetbrains.kotlin.idea.refactoring.introduce.AbstractKotlinInplaceIntroducer
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.awt.BorderLayout
 
 public class KotlinVariableInplaceIntroducer(
-        val addedVariable: JetProperty,
-        val originalExpression: JetExpression?,
-        val occurrencesToReplace: Array<JetExpression>,
+        val addedVariable: KtProperty,
+        val originalExpression: KtExpression?,
+        val occurrencesToReplace: Array<KtExpression>,
         suggestedNames: Collection<String>,
         val isVar: Boolean,
         val doNotChangeVar: Boolean,
-        val expressionType: JetType?,
+        val expressionType: KtType?,
         val noTypeInference: Boolean,
         project: Project,
         editor: Editor
-): AbstractKotlinInplaceIntroducer<JetProperty>(
+): AbstractKotlinInplaceIntroducer<KtProperty>(
         addedVariable,
         originalExpression,
         occurrencesToReplace,
@@ -71,7 +71,7 @@ public class KotlinVariableInplaceIntroducer(
                     myProject.executeWriteCommand(getCommandName(), getCommandName()) {
                         PsiDocumentManager.getInstance(myProject).commitDocument(myEditor.getDocument())
 
-                        val psiFactory = JetPsiFactory(myProject)
+                        val psiFactory = KtPsiFactory(myProject)
                         val keyword = if (varCheckBox.isSelected()) psiFactory.createVarKeyword() else psiFactory.createValKeyword()
                         addedVariable.getValOrVarKeyword().replace(keyword)
                     }
@@ -87,7 +87,7 @@ public class KotlinVariableInplaceIntroducer(
                     runWriteCommandAndRestart {
                         if (expressionTypeCheckBox.isSelected()) {
                             val renderedType = IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType(expressionType)
-                            addedVariable.setTypeReference(JetPsiFactory(myProject).createType(renderedType))
+                            addedVariable.setTypeReference(KtPsiFactory(myProject).createType(renderedType))
                         }
                         else {
                             addedVariable.setTypeReference(null)
@@ -101,7 +101,7 @@ public class KotlinVariableInplaceIntroducer(
 
     override fun getVariable() = addedVariable
 
-    override fun suggestNames(replaceAll: Boolean, variable: JetProperty?) = suggestedNames
+    override fun suggestNames(replaceAll: Boolean, variable: KtProperty?) = suggestedNames
 
     override fun createFieldToStartTemplateOn(replaceAll: Boolean, names: Array<out String>) = addedVariable
 
@@ -130,11 +130,11 @@ public class KotlinVariableInplaceIntroducer(
         return result
     }
 
-    override fun updateTitle(variable: JetProperty?, value: String?) {
+    override fun updateTitle(variable: KtProperty?, value: String?) {
         // No preview to update
     }
 
-    override fun deleteTemplateField(psiField: JetProperty?) {
+    override fun deleteTemplateField(psiField: KtProperty?) {
         // Do not delete introduced variable as it was created outside of in-place refactoring
     }
 
@@ -149,7 +149,7 @@ public class KotlinVariableInplaceIntroducer(
     override fun performIntroduce() {
         val newName = getInputName() ?: return
         addedVariable.setName(newName)
-        val replacement = JetPsiFactory(myProject).createExpression(newName)
+        val replacement = KtPsiFactory(myProject).createExpression(newName)
         getOccurrences().forEach {
             if (it.isValid()) {
                 it.replace(replacement)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt
index 3b2d56ace6f..3ec5a5daae2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt
@@ -61,7 +61,7 @@ import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.getJavaMemberDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
@@ -90,18 +90,18 @@ fun <T: Any> PsiElement.getAndRemoveCopyableUserData(key: Key<T>): T? {
     return data
 }
 
-fun getOrCreateKotlinFile(fileName: String, targetDir: PsiDirectory): JetFile? =
-        (targetDir.findFile(fileName) ?: createKotlinFile(fileName, targetDir)) as? JetFile
+fun getOrCreateKotlinFile(fileName: String, targetDir: PsiDirectory): KtFile? =
+        (targetDir.findFile(fileName) ?: createKotlinFile(fileName, targetDir)) as? KtFile
 
 fun createKotlinFile(fileName: String,
                      targetDir: PsiDirectory,
-                     packageName: String? = targetDir.getPackage()?.qualifiedName): JetFile {
+                     packageName: String? = targetDir.getPackage()?.qualifiedName): KtFile {
     targetDir.checkCreateFile(fileName)
     val file = PsiFileFactory.getInstance(targetDir.getProject()).createFileFromText(
-            fileName, JetFileType.INSTANCE, if (!packageName.isNullOrBlank()) "package $packageName \n\n" else ""
+            fileName, KotlinFileType.INSTANCE, if (!packageName.isNullOrBlank()) "package $packageName \n\n" else ""
     )
 
-    return targetDir.add(file) as JetFile
+    return targetDir.add(file) as KtFile
 }
 
 public fun File.toVirtualFile(): VirtualFile? = LocalFileSystem.getInstance().findFileByIoFile(this)
@@ -118,7 +118,7 @@ public fun VirtualFile.toPsiDirectory(project: Project): PsiDirectory? = PsiMana
 
 public fun PsiElement.getUsageContext(): PsiElement {
     return when (this) {
-        is JetElement -> PsiTreeUtil.getParentOfType(this, javaClass<JetNamedDeclaration>(), javaClass<JetFile>())!!
+        is KtElement -> PsiTreeUtil.getParentOfType(this, javaClass<KtNamedDeclaration>(), javaClass<KtFile>())!!
         else -> ConflictsUtil.getContainer(this)
     }
 }
@@ -126,43 +126,43 @@ public fun PsiElement.getUsageContext(): PsiElement {
 public fun PsiElement.isInJavaSourceRoot(): Boolean =
         !JavaProjectRootsUtil.isOutsideJavaSourceRoot(getContainingFile())
 
-public inline fun JetFile.createTempCopy(textTransform: (String) -> String): JetFile {
-    val tmpFile = JetPsiFactory(this).createAnalyzableFile(getName(), textTransform(getText() ?: ""), this)
+public inline fun KtFile.createTempCopy(textTransform: (String) -> String): KtFile {
+    val tmpFile = KtPsiFactory(this).createAnalyzableFile(getName(), textTransform(getText() ?: ""), this)
     tmpFile.setOriginalFile(this)
     tmpFile.suppressDiagnosticsInDebugMode = suppressDiagnosticsInDebugMode
     return tmpFile
 }
 
-public fun PsiElement.getAllExtractionContainers(strict: Boolean = true): List<JetElement> {
-    val containers = ArrayList<JetElement>()
+public fun PsiElement.getAllExtractionContainers(strict: Boolean = true): List<KtElement> {
+    val containers = ArrayList<KtElement>()
 
     var objectFound = false
     val parents = if (strict) parents else parentsWithSelf
     for (element in parents) {
         val isValidContainer = when (element) {
-            is JetFile -> true
-            is JetClassBody -> !objectFound || element.parent is JetObjectDeclaration
-            is JetBlockExpression -> !objectFound
+            is KtFile -> true
+            is KtClassBody -> !objectFound || element.parent is KtObjectDeclaration
+            is KtBlockExpression -> !objectFound
             else -> false
         }
         if (!isValidContainer) continue
 
-        containers.add(element as JetElement)
+        containers.add(element as KtElement)
 
-        ((element as? JetClassBody)?.parent as? JetObjectDeclaration)?.let { objectFound = true }
+        ((element as? KtClassBody)?.parent as? KtObjectDeclaration)?.let { objectFound = true }
     }
 
     return containers
 }
 
-public fun PsiElement.getExtractionContainers(strict: Boolean = true, includeAll: Boolean = false): List<JetElement> {
+public fun PsiElement.getExtractionContainers(strict: Boolean = true, includeAll: Boolean = false): List<KtElement> {
     fun getEnclosingDeclaration(element: PsiElement, strict: Boolean): PsiElement? {
         return (if (strict) element.parents else element.parentsWithSelf)
                 .filter {
-                    (it is JetDeclarationWithBody && it !is JetFunctionLiteral)
-                    || it is JetClassInitializer
-                    || it is JetClassBody
-                    || it is JetFile
+                    (it is KtDeclarationWithBody && it !is KtFunctionLiteral)
+                    || it is KtClassInitializer
+                    || it is KtClassBody
+                    || it is KtFile
                 }
                 .firstOrNull()
     }
@@ -170,19 +170,19 @@ public fun PsiElement.getExtractionContainers(strict: Boolean = true, includeAll
     if (includeAll) return getAllExtractionContainers(strict)
 
     val enclosingDeclaration = getEnclosingDeclaration(this, strict)?.let {
-        if (it is JetDeclarationWithBody || it is JetClassInitializer) getEnclosingDeclaration(it, true) else it
+        if (it is KtDeclarationWithBody || it is KtClassInitializer) getEnclosingDeclaration(it, true) else it
     }
 
     return when (enclosingDeclaration) {
-        is JetFile -> Collections.singletonList(enclosingDeclaration)
-        is JetClassBody -> getAllExtractionContainers(strict).filterIsInstance<JetClassBody>()
+        is KtFile -> Collections.singletonList(enclosingDeclaration)
+        is KtClassBody -> getAllExtractionContainers(strict).filterIsInstance<KtClassBody>()
         else -> {
             val targetContainer = when (enclosingDeclaration) {
-                is JetDeclarationWithBody -> enclosingDeclaration.getBodyExpression()
-                is JetClassInitializer -> enclosingDeclaration.getBody()
+                is KtDeclarationWithBody -> enclosingDeclaration.getBodyExpression()
+                is KtClassInitializer -> enclosingDeclaration.getBody()
                 else -> null
             }
-            if (targetContainer is JetBlockExpression) Collections.singletonList(targetContainer) else Collections.emptyList()
+            if (targetContainer is KtBlockExpression) Collections.singletonList(targetContainer) else Collections.emptyList()
         }
     }
 }
@@ -321,15 +321,15 @@ fun PsiElement.getLineCount(): Int {
 
 fun PsiElement.isMultiLine(): Boolean = getLineCount() > 1
 
-public fun JetElement.getContextForContainingDeclarationBody(): BindingContext? {
-    val enclosingDeclaration = getStrictParentOfType<JetDeclaration>()
+public fun KtElement.getContextForContainingDeclarationBody(): BindingContext? {
+    val enclosingDeclaration = getStrictParentOfType<KtDeclaration>()
     val bodyElement = when (enclosingDeclaration) {
-        is JetDeclarationWithBody -> enclosingDeclaration.getBodyExpression()
-        is JetWithExpressionInitializer -> enclosingDeclaration.getInitializer()
-        is JetMultiDeclaration -> enclosingDeclaration.getInitializer()
-        is JetParameter -> enclosingDeclaration.getDefaultValue()
-        is JetClassInitializer -> enclosingDeclaration.getBody()
-        is JetClass -> {
+        is KtDeclarationWithBody -> enclosingDeclaration.getBodyExpression()
+        is KtWithExpressionInitializer -> enclosingDeclaration.getInitializer()
+        is KtMultiDeclaration -> enclosingDeclaration.getInitializer()
+        is KtParameter -> enclosingDeclaration.getDefaultValue()
+        is KtClassInitializer -> enclosingDeclaration.getBody()
+        is KtClass -> {
             val delegationSpecifierList = enclosingDeclaration.getDelegationSpecifierList()
             if (delegationSpecifierList.isAncestor(this)) this else null
         }
@@ -350,19 +350,19 @@ public fun chooseContainerElement<T>(
             containers,
             object : PsiElementListCellRenderer<PsiElement>() {
                 private fun PsiElement.renderName(): String {
-                    if (this is JetPropertyAccessor) {
-                        return (getParent() as JetProperty).renderName() + if (isGetter()) ".get" else ".set"
+                    if (this is KtPropertyAccessor) {
+                        return (getParent() as KtProperty).renderName() + if (isGetter()) ".get" else ".set"
                     }
-                    if (this is JetObjectDeclaration && this.isCompanion()) {
-                        return "Companion object of ${getStrictParentOfType<JetClassOrObject>()?.renderName() ?: "<anonymous>"}"
+                    if (this is KtObjectDeclaration && this.isCompanion()) {
+                        return "Companion object of ${getStrictParentOfType<KtClassOrObject>()?.renderName() ?: "<anonymous>"}"
                     }
                     return (this as? PsiNamedElement)?.getName() ?: "<anonymous>"
                 }
 
                 private fun PsiElement.renderDeclaration(): String? {
                     val descriptor = when {
-                        this is JetFile -> getName()
-                        this is JetElement -> analyze()[BindingContext.DECLARATION_TO_DESCRIPTOR, this]
+                        this is KtFile -> getName()
+                        this is KtElement -> analyze()[BindingContext.DECLARATION_TO_DESCRIPTOR, this]
                         this is PsiMember -> getJavaMemberDescriptor()
                         else -> null
                     } ?: return null
@@ -381,8 +381,8 @@ public fun chooseContainerElement<T>(
 
                 private fun PsiElement.getRepresentativeElement(): PsiElement {
                     return when (this) {
-                        is JetBlockExpression -> (getParent() as? JetDeclarationWithBody) ?: this
-                        is JetClassBody -> getParent() as JetClassOrObject
+                        is KtBlockExpression -> (getParent() as? KtDeclarationWithBody) ?: this
+                        is KtClassBody -> getParent() as KtClassOrObject
                         else -> this
                     }
                 }
@@ -430,7 +430,7 @@ public fun PsiElement.canRefactor(): Boolean {
     return when {
         this is PsiPackage ->
             getDirectories().any { it.canRefactor() }
-        this is JetElement,
+        this is KtElement,
         this is PsiMember && getLanguage() == JavaLanguage.INSTANCE,
         this is PsiDirectory ->
             isWritable() && ProjectRootsUtil.isInProjectSource(this)
@@ -478,7 +478,7 @@ private fun copyTypeParameters<T>(
     }
 }
 
-public fun createJavaMethod(function: JetFunction, targetClass: PsiClass): PsiMethod {
+public fun createJavaMethod(function: KtFunction, targetClass: PsiClass): PsiMethod {
     val template = LightClassUtil.getLightClassMethod(function)
                    ?: throw AssertionError("Can't generate light method: ${function.getElementTextWithContext()}")
     return createJavaMethod(template, targetClass)
@@ -526,7 +526,7 @@ public fun createJavaMethod(template: PsiMethod, targetClass: PsiClass): PsiMeth
     return method
 }
 
-fun createJavaField(property: JetProperty, targetClass: PsiClass): PsiField {
+fun createJavaField(property: KtProperty, targetClass: PsiClass): PsiField {
     val template = LightClassUtil.getLightClassPropertyMethods(property).getter
                    ?: throw AssertionError("Can't generate light method: ${property.getElementTextWithContext()}")
 
@@ -545,7 +545,7 @@ fun createJavaField(property: JetProperty, targetClass: PsiClass): PsiField {
     return field
 }
 
-fun createJavaClass(klass: JetClass, targetClass: PsiClass?, forcePlainClass: Boolean = false): PsiClass {
+fun createJavaClass(klass: KtClass, targetClass: PsiClass?, forcePlainClass: Boolean = false): PsiClass {
     val kind = if (forcePlainClass) ClassKind.CLASS else (klass.resolveToDescriptor() as ClassDescriptor).getKind()
 
     val factory = PsiElementFactory.SERVICE.getInstance(klass.getProject())
@@ -619,14 +619,14 @@ fun PsiElement.j2kText(): String? {
     return j2kConverter.elementsToKotlin(listOf(this)).results.single()?.text ?: return null //TODO: insert imports
 }
 
-fun PsiExpression.j2k(): JetExpression? {
+fun PsiExpression.j2k(): KtExpression? {
     val text = j2kText() ?: return null
-    return JetPsiFactory(project).createExpression(text)
+    return KtPsiFactory(project).createExpression(text)
 }
 
-fun PsiMember.j2k(): JetNamedDeclaration? {
+fun PsiMember.j2k(): KtNamedDeclaration? {
     val text = j2kText() ?: return null
-    return JetPsiFactory(project).createDeclaration(text)
+    return KtPsiFactory(project).createDeclaration(text)
 }
 
 public fun (() -> Any).runRefactoringWithPostprocessing(
@@ -664,7 +664,7 @@ public fun (() -> Any).runRefactoringWithPostprocessing(
 }
 
 @Throws(ConfigurationException::class)
-public fun JetElement.validateElement(errorMessage: String) {
+public fun KtElement.validateElement(errorMessage: String) {
     try {
         AnalyzingUtils.checkForSyntacticErrors(this)
     }
@@ -694,18 +694,18 @@ public fun String.quoteIfNeeded(): String = if (KotlinNameSuggester.isIdentifier
 
 public fun FqNameBase.hasIdentifiersOnly(): Boolean = pathSegments().all { KotlinNameSuggester.isIdentifier(it.asString()) }
 
-public fun JetClass.createPrimaryConstructorIfAbsent(): JetPrimaryConstructor {
+public fun KtClass.createPrimaryConstructorIfAbsent(): KtPrimaryConstructor {
     val constructor = getPrimaryConstructor()
     if (constructor != null) return constructor
     var anchor: PsiElement? = typeParameterList
     if (anchor == null) anchor = nameIdentifier
     if (anchor == null) anchor = lastChild
-    return addAfter(JetPsiFactory(project).createPrimaryConstructor(), anchor) as JetPrimaryConstructor
+    return addAfter(KtPsiFactory(project).createPrimaryConstructor(), anchor) as KtPrimaryConstructor
 }
 
-public fun JetClass.createPrimaryConstructorParameterListIfAbsent(): JetParameterList {
+public fun KtClass.createPrimaryConstructorParameterListIfAbsent(): KtParameterList {
     val constructor = createPrimaryConstructorIfAbsent()
     val parameterList = constructor.valueParameterList
     if (parameterList != null) return parameterList
-    return constructor.add(JetPsiFactory(project).createParameterList("()")) as JetParameterList
+    return constructor.add(KtPsiFactory(project).createParameterList("()")) as KtParameterList
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfo.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfo.kt
index 99ed696f41a..88d26d36093 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfo.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfo.kt
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.renderer.DescriptorRendererModifier
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptySet
 
-public class KotlinMemberInfo(member: JetNamedDeclaration, val isSuperClass: Boolean = false) : MemberInfoBase<JetNamedDeclaration>(member) {
+public class KotlinMemberInfo(member: KtNamedDeclaration, val isSuperClass: Boolean = false) : MemberInfoBase<KtNamedDeclaration>(member) {
     companion object {
         private val RENDERER = IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.withOptions {
             modifiers = DescriptorRendererModifier.INNER.singletonOrEmptySet()
@@ -40,9 +40,9 @@ public class KotlinMemberInfo(member: JetNamedDeclaration, val isSuperClass: Boo
 
     init {
         val memberDescriptor = member.resolveToDescriptor()
-        isStatic = member.parent is JetFile
+        isStatic = member.parent is KtFile
 
-        if (member is JetClass && isSuperClass) {
+        if (member is KtClass && isSuperClass) {
             if (member.isInterface()) {
                 displayName = RefactoringBundle.message("member.info.implements.0", member.name)
                 overrides = false
@@ -69,8 +69,8 @@ public class KotlinMemberInfo(member: JetNamedDeclaration, val isSuperClass: Boo
 public fun KotlinMemberInfo.toJavaMemberInfo(): MemberInfo? {
     val declaration = member
     val psiMember: PsiMember? = when (declaration) {
-        is JetNamedFunction, is JetProperty -> declaration.getRepresentativeLightMethod()
-        is JetClassOrObject -> declaration.toLightClass()
+        is KtNamedFunction, is KtProperty -> declaration.getRepresentativeLightMethod()
+        is KtClassOrObject -> declaration.toLightClass()
         else -> null
     }
     if (psiMember == null) return null
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt
index 03f1598b5ba..1f31877dd50 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt
@@ -34,9 +34,9 @@ import java.util.ArrayList
 
 public class KotlinMemberInfoStorage(
         classOrObject: PsiNamedElement,
-        filter: (JetNamedDeclaration) -> Boolean = { true }
-): AbstractMemberInfoStorage<JetNamedDeclaration, PsiNamedElement, KotlinMemberInfo>(classOrObject, filter) {
-    override fun memberConflict(member1: JetNamedDeclaration, member: JetNamedDeclaration): Boolean {
+        filter: (KtNamedDeclaration) -> Boolean = { true }
+): AbstractMemberInfoStorage<KtNamedDeclaration, PsiNamedElement, KotlinMemberInfo>(classOrObject, filter) {
+    override fun memberConflict(member1: KtNamedDeclaration, member: KtNamedDeclaration): Boolean {
         val descriptor1 = member1.resolveToDescriptor()
         val descriptor = member.resolveToDescriptor()
         if (descriptor1.name != descriptor.name) return false
@@ -56,7 +56,7 @@ public class KotlinMemberInfoStorage(
         val classType = classDescriptor.defaultType
         for (supertype in classType.immediateSupertypes()) {
             val superClass = supertype.constructor.declarationDescriptor?.source?.getPsi()
-            if (superClass is JetClass || superClass is PsiClass) {
+            if (superClass is KtClass || superClass is PsiClass) {
                 getSubclasses(superClass as PsiNamedElement).add(aClass)
                 buildSubClassesMap(superClass)
             }
@@ -70,21 +70,21 @@ public class KotlinMemberInfoStorage(
     }
 
     override fun extractClassMembers(aClass: PsiNamedElement, temp: ArrayList<KotlinMemberInfo>) {
-        if (aClass !is JetClassOrObject) return
+        if (aClass !is KtClassOrObject) return
 
         val context = aClass.analyze()
         aClass.declarations
-                .filter { it is JetNamedDeclaration
-                          && it !is JetConstructor<*>
-                          && !(it is JetObjectDeclaration && it.isCompanion())
+                .filter { it is KtNamedDeclaration
+                          && it !is KtConstructor<*>
+                          && !(it is KtObjectDeclaration && it.isCompanion())
                           && myFilter.includeMember(it) }
-                .mapTo(temp) { KotlinMemberInfo(it as JetNamedDeclaration) }
+                .mapTo(temp) { KotlinMemberInfo(it as KtNamedDeclaration) }
         aClass.getDelegationSpecifiers()
-                .filterIsInstance<JetDelegatorToSuperClass>()
+                .filterIsInstance<KtDelegatorToSuperClass>()
                 .map {
                     val type = context[BindingContext.TYPE, it.typeReference]
                     val classDescriptor = type?.constructor?.declarationDescriptor as? ClassDescriptor
-                    classDescriptor?.source?.getPsi() as? JetClass
+                    classDescriptor?.source?.getPsi() as? KtClass
                 }
                 .filter { it != null && it.isInterface() }
                 .mapTo(temp) { KotlinMemberInfo(it!!, true) }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionPanel.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionPanel.kt
index cbfb45fa2ad..0ffe408228b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionPanel.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionPanel.kt
@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.idea.refactoring.memberInfo
 import com.intellij.refactoring.ui.AbstractMemberSelectionPanel
 import com.intellij.ui.ScrollPaneFactory
 import com.intellij.ui.SeparatorFactory
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import java.awt.BorderLayout
 
 public class KotlinMemberSelectionPanel(title: String,
                                         memberInfo: List<KotlinMemberInfo>,
                                         abstractColumnHeader: String?
-) : AbstractMemberSelectionPanel<JetNamedDeclaration, KotlinMemberInfo>() {
+) : AbstractMemberSelectionPanel<KtNamedDeclaration, KotlinMemberInfo>() {
     private val table = createMemberSelectionTable(memberInfo, abstractColumnHeader)
 
     init {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionTable.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionTable.kt
index 2cee0e6e9cd..c356c71e61d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionTable.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionTable.kt
@@ -21,24 +21,24 @@ import com.intellij.refactoring.classMembers.MemberInfoModel
 import com.intellij.refactoring.ui.AbstractMemberSelectionTable
 import com.intellij.ui.RowIcon
 import org.jetbrains.kotlin.idea.JetIconProvider
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtProperty
 import javax.swing.Icon
 
 public class KotlinMemberSelectionTable(
         memberInfos: List<KotlinMemberInfo>,
-        memberInfoModel: MemberInfoModel<JetNamedDeclaration, KotlinMemberInfo>?,
+        memberInfoModel: MemberInfoModel<KtNamedDeclaration, KotlinMemberInfo>?,
         abstractColumnHeader: String?
-) : AbstractMemberSelectionTable<JetNamedDeclaration, KotlinMemberInfo>(memberInfos, memberInfoModel, abstractColumnHeader) {
+) : AbstractMemberSelectionTable<KtNamedDeclaration, KotlinMemberInfo>(memberInfos, memberInfoModel, abstractColumnHeader) {
     override fun getAbstractColumnValue(memberInfo: KotlinMemberInfo): Any? {
         if (memberInfo.isStatic()) return null
 
         val member = memberInfo.member
-        if (member !is JetNamedFunction && member !is JetProperty) return null
+        if (member !is KtNamedFunction && member !is KtProperty) return null
 
-        if (member.hasModifier(JetTokens.ABSTRACT_KEYWORD)) {
+        if (member.hasModifier(KtTokens.ABSTRACT_KEYWORD)) {
             myMemberInfoModel.isFixedAbstract(memberInfo)?.let { return it }
         }
         if (myMemberInfoModel.isAbstractEnabled(memberInfo)) return memberInfo.isToAbstract
@@ -51,9 +51,9 @@ public class KotlinMemberSelectionTable(
         if (memberInfo.isStatic()) return false
 
         val member = memberInfo.member
-        if (member !is JetNamedFunction && member !is JetProperty) return false
+        if (member !is KtNamedFunction && member !is KtProperty) return false
 
-        if (member.hasModifier(JetTokens.ABSTRACT_KEYWORD)) {
+        if (member.hasModifier(KtTokens.ABSTRACT_KEYWORD)) {
             myMemberInfoModel.isFixedAbstract(memberInfo)?.let { return false }
         }
 
@@ -68,7 +68,7 @@ public class KotlinMemberSelectionTable(
         val defaultIcon = AbstractMemberSelectionTable.EMPTY_OVERRIDE_ICON
 
         val member = memberInfo.member
-        if (member !is JetNamedFunction && member !is JetProperty) return defaultIcon
+        if (member !is KtNamedFunction && member !is KtProperty) return defaultIcon
 
         return when (memberInfo.getOverrides()) {
             true -> AllIcons.General.OverridingMethod
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/memberInfoUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/memberInfoUtils.kt
index 1ae009fe702..5d2f20010d5 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/memberInfoUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/memberInfoUtils.kt
@@ -24,15 +24,15 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.getJavaClassDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 
 fun PsiNamedElement.getClassDescriptorIfAny(resolutionFacade: ResolutionFacade? = null): ClassDescriptor? {
     return when (this) {
-        is JetClass -> (resolutionFacade ?: getResolutionFacade()).resolveToDescriptor(this) as ClassDescriptor
+        is KtClass -> (resolutionFacade ?: getResolutionFacade()).resolveToDescriptor(this) as ClassDescriptor
         is PsiClass -> getJavaClassDescriptor()
         else -> null
     }
@@ -40,7 +40,7 @@ fun PsiNamedElement.getClassDescriptorIfAny(resolutionFacade: ResolutionFacade?
 
 fun PsiNamedElement.isAbstractMember(): Boolean {
     return when(this) {
-        is JetNamedDeclaration -> hasModifier(JetTokens.ABSTRACT_KEYWORD)
+        is KtNamedDeclaration -> hasModifier(KtTokens.ABSTRACT_KEYWORD)
         is PsiMember -> hasModifierProperty(PsiModifier.ABSTRACT)
         else -> false
     }
@@ -49,7 +49,7 @@ fun PsiNamedElement.isAbstractMember(): Boolean {
 // Applies to JetClassOrObject and PsiClass
 public fun PsiNamedElement.qualifiedClassNameForRendering(): String {
     val fqName = when (this) {
-        is JetClassOrObject -> fqName?.asString()
+        is KtClassOrObject -> fqName?.asString()
         is PsiClass -> qualifiedName
         else -> throw AssertionError("Not a class: ${getElementTextWithContext()}")
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/MoveJavaInnerClassKotlinUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/MoveJavaInnerClassKotlinUsagesHandler.kt
index 4ab4c538c94..c418a788497 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/MoveJavaInnerClassKotlinUsagesHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/MoveJavaInnerClassKotlinUsagesHandler.kt
@@ -19,31 +19,31 @@ package org.jetbrains.kotlin.idea.refactoring.move
 import com.intellij.refactoring.move.moveInner.MoveInnerClassUsagesHandler
 import com.intellij.usageView.UsageInfo
 import com.intellij.psi.PsiClass
-import org.jetbrains.kotlin.psi.JetQualifiedExpression
+import org.jetbrains.kotlin.psi.KtQualifiedExpression
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElementSelector
-import org.jetbrains.kotlin.psi.JetCallExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtCallExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import java.util.ArrayList
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.psi.PsiWhiteSpace
 import org.jetbrains.kotlin.idea.references.mainReference
 
 public class MoveJavaInnerClassKotlinUsagesHandler: MoveInnerClassUsagesHandler {
     override fun correctInnerClassUsage(usage: UsageInfo, outerClass: PsiClass) {
-        val innerCall = usage.getElement()?.getParent() as? JetCallExpression ?: return
+        val innerCall = usage.getElement()?.getParent() as? KtCallExpression ?: return
 
-        val receiver = (innerCall.getParent() as? JetQualifiedExpression)?.getReceiverExpression()
+        val receiver = (innerCall.getParent() as? KtQualifiedExpression)?.getReceiverExpression()
         val outerClassRef = when (receiver) {
-            is JetCallExpression -> receiver.getCalleeExpression()
-            is JetQualifiedExpression -> receiver.getQualifiedElementSelector()
+            is KtCallExpression -> receiver.getCalleeExpression()
+            is KtQualifiedExpression -> receiver.getQualifiedElementSelector()
             else -> null
-        } as? JetSimpleNameExpression
+        } as? KtSimpleNameExpression
         if (outerClassRef?.mainReference?.resolve() != outerClass) return
 
-        val outerCall = outerClassRef!!.getParent() as? JetCallExpression ?: return
+        val outerCall = outerClassRef!!.getParent() as? KtCallExpression ?: return
 
-        val psiFactory = JetPsiFactory(usage.getProject())
+        val psiFactory = KtPsiFactory(usage.getProject())
 
         val argumentList = innerCall.getValueArgumentList()
         if (argumentList != null) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/ChangePackageIntention.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/ChangePackageIntention.kt
index 6e4056ea5c9..5f056e5e0ae 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/ChangePackageIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/ChangePackageIntention.kt
@@ -29,16 +29,16 @@ import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingOffsetIndependentInt
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.FqNameUnsafe
-import org.jetbrains.kotlin.psi.JetPackageDirective
+import org.jetbrains.kotlin.psi.KtPackageDirective
 
-public class ChangePackageIntention: JetSelfTargetingOffsetIndependentIntention<JetPackageDirective>(javaClass(), "Change package") {
+public class ChangePackageIntention: JetSelfTargetingOffsetIndependentIntention<KtPackageDirective>(javaClass(), "Change package") {
     companion object {
         private val PACKAGE_NAME_VAR = "PACKAGE_NAME"
     }
 
-    override fun isApplicableTo(element: JetPackageDirective) = element.getPackageNameExpression() != null
+    override fun isApplicableTo(element: KtPackageDirective) = element.getPackageNameExpression() != null
 
-    override fun applyTo(element: JetPackageDirective, editor: Editor) {
+    override fun applyTo(element: KtPackageDirective, editor: Editor) {
         if (ApplicationManager.getApplication().isUnitTestMode()) {
             throw UnsupportedOperationException("Do not call applyTo() in the test mode")
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/ChangePackageToMatchDirectoryIntention.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/ChangePackageToMatchDirectoryIntention.kt
index 40615bbe67e..1f0063d33db 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/ChangePackageToMatchDirectoryIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/ChangePackageToMatchDirectoryIntention.kt
@@ -21,12 +21,12 @@ import org.jetbrains.kotlin.idea.core.getFqNameByDirectory
 import org.jetbrains.kotlin.idea.core.packageMatchesDirectory
 import org.jetbrains.kotlin.idea.core.refactoring.hasIdentifiersOnly
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingOffsetIndependentIntention
-import org.jetbrains.kotlin.psi.JetPackageDirective
+import org.jetbrains.kotlin.psi.KtPackageDirective
 
-public class ChangePackageToMatchDirectoryIntention : JetSelfTargetingOffsetIndependentIntention<JetPackageDirective>(
+public class ChangePackageToMatchDirectoryIntention : JetSelfTargetingOffsetIndependentIntention<KtPackageDirective>(
         javaClass(), "", "Change file's package to match directory"
 ) {
-    override fun isApplicableTo(element: JetPackageDirective): Boolean {
+    override fun isApplicableTo(element: KtPackageDirective): Boolean {
         val file = element.getContainingJetFile()
         if (file.packageMatchesDirectory()) return false
 
@@ -43,7 +43,7 @@ public class ChangePackageToMatchDirectoryIntention : JetSelfTargetingOffsetInde
         return true
     }
 
-    override fun applyTo(element: JetPackageDirective, editor: Editor) {
+    override fun applyTo(element: KtPackageDirective, editor: Editor) {
         val file = element.getContainingJetFile()
         val newFqName = file.getFqNameByDirectory()
         if (!newFqName.hasIdentifiersOnly()) return
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/KotlinChangePackageRefactoring.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/KotlinChangePackageRefactoring.kt
index 1a038881afa..1943225c68d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/KotlinChangePackageRefactoring.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/KotlinChangePackageRefactoring.kt
@@ -29,10 +29,10 @@ import org.jetbrains.kotlin.idea.refactoring.move.moveTopLevelDeclarations.Mover
 import org.jetbrains.kotlin.idea.refactoring.move.postProcessMoveUsages
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 
-public class KotlinChangePackageRefactoring(val file: JetFile) {
+public class KotlinChangePackageRefactoring(val file: KtFile) {
     private val project = file.getProject()
 
     fun run(newFqName: FqName) {
@@ -42,7 +42,7 @@ public class KotlinChangePackageRefactoring(val file: JetFile) {
         val declarationProcessor = MoveKotlinTopLevelDeclarationsProcessor(
                 project,
                 MoveKotlinTopLevelDeclarationsOptions(
-                        elementsToMove = file.getDeclarations().filterIsInstance<JetNamedDeclaration>(),
+                        elementsToMove = file.getDeclarations().filterIsInstance<KtNamedDeclaration>(),
                         moveTarget = object: KotlinMoveTarget {
                             override val packageWrapper = PackageWrapper(file.getManager(), newFqName.asString())
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/MoveFileToPackageMatchingDirectoryIntention.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/MoveFileToPackageMatchingDirectoryIntention.kt
index c2c330127ac..3b6880de758 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/MoveFileToPackageMatchingDirectoryIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/MoveFileToPackageMatchingDirectoryIntention.kt
@@ -26,13 +26,13 @@ import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectori
 import com.intellij.refactoring.util.RefactoringMessageUtil
 import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingOffsetIndependentIntention
-import org.jetbrains.kotlin.psi.JetPackageDirective
+import org.jetbrains.kotlin.psi.KtPackageDirective
 import org.jetbrains.kotlin.idea.core.packageMatchesDirectory
 
-public class MoveFileToPackageMatchingDirectoryIntention : JetSelfTargetingOffsetIndependentIntention<JetPackageDirective>(
+public class MoveFileToPackageMatchingDirectoryIntention : JetSelfTargetingOffsetIndependentIntention<KtPackageDirective>(
         javaClass(), "", "Move file to package-matching directory"
 ) {
-    override fun isApplicableTo(element: JetPackageDirective): Boolean {
+    override fun isApplicableTo(element: KtPackageDirective): Boolean {
         if (element.getContainingJetFile().packageMatchesDirectory()) return false
 
         val qualifiedName = element.getQualifiedName()
@@ -41,7 +41,7 @@ public class MoveFileToPackageMatchingDirectoryIntention : JetSelfTargetingOffse
         return true
     }
 
-    override fun applyTo(element: JetPackageDirective, editor: Editor) {
+    override fun applyTo(element: KtPackageDirective, editor: Editor) {
         val file = element.getContainingJetFile()
         val project = file.getProject()
         val targetDirectory = MoveClassesOrPackagesUtil.chooseDestinationPackage(
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/PackageDirectoryMismatchInspection.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/PackageDirectoryMismatchInspection.kt
index e50d666ad9e..866e4103322 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/PackageDirectoryMismatchInspection.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/PackageDirectoryMismatchInspection.kt
@@ -17,9 +17,9 @@
 package org.jetbrains.kotlin.idea.refactoring.move.changePackage
 
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
-import org.jetbrains.kotlin.psi.JetPackageDirective
+import org.jetbrains.kotlin.psi.KtPackageDirective
 
-public class PackageDirectoryMismatchInspection: IntentionBasedInspection<JetPackageDirective>(
+public class PackageDirectoryMismatchInspection: IntentionBasedInspection<KtPackageDirective>(
         listOf(IntentionBasedInspection.IntentionData(MoveFileToPackageMatchingDirectoryIntention()), IntentionBasedInspection.IntentionData(ChangePackageToMatchDirectoryIntention())),
         "Package directive doesn't match file location",
         javaClass()
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/KotlinMoveDirectoryWithClassesHelper.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/KotlinMoveDirectoryWithClassesHelper.kt
index bb42f9361e9..2c42aec542e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/KotlinMoveDirectoryWithClassesHelper.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/KotlinMoveDirectoryWithClassesHelper.kt
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.idea.core.getPackage
 import org.jetbrains.kotlin.idea.core.refactoring.invokeOnceOnCommandFinish
 import org.jetbrains.kotlin.idea.refactoring.move.moveTopLevelDeclarations.MoveKotlinTopLevelDeclarationsProcessor
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import java.util.ArrayList
 import java.util.HashMap
 
@@ -66,7 +66,7 @@ public class KotlinMoveDirectoryWithClassesHelper : MoveDirectoryWithClassesHelp
             searchInNonJavaFiles: Boolean,
             project: Project) {
         filesToMove
-                .filterIsInstance<JetFile>()
+                .filterIsInstance<KtFile>()
                 .mapTo(result) { FileUsagesWrapper(it, fileHandler.findUsages(it, null, searchInComments, searchInNonJavaFiles), null) }
     }
 
@@ -82,7 +82,7 @@ public class KotlinMoveDirectoryWithClassesHelper : MoveDirectoryWithClassesHelp
             movedFiles: MutableList<PsiFile>,
             listener: RefactoringElementListener?
     ): Boolean {
-        if (file !is JetFile) return false
+        if (file !is KtFile) return false
 
         val moveDeclarationsProcessor = fileHandler.initMoveProcessor(file, moveDestination)
         val moveContextMap = getOrCreateMoveContextMap()
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/KotlinMoveFilesOrDirectoriesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/KotlinMoveFilesOrDirectoriesHandler.kt
index 068b0d49e86..692b45c760b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/KotlinMoveFilesOrDirectoriesHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/KotlinMoveFilesOrDirectoriesHandler.kt
@@ -21,8 +21,8 @@ import com.intellij.psi.*
 import com.intellij.refactoring.move.MoveCallback
 import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesHandler
 import org.jetbrains.kotlin.idea.refactoring.move.*
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtFile
 
 public class KotlinMoveFilesOrDirectoriesHandler : MoveFilesOrDirectoriesHandler() {
     private fun adjustElements(elements: Array<out PsiElement>): Array<PsiElement>? {
@@ -30,7 +30,7 @@ public class KotlinMoveFilesOrDirectoriesHandler : MoveFilesOrDirectoriesHandler
             when {
                 it is PsiFile, it is PsiDirectory -> it
                 it is PsiClass && it.getContainingClass() == null -> it.getContainingFile()
-                it is JetClassOrObject && it.getParent() is JetFile -> it.getParent()
+                it is KtClassOrObject && it.getParent() is KtFile -> it.getParent()
                 else -> return null
             }
         }.toTypedArray()
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/MoveKotlinFileHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/MoveKotlinFileHandler.kt
index f2e59d3c0a0..6e1997749b1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/MoveKotlinFileHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/MoveKotlinFileHandler.kt
@@ -31,13 +31,13 @@ import org.jetbrains.kotlin.idea.core.refactoring.hasIdentifiersOnly
 import org.jetbrains.kotlin.idea.refactoring.move.*
 import org.jetbrains.kotlin.idea.refactoring.move.moveTopLevelDeclarations.*
 import org.jetbrains.kotlin.name.FqNameUnsafe
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import java.util.*
 
 public class MoveKotlinFileHandler : MoveFileHandler() {
-    internal class InternalUsagesWrapper(file: JetFile, val usages: List<UsageInfo>) : UsageInfo(file)
+    internal class InternalUsagesWrapper(file: KtFile, val usages: List<UsageInfo>) : UsageInfo(file)
 
     // This is special 'PsiElement' whose purpose is to wrap MoveKotlinTopLevelDeclarationsProcessor
     // so that it can be kept in the transition map
@@ -48,7 +48,7 @@ public class MoveKotlinFileHandler : MoveFileHandler() {
         override fun toString() = ""
     }
 
-    private fun JetFile.getPackageNameInfo(newParent: PsiDirectory?, clearUserData: Boolean): PackageNameInfo? {
+    private fun KtFile.getPackageNameInfo(newParent: PsiDirectory?, clearUserData: Boolean): PackageNameInfo? {
         val shouldUpdatePackageDirective = updatePackageDirective ?: packageMatchesDirectory()
         updatePackageDirective = if (clearUserData) null else shouldUpdatePackageDirective
 
@@ -65,7 +65,7 @@ public class MoveKotlinFileHandler : MoveFileHandler() {
     }
 
     fun initMoveProcessor(psiFile: PsiFile, newParent: PsiDirectory?): MoveKotlinTopLevelDeclarationsProcessor? {
-        if (psiFile !is JetFile) return null
+        if (psiFile !is KtFile) return null
         val packageNameInfo = psiFile.getPackageNameInfo(newParent, false) ?: return null
 
         val project = psiFile.project
@@ -76,14 +76,14 @@ public class MoveKotlinFileHandler : MoveFileHandler() {
 
             else -> DeferredJetFileKotlinMoveTarget(project, newPackageName.toSafe()) {
                 MoveFilesOrDirectoriesUtil.doMoveFile(psiFile, newParent)
-                newParent?.findFile(psiFile.name) as? JetFile
+                newParent?.findFile(psiFile.name) as? KtFile
             }
         }
 
         val declarationMoveProcessor = MoveKotlinTopLevelDeclarationsProcessor(
                 project,
                 MoveKotlinTopLevelDeclarationsOptions(
-                        elementsToMove = psiFile.declarations.filterIsInstance<JetNamedDeclaration>(),
+                        elementsToMove = psiFile.declarations.filterIsInstance<KtNamedDeclaration>(),
                         moveTarget = moveTarget,
                         updateInternalReferences = false
                 ),
@@ -93,11 +93,11 @@ public class MoveKotlinFileHandler : MoveFileHandler() {
     }
 
     override fun canProcessElement(element: PsiFile?): Boolean {
-        if (element is PsiCompiledElement || element !is JetFile) return false
+        if (element is PsiCompiledElement || element !is KtFile) return false
         return !JavaProjectRootsUtil.isOutsideJavaSourceRoot(element)
     }
 
-    fun findInternalUsages(file: JetFile, newParent: PsiDirectory): InternalUsagesWrapper {
+    fun findInternalUsages(file: KtFile, newParent: PsiDirectory): InternalUsagesWrapper {
         val packageNameInfo = file.getPackageNameInfo(newParent, false)
         val usages = packageNameInfo?.let { file.getInternalReferencesToUpdateOnPackageNameChange(it) } ?: emptyList()
         return InternalUsagesWrapper(file, usages)
@@ -109,7 +109,7 @@ public class MoveKotlinFileHandler : MoveFileHandler() {
             searchInComments: Boolean,
             searchInNonJavaFiles: Boolean
     ): List<UsageInfo> {
-        if (psiFile !is JetFile) return emptyList()
+        if (psiFile !is KtFile) return emptyList()
 
         val usages = ArrayList<UsageInfo>()
         initMoveProcessor(psiFile, newParent)?.findUsages()?.let { usages += it }
@@ -124,7 +124,7 @@ public class MoveKotlinFileHandler : MoveFileHandler() {
     }
 
     override fun updateMovedFile(file: PsiFile) {
-        if (file !is JetFile) return
+        if (file !is KtFile) return
         val newDirectory = file.parent ?: return
         val packageNameInfo = file.getPackageNameInfo(newDirectory, true) ?: return
         val newPackageName = packageNameInfo.newPackageName
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/KotlinMoveTarget.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/KotlinMoveTarget.kt
index 91d9f9148f5..3767426b20d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/KotlinMoveTarget.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/KotlinMoveTarget.kt
@@ -22,7 +22,7 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiManager
 import com.intellij.refactoring.PackageWrapper
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import java.util.HashMap
 
 public interface KotlinMoveTarget {
@@ -41,7 +41,7 @@ public object EmptyKotlinMoveTarget: KotlinMoveTarget {
     override fun verify(file: PsiFile) = null
 }
 
-public class JetFileKotlinMoveTarget(val targetFile: JetFile): KotlinMoveTarget {
+public class JetFileKotlinMoveTarget(val targetFile: KtFile): KotlinMoveTarget {
     override val packageWrapper: PackageWrapper? = targetFile.getPackageFqName().asString().let { packageName ->
         PackageWrapper(PsiManager.getInstance(targetFile.getProject()), packageName)
     }
@@ -57,13 +57,13 @@ public class JetFileKotlinMoveTarget(val targetFile: JetFile): KotlinMoveTarget
 public class DeferredJetFileKotlinMoveTarget(
         project: Project,
         private val packageFqName: FqName,
-        private val createFile: (JetFile) -> JetFile?): KotlinMoveTarget {
-    private val createdFiles = HashMap<JetFile, JetFile?>()
+        private val createFile: (KtFile) -> KtFile?): KotlinMoveTarget {
+    private val createdFiles = HashMap<KtFile, KtFile?>()
 
     override val packageWrapper: PackageWrapper = PackageWrapper(PsiManager.getInstance(project), packageFqName.asString())
 
     override fun getOrCreateTargetPsi(originalPsi: PsiElement): PsiFile? {
-        val originalFile = originalPsi.containingFile as? JetFile ?: return null
+        val originalFile = originalPsi.containingFile as? KtFile ?: return null
         return createdFiles.getOrPut(originalFile) { createFile(originalFile) }
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveDeclarationToSeparateFileIntention.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveDeclarationToSeparateFileIntention.kt
index 8b49067ad67..348aa9e8253 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveDeclarationToSeparateFileIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveDeclarationToSeparateFileIntention.kt
@@ -28,26 +28,26 @@ import org.jetbrains.kotlin.idea.core.refactoring.createKotlinFile
 import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.quickfix.moveCaret
 import org.jetbrains.kotlin.idea.refactoring.move.moveTopLevelDeclarations.ui.MoveKotlinTopLevelDeclarationsDialog
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetObjectDeclaration
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
 public class MoveDeclarationToSeparateFileIntention :
-        JetSelfTargetingRangeIntention<JetClassOrObject>(JetClassOrObject::class.java, "Move declaration to separate file"),
+        JetSelfTargetingRangeIntention<KtClassOrObject>(KtClassOrObject::class.java, "Move declaration to separate file"),
         LowPriorityAction {
-    override fun applicabilityRange(element: JetClassOrObject): TextRange? {
+    override fun applicabilityRange(element: KtClassOrObject): TextRange? {
         if (element.name == null) return null
-        if (element.parent !is JetFile) return null
-        if (element.hasModifier(JetTokens.PRIVATE_KEYWORD)) return null
+        if (element.parent !is KtFile) return null
+        if (element.hasModifier(KtTokens.PRIVATE_KEYWORD)) return null
         if (element.getContainingJetFile().declarations.size() == 1) return null
 
         val keyword = when (element) {
-            is JetClass -> element.getClassOrInterfaceKeyword()
-            is JetObjectDeclaration -> element.getObjectKeyword()
+            is KtClass -> element.getClassOrInterfaceKeyword()
+            is KtObjectDeclaration -> element.getObjectKeyword()
             else -> return null
         }
         val startOffset = keyword?.startOffset ?: return null
@@ -58,7 +58,7 @@ public class MoveDeclarationToSeparateFileIntention :
         return TextRange(startOffset, endOffset)
     }
 
-    override fun applyTo(element: JetClassOrObject, editor: Editor) {
+    override fun applyTo(element: KtClassOrObject, editor: Editor) {
         val file = element.getContainingJetFile()
         val project = file.project
         val originalOffset = editor.caretModel.offset - element.startOffset
@@ -77,7 +77,7 @@ public class MoveDeclarationToSeparateFileIntention :
                                                      setOf(element),
                                                      packageName.asString(),
                                                      directory,
-                                                     targetFile as? JetFile,
+                                                     targetFile as? KtFile,
                                                      true,
                                                      true,
                                                      true,
@@ -95,7 +95,7 @@ public class MoveDeclarationToSeparateFileIntention :
                 searchInNonCode = false,
                 updateInternalReferences = true,
                 moveCallback = MoveCallback {
-                    val newFile = directory.findFile(targetFileName) as JetFile
+                    val newFile = directory.findFile(targetFileName) as KtFile
                     val newDeclaration = newFile.declarations.first()
                     NavigationUtil.activateFileWithPsiElement(newFile)
                     FileEditorManager.getInstance(project).selectedTextEditor?.moveCaret(newDeclaration.startOffset + originalOffset)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsHandler.kt
index 0408219c0d6..26e11560817 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsHandler.kt
@@ -51,9 +51,9 @@ public class MoveKotlinTopLevelDeclarationsHandler : MoveHandlerDelegate() {
             return false
         }
 
-        val elementsToSearch = elements.mapTo(LinkedHashSet()) { it as JetNamedDeclaration }
+        val elementsToSearch = elements.mapTo(LinkedHashSet()) { it as KtNamedDeclaration }
 
-        if (elementsToSearch.any { it.parent !is JetFile }) {
+        if (elementsToSearch.any { it.parent !is KtFile }) {
             val message = RefactoringBundle.getCannotRefactorMessage("Move declaration is only supported for top-level declarations")
             CommonRefactoringUtil.showErrorHint(project, editor, message, MOVE_DECLARATIONS, null)
             return true
@@ -63,8 +63,8 @@ public class MoveKotlinTopLevelDeclarationsHandler : MoveHandlerDelegate() {
         val targetDirectory = MoveClassesOrPackagesImpl.getInitialTargetDirectory(targetContainer, elements)
         val searchInComments = JavaRefactoringSettings.getInstance()!!.MOVE_SEARCH_IN_COMMENTS
         val searchInText = JavaRefactoringSettings.getInstance()!!.MOVE_SEARCH_FOR_TEXT
-        val targetFile = targetContainer as? JetFile
-        val moveToPackage = targetContainer !is JetFile
+        val targetFile = targetContainer as? KtFile
+        val moveToPackage = targetContainer !is KtFile
 
         MoveKotlinTopLevelDeclarationsDialog(
                 project, elementsToSearch, targetPackageName, targetDirectory, targetFile, moveToPackage, searchInComments, searchInText, callback
@@ -78,8 +78,8 @@ public class MoveKotlinTopLevelDeclarationsHandler : MoveHandlerDelegate() {
         if (getSourceDirectories(elements).singleOrNull() == null) return false
 
         return elements.all { e ->
-            if (e is JetClass || (e is JetObjectDeclaration && !e.isObjectLiteral()) || e is JetNamedFunction || e is JetProperty) {
-                (editorMode || e.parent is JetFile) && e.canRefactor()
+            if (e is KtClass || (e is KtObjectDeclaration && !e.isObjectLiteral()) || e is KtNamedFunction || e is KtProperty) {
+                (editorMode || e.parent is KtFile) && e.canRefactor()
             }
             else false
         }
@@ -90,7 +90,7 @@ public class MoveKotlinTopLevelDeclarationsHandler : MoveHandlerDelegate() {
     }
 
     override fun isValidTarget(psiElement: PsiElement?, sources: Array<out PsiElement>): Boolean {
-        return psiElement is PsiPackage || (psiElement is PsiDirectory && psiElement.getPackage() != null) || psiElement is JetFile
+        return psiElement is PsiPackage || (psiElement is PsiDirectory && psiElement.getPackage() != null) || psiElement is KtFile
     }
 
     override fun doMove(project: Project, elements: Array<out PsiElement>, targetContainer: PsiElement?, callback: MoveCallback?) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt
index 63a8517ca9d..d6cf65d1994 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt
@@ -51,11 +51,11 @@ import org.jetbrains.kotlin.idea.core.refactoring.getUsageContext
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle
 import org.jetbrains.kotlin.idea.refactoring.fqName.getKotlinFqName
 import org.jetbrains.kotlin.idea.refactoring.move.*
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference.ShorteningMode
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference.ShorteningMode
 import org.jetbrains.kotlin.idea.search.projectScope
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetModifierListOwner
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtModifierListOwner
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
 import org.jetbrains.kotlin.psi.psiUtil.isInsideOf
 import org.jetbrains.kotlin.psi.psiUtil.isPrivate
@@ -63,22 +63,22 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.utils.keysToMap
 import java.util.*
 
-interface Mover: (JetNamedDeclaration, JetFile) -> JetNamedDeclaration {
+interface Mover: (KtNamedDeclaration, KtFile) -> KtNamedDeclaration {
     object Default: Mover {
-        override fun invoke(originalElement: JetNamedDeclaration, targetFile: JetFile): JetNamedDeclaration {
-            val newElement = targetFile.add(originalElement) as JetNamedDeclaration
+        override fun invoke(originalElement: KtNamedDeclaration, targetFile: KtFile): KtNamedDeclaration {
+            val newElement = targetFile.add(originalElement) as KtNamedDeclaration
             originalElement.deleteSingle()
             return newElement
         }
     }
 
     object Idle: Mover {
-        override fun invoke(originalElement: JetNamedDeclaration, targetFile: JetFile) = originalElement
+        override fun invoke(originalElement: KtNamedDeclaration, targetFile: KtFile) = originalElement
     }
 }
 
 public class MoveKotlinTopLevelDeclarationsOptions(
-        val elementsToMove: Collection<JetNamedDeclaration>,
+        val elementsToMove: Collection<KtNamedDeclaration>,
         val moveTarget: KotlinMoveTarget,
         val searchInCommentsAndStrings: Boolean = true,
         val searchInNonCode: Boolean = true,
@@ -112,7 +112,7 @@ public class MoveKotlinTopLevelDeclarationsProcessor(
     public override fun findUsages(): Array<UsageInfo> {
         val newPackageName = options.moveTarget.packageWrapper?.getQualifiedName() ?: ""
 
-        fun collectUsages(kotlinToLightElements: Map<JetNamedDeclaration, List<PsiNamedElement>>, result: MutableList<UsageInfo>) {
+        fun collectUsages(kotlinToLightElements: Map<KtNamedDeclaration, List<PsiNamedElement>>, result: MutableList<UsageInfo>) {
             kotlinToLightElements.values().flatMap { it }.flatMapTo(result) { lightElement ->
                 val newFqName = StringUtil.getQualifiedName(newPackageName, lightElement.getName())
 
@@ -154,12 +154,12 @@ public class MoveKotlinTopLevelDeclarationsProcessor(
          */
 
         fun collectConflictsInUsages(usages: List<UsageInfo>) {
-            val declarationToContainers = HashMap<JetNamedDeclaration, MutableSet<PsiElement>>()
+            val declarationToContainers = HashMap<KtNamedDeclaration, MutableSet<PsiElement>>()
             for (usage in usages) {
                 val element = usage.getElement()
                 if (element == null || usage !is MoveRenameUsageInfo || usage is NonCodeUsageInfo) continue
 
-                val declaration = usage.getReferencedElement()?.namedUnwrappedElement as? JetNamedDeclaration
+                val declaration = usage.getReferencedElement()?.namedUnwrappedElement as? KtNamedDeclaration
                 if (declaration == null || !declaration.isPrivate()) continue
 
                 if (element.isInsideOf(elementsToMove)) continue
@@ -184,7 +184,7 @@ public class MoveKotlinTopLevelDeclarationsProcessor(
         fun collectConflictsInDeclarations() {
             if (newPackageName == UNKNOWN_PACKAGE_FQ_NAME.asString()) return
 
-            val declarationToReferenceTargets = HashMap<JetNamedDeclaration, MutableSet<PsiElement>>()
+            val declarationToReferenceTargets = HashMap<KtNamedDeclaration, MutableSet<PsiElement>>()
             for (declaration in elementsToMove) {
                 val referenceToContext = JetFileReferencesResolver.resolve(element = declaration, resolveQualifiers = false)
                 for ((refExpr, bindingContext) in referenceToContext) {
@@ -194,7 +194,7 @@ public class MoveKotlinTopLevelDeclarationsProcessor(
                     if (refTarget == null || refTarget.isInsideOf(elementsToMove)) continue
 
                     val packagePrivate = when(refTarget) {
-                        is JetModifierListOwner ->
+                        is KtModifierListOwner ->
                             refTarget.isPrivate()
                         is PsiModifierListOwner ->
                             VisibilityUtil.getVisibilityModifier(refTarget.getModifierList()) == PsiModifier.PACKAGE_LOCAL
@@ -240,14 +240,14 @@ public class MoveKotlinTopLevelDeclarationsProcessor(
 
     override fun performRefactoring(usages: Array<out UsageInfo>) {
         fun moveDeclaration(
-                declaration: JetNamedDeclaration,
+                declaration: KtNamedDeclaration,
                 moveTarget: KotlinMoveTarget,
                 usagesToProcessAfterMove: MutableList<UsageInfo>
-        ): JetNamedDeclaration? {
-            val file = declaration.getContainingFile() as? JetFile
+        ): KtNamedDeclaration? {
+            val file = declaration.getContainingFile() as? KtFile
             assert(file != null) { "${declaration.javaClass}: ${declaration.getText()}" }
 
-            val targetFile = moveTarget.getOrCreateTargetPsi(declaration) as? JetFile
+            val targetFile = moveTarget.getOrCreateTargetPsi(declaration) as? KtFile
                              ?: throw AssertionError("Couldn't create Kotlin file for: ${declaration.javaClass}: ${declaration.getText()}")
 
             if (options.updateInternalReferences) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/ui/MoveFilesOrDirectoriesDialogWithKotlinOptions.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/ui/MoveFilesOrDirectoriesDialogWithKotlinOptions.kt
index ea21955e24b..a59be46022b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/ui/MoveFilesOrDirectoriesDialogWithKotlinOptions.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/ui/MoveFilesOrDirectoriesDialogWithKotlinOptions.kt
@@ -23,7 +23,7 @@ import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectori
 import com.intellij.ui.NonFocusableCheckBox
 import com.intellij.util.ui.UIUtil
 import org.jetbrains.kotlin.idea.core.refactoring.isInJavaSourceRoot
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.idea.core.packageMatchesDirectory
 import java.awt.GridBagConstraints
 import java.awt.Insets
@@ -71,7 +71,7 @@ public class MoveFilesOrDirectoriesDialogWithKotlinOptions(
         super.setData(psiElements, initialTargetDirectory, helpID)
 
         with (cbUpdatePackageDirective!!) {
-            val jetFiles = psiElements.filterIsInstance<JetFile>().filter { it.isInJavaSourceRoot() }
+            val jetFiles = psiElements.filterIsInstance<KtFile>().filter { it.isInJavaSourceRoot() }
             if (jetFiles.isEmpty()) {
                 getParent().remove(cbUpdatePackageDirective)
                 return
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/ui/MoveKotlinTopLevelDeclarationsDialog.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/ui/MoveKotlinTopLevelDeclarationsDialog.java
index 42ff2abc60b..a2834c68300 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/ui/MoveKotlinTopLevelDeclarationsDialog.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/ui/MoveKotlinTopLevelDeclarationsDialog.java
@@ -61,7 +61,7 @@ import kotlin.jvm.functions.Function0;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.idea.core.PackageUtilsKt;
 import org.jetbrains.kotlin.idea.core.refactoring.JetRefactoringUtilKt;
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle;
@@ -72,8 +72,8 @@ import org.jetbrains.kotlin.idea.refactoring.move.MoveUtilsKt;
 import org.jetbrains.kotlin.idea.refactoring.move.moveTopLevelDeclarations.*;
 import org.jetbrains.kotlin.idea.util.application.ApplicationUtilsKt;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetNamedDeclaration;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtNamedDeclaration;
 
 import javax.swing.*;
 import java.awt.*;
@@ -86,7 +86,7 @@ import java.util.List;
 public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
     private static final String RECENTS_KEY = "MoveKotlinTopLevelDeclarationsDialog.RECENTS_KEY";
 
-    private static class MemberInfoModelImpl extends AbstractMemberInfoModel<JetNamedDeclaration, KotlinMemberInfo> {
+    private static class MemberInfoModelImpl extends AbstractMemberInfoModel<KtNamedDeclaration, KotlinMemberInfo> {
 
     }
 
@@ -109,10 +109,10 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
 
     public MoveKotlinTopLevelDeclarationsDialog(
             @NotNull Project project,
-            @NotNull Set<JetNamedDeclaration> elementsToMove,
+            @NotNull Set<KtNamedDeclaration> elementsToMove,
             @Nullable String targetPackageName,
             @Nullable PsiDirectory targetDirectory,
-            @Nullable JetFile targetFile,
+            @Nullable KtFile targetFile,
             boolean moveToPackage,
             boolean searchInComments,
             boolean searchForTextOccurences,
@@ -120,7 +120,7 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
     ) {
         super(project, true);
 
-        List<JetFile> sourceFiles = getSourceFiles(elementsToMove);
+        List<KtFile> sourceFiles = getSourceFiles(elementsToMove);
 
         this.moveCallback = moveCallback;
 
@@ -143,13 +143,13 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
         pack();
     }
 
-    private static List<JetFile> getSourceFiles(@NotNull Collection<JetNamedDeclaration> elementsToMove) {
+    private static List<KtFile> getSourceFiles(@NotNull Collection<KtNamedDeclaration> elementsToMove) {
         return CollectionsKt.distinct(
                 CollectionsKt.map(
                         elementsToMove,
-                        new Function1<JetNamedDeclaration, JetFile>() {
+                        new Function1<KtNamedDeclaration, KtFile>() {
                             @Override
-                            public JetFile invoke(JetNamedDeclaration declaration) {
+                            public KtFile invoke(KtNamedDeclaration declaration) {
                                 return declaration.getContainingJetFile();
                             }
                         }
@@ -158,14 +158,14 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
     }
 
     @NotNull
-    private static PsiDirectory getSourceDirectory(@NotNull Collection<JetFile> sourceFiles) {
+    private static PsiDirectory getSourceDirectory(@NotNull Collection<KtFile> sourceFiles) {
         return CollectionsKt.single(
                 CollectionsKt.distinct(
                         CollectionsKt.map(
                                 sourceFiles,
-                                new Function1<JetFile, PsiDirectory>() {
+                                new Function1<KtFile, PsiDirectory>() {
                                     @Override
-                                    public PsiDirectory invoke(JetFile jetFile) {
+                                    public PsiDirectory invoke(KtFile jetFile) {
                                         return jetFile.getParent();
                                     }
                                 }
@@ -174,37 +174,37 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
         );
     }
 
-    private static List<JetNamedDeclaration> getAllDeclarations(Collection<JetFile> sourceFiles) {
+    private static List<KtNamedDeclaration> getAllDeclarations(Collection<KtFile> sourceFiles) {
         return CollectionsKt.filterIsInstance(
                 CollectionsKt.flatMap(
                         sourceFiles,
-                        new Function1<JetFile, Iterable<?>>() {
+                        new Function1<KtFile, Iterable<?>>() {
                             @Override
-                            public Iterable<?> invoke(JetFile jetFile) {
+                            public Iterable<?> invoke(KtFile jetFile) {
                                 return jetFile.getDeclarations();
                             }
                         }
                 ),
-                JetNamedDeclaration.class
+                KtNamedDeclaration.class
         );
     }
 
-    private static boolean arePackagesAndDirectoryMatched(List<JetFile> sourceFiles) {
-        for (JetFile sourceFile : sourceFiles) {
+    private static boolean arePackagesAndDirectoryMatched(List<KtFile> sourceFiles) {
+        for (KtFile sourceFile : sourceFiles) {
             if (!PackageUtilsKt.packageMatchesDirectory(sourceFile)) return false;
         }
         return true;
     }
 
     private void initMemberInfo(
-            @NotNull final Set<JetNamedDeclaration> elementsToMove,
-            @NotNull List<JetFile> sourceFiles
+            @NotNull final Set<KtNamedDeclaration> elementsToMove,
+            @NotNull List<KtFile> sourceFiles
     ) {
         final List<KotlinMemberInfo> memberInfos = CollectionsKt.map(
                 getAllDeclarations(sourceFiles),
-                new Function1<JetNamedDeclaration, KotlinMemberInfo>() {
+                new Function1<KtNamedDeclaration, KotlinMemberInfo>() {
                     @Override
-                    public KotlinMemberInfo invoke(JetNamedDeclaration declaration) {
+                    public KotlinMemberInfo invoke(KtNamedDeclaration declaration) {
                         KotlinMemberInfo memberInfo = new KotlinMemberInfo(declaration, false);
                         memberInfo.setChecked(elementsToMove.contains(declaration));
                         return memberInfo;
@@ -214,20 +214,20 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
         KotlinMemberSelectionPanel selectionPanel = new KotlinMemberSelectionPanel(getTitle(), memberInfos, null);
         memberTable = selectionPanel.getTable();
         MemberInfoModelImpl memberInfoModel = new MemberInfoModelImpl();
-        memberInfoModel.memberInfoChanged(new MemberInfoChange<JetNamedDeclaration, KotlinMemberInfo>(memberInfos));
+        memberInfoModel.memberInfoChanged(new MemberInfoChange<KtNamedDeclaration, KotlinMemberInfo>(memberInfos));
         selectionPanel.getTable().setMemberInfoModel(memberInfoModel);
         selectionPanel.getTable().addMemberInfoChangeListener(memberInfoModel);
         selectionPanel.getTable().addMemberInfoChangeListener(
-                new MemberInfoChangeListener<JetNamedDeclaration, KotlinMemberInfo>() {
+                new MemberInfoChangeListener<KtNamedDeclaration, KotlinMemberInfo>() {
                     private boolean shouldUpdateFileNameField(final Collection<KotlinMemberInfo> changedMembers) {
                         if (!tfFileNameInPackage.isEnabled()) return true;
 
-                        Collection<JetNamedDeclaration> previousDeclarations = CollectionsKt.filterNotNull(
+                        Collection<KtNamedDeclaration> previousDeclarations = CollectionsKt.filterNotNull(
                                 CollectionsKt.map(
                                         memberInfos,
-                                        new Function1<KotlinMemberInfo, JetNamedDeclaration>() {
+                                        new Function1<KotlinMemberInfo, KtNamedDeclaration>() {
                                             @Override
-                                            public JetNamedDeclaration invoke(KotlinMemberInfo info) {
+                                            public KtNamedDeclaration invoke(KotlinMemberInfo info) {
                                                 return changedMembers.contains(info) != info.isChecked() ? info.getMember() : null;
                                             }
                                         }
@@ -240,7 +240,7 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
                     }
 
                     @Override
-                    public void memberInfoChanged(MemberInfoChange<JetNamedDeclaration, KotlinMemberInfo> event) {
+                    public void memberInfoChanged(MemberInfoChange<KtNamedDeclaration, KotlinMemberInfo> event) {
                         updatePackageDirectiveCheckBox();
                         updateFileNameInPackageField();
                         // Update file name field only if it user hasn't changed it to some non-default value
@@ -268,7 +268,7 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
     private void initPackageChooser(
             String targetPackageName,
             PsiDirectory targetDirectory,
-            List<JetFile> sourceFiles
+            List<KtFile> sourceFiles
     ) {
         if (targetPackageName != null) {
             classPackageChooser.prependItem(targetPackageName);
@@ -333,9 +333,9 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
     }
 
     private void initFileChooser(
-            @Nullable JetFile targetFile,
-            @NotNull Set<JetNamedDeclaration> elementsToMove,
-            @NotNull List<JetFile> sourceFiles
+            @Nullable KtFile targetFile,
+            @NotNull Set<KtNamedDeclaration> elementsToMove,
+            @NotNull List<KtFile> sourceFiles
     ) {
         FileChooserDescriptor descriptor = FileChooserDescriptorFactory.createSingleFileNoJarsDescriptor()
                 .withRoots(ProjectRootManager.getInstance(myProject).getContentRoots())
@@ -390,16 +390,16 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
     }
 
     private boolean isFullFileMove() {
-        Map<JetFile, List<? extends JetNamedDeclaration>> fileToElements = CollectionsKt.groupBy(
+        Map<KtFile, List<? extends KtNamedDeclaration>> fileToElements = CollectionsKt.groupBy(
                 getSelectedElementsToMove(),
-                new Function1<JetNamedDeclaration, JetFile>() {
+                new Function1<KtNamedDeclaration, KtFile>() {
                     @Override
-                    public JetFile invoke(JetNamedDeclaration declaration) {
+                    public KtFile invoke(KtNamedDeclaration declaration) {
                         return declaration.getContainingJetFile();
                     }
                 }
         );
-        for (Map.Entry<JetFile, List<? extends JetNamedDeclaration>> entry : fileToElements.entrySet()) {
+        for (Map.Entry<KtFile, List<? extends KtNamedDeclaration>> entry : fileToElements.entrySet()) {
             if (entry.getKey().getDeclarations().size() != entry.getValue().size()) return false;
         }
         return true;
@@ -436,14 +436,14 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
     }
 
     private boolean checkTargetFileName(String fileName) {
-        if (FileTypeManager.getInstance().getFileTypeByFileName(fileName) == JetFileType.INSTANCE) return true;
+        if (FileTypeManager.getInstance().getFileTypeByFileName(fileName) == KotlinFileType.INSTANCE) return true;
         setErrorText("Can't move to non-Kotlin file");
         return false;
     }
 
     @NotNull
     private static List<PsiFile> getFilesExistingInTargetDir(
-            @NotNull List<JetFile> sourceFiles,
+            @NotNull List<KtFile> sourceFiles,
             @Nullable String targetFileName,
             @Nullable final PsiDirectory targetDirectory
     ) {
@@ -454,9 +454,9 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
                 ? Collections.singletonList(targetFileName)
                 : CollectionsKt.map(
                         sourceFiles,
-                        new Function1<JetFile, String>() {
+                        new Function1<KtFile, String>() {
                             @Override
-                            public String invoke(JetFile jetFile) {
+                            public String invoke(KtFile jetFile) {
                                 return jetFile.getName();
                             }
                         }
@@ -485,7 +485,7 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
 
         setErrorText(null);
 
-        List<JetFile> sourceFiles = getSourceFiles(getSelectedElementsToMove());
+        List<KtFile> sourceFiles = getSourceFiles(getSelectedElementsToMove());
         PsiDirectory sourceDirectory = getSourceDirectory(sourceFiles);
 
         if (isMoveToPackage()) {
@@ -535,9 +535,9 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
             return new DeferredJetFileKotlinMoveTarget(
                     myProject,
                     new FqName(getTargetPackage()),
-                    new Function1<JetFile, JetFile>() {
+                    new Function1<KtFile, KtFile>() {
                         @Override
-                        public JetFile invoke(@NotNull JetFile originalFile) {
+                        public KtFile invoke(@NotNull KtFile originalFile) {
                             return JetRefactoringUtilKt.getOrCreateKotlinFile(
                                     targetFileName != null ? targetFileName : originalFile.getName(),
                                     moveDestination.getTargetDirectory(originalFile)
@@ -549,7 +549,7 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
 
         final File targetFile = new File(getTargetFilePath());
         if (!checkTargetFileName(targetFile.getName())) return null;
-        JetFile jetFile = (JetFile) JetRefactoringUtilKt.toPsiFile(targetFile, myProject);
+        KtFile jetFile = (KtFile) JetRefactoringUtilKt.toPsiFile(targetFile, myProject);
         if (jetFile != null) {
             if (sourceFiles.size() == 1 && sourceFiles.contains(jetFile)) {
                 setErrorText("Can't move to the original file");
@@ -572,9 +572,9 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
         return new DeferredJetFileKotlinMoveTarget(
                 myProject,
                 new FqName(psiPackage.getQualifiedName()),
-                new Function1<JetFile, JetFile>() {
+                new Function1<KtFile, KtFile>() {
                     @Override
-                    public JetFile invoke(@NotNull JetFile originalFile) {
+                    public KtFile invoke(@NotNull KtFile originalFile) {
                         return JetRefactoringUtilKt.getOrCreateKotlinFile(targetFile.getName(), psiDirectory);
                     }
                 }
@@ -593,7 +593,7 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
         }
         else {
             PsiFile targetFile = JetRefactoringUtilKt.toPsiFile(new File(getTargetFilePath()), myProject);
-            if (!(targetFile == null || targetFile instanceof JetFile)) {
+            if (!(targetFile == null || targetFile instanceof KtFile)) {
                 return JetRefactoringBundle.message("refactoring.move.non.kotlin.file");
             }
         }
@@ -605,12 +605,12 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
         return null;
     }
 
-    private List<JetNamedDeclaration> getSelectedElementsToMove() {
+    private List<KtNamedDeclaration> getSelectedElementsToMove() {
         return CollectionsKt.map(
                 memberTable.getSelectedMemberInfos(),
-                new Function1<KotlinMemberInfo, JetNamedDeclaration>() {
+                new Function1<KotlinMemberInfo, KtNamedDeclaration>() {
                     @Override
-                    public JetNamedDeclaration invoke(KotlinMemberInfo info) {
+                    public KtNamedDeclaration invoke(KotlinMemberInfo info) {
                         return info.getMember();
                     }
                 }
@@ -650,8 +650,8 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
 
         saveRefactoringSettings();
 
-        List<JetNamedDeclaration> elementsToMove = getSelectedElementsToMove();
-        final List<JetFile> sourceFiles = getSourceFiles(elementsToMove);
+        List<KtNamedDeclaration> elementsToMove = getSelectedElementsToMove();
+        final List<KtFile> sourceFiles = getSourceFiles(elementsToMove);
         final PsiDirectory sourceDirectory = getSourceDirectory(sourceFiles);
 
         for (PsiElement element : elementsToMove) {
@@ -682,7 +682,7 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
                                 }
                         );
 
-                        for (JetFile sourceFile : sourceFiles) {
+                        for (KtFile sourceFile : sourceFiles) {
                             MoveUtilsKt.setUpdatePackageDirective(sourceFile, cbUpdatePackageDirective.isSelected());
                         }
 
@@ -719,7 +719,7 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
                                     @Override
                                     protected void performRefactoring(@NotNull UsageInfo[] usages) {
                                         if (targetFileName != null) {
-                                            JetFile sourceFile = CollectionsKt.single(sourceFiles);
+                                            KtFile sourceFile = CollectionsKt.single(sourceFiles);
                                             //noinspection ConstantConditions
                                             String temporaryName = UniqueNameGenerator.generateUniqueName(
                                                     "temp",
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveUtils.kt
index f875159055d..8a6397f7e91 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveUtils.kt
@@ -41,7 +41,7 @@ import com.intellij.util.IncorrectOperationException
 import org.jetbrains.kotlin.asJava.namedUnwrappedElement
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.codeInsight.JetFileReferencesResolver
@@ -49,9 +49,9 @@ import org.jetbrains.kotlin.idea.core.refactoring.isInJavaSourceRoot
 import org.jetbrains.kotlin.idea.imports.importableFqName
 import org.jetbrains.kotlin.idea.refactoring.fqName.isImported
 import org.jetbrains.kotlin.idea.refactoring.move.moveTopLevelDeclarations.ui.MoveFilesOrDirectoriesDialogWithKotlinOptions
-import org.jetbrains.kotlin.idea.references.JetReference
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference.ShorteningMode
+import org.jetbrains.kotlin.idea.references.KtReference
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference.ShorteningMode
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.application.executeCommand
@@ -71,8 +71,8 @@ val UNKNOWN_PACKAGE_FQ_NAME = FqNameUnsafe("org.jetbrains.kotlin.idea.refactorin
 
 public class PackageNameInfo(val oldPackageName: FqName, val newPackageName: FqNameUnsafe)
 
-public fun JetElement.getInternalReferencesToUpdateOnPackageNameChange(packageNameInfo: PackageNameInfo): List<UsageInfo> {
-    val file = getContainingFile() as? JetFile ?: return listOf()
+public fun KtElement.getInternalReferencesToUpdateOnPackageNameChange(packageNameInfo: PackageNameInfo): List<UsageInfo> {
+    val file = getContainingFile() as? KtFile ?: return listOf()
 
     val importPaths = file.getImportDirectives().map { it.getImportPath() }.filterNotNull()
 
@@ -87,7 +87,7 @@ public fun JetElement.getInternalReferencesToUpdateOnPackageNameChange(packageNa
         }
     }
 
-    fun processReference(refExpr: JetSimpleNameExpression, bindingContext: BindingContext): UsageInfo? {
+    fun processReference(refExpr: KtSimpleNameExpression, bindingContext: BindingContext): UsageInfo? {
         val descriptor = bindingContext[BindingContext.REFERENCE_TARGET, refExpr]?.getImportableDescriptor() ?: return null
 
         val declaration = DescriptorToSourceUtilsIde.getAnyDeclaration(getProject(), descriptor) ?: return null
@@ -99,7 +99,7 @@ public fun JetElement.getInternalReferencesToUpdateOnPackageNameChange(packageNa
             val containingDescriptor = descriptor.getContainingDeclaration()
             val receiver = refExpr.getReceiverExpression()
             if (receiver != null) {
-                val receiverRef = receiver.getQualifiedElementSelector() as? JetSimpleNameExpression ?: return null
+                val receiverRef = receiver.getQualifiedElementSelector() as? KtSimpleNameExpression ?: return null
                 if (bindingContext[BindingContext.QUALIFIER, receiverRef] == null) return null
                 return processReference(receiverRef, bindingContext)
             }
@@ -143,7 +143,7 @@ public fun JetElement.getInternalReferencesToUpdateOnPackageNameChange(packageNa
 
     val usages = ArrayList<UsageInfo>()
     for ((refExpr, bindingContext) in referenceToContext) {
-        if (refExpr !is JetSimpleNameExpression || refExpr.getParent() is JetThisExpression) continue
+        if (refExpr !is KtSimpleNameExpression || refExpr.getParent() is KtThisExpression) continue
         if (bindingContext[BindingContext.QUALIFIER, refExpr] != null) continue
 
         processReference(refExpr, bindingContext)?.let { usages.add(it) }
@@ -162,9 +162,9 @@ class MoveRenameUsageInfoForExtension(
         val addImportToOriginalFile: Boolean
 ): MoveRenameUsageInfo(element, reference, startOffset, endOffset, referencedElement, false)
 
-class MoveRenameSelfUsageInfo(ref: JetSimpleNameReference, refTarget: PsiElement, val newFqName: FqName):
+class MoveRenameSelfUsageInfo(ref: KtSimpleNameReference, refTarget: PsiElement, val newFqName: FqName):
         MoveRenameUsageInfo(ref.element, ref, ref.rangeInElement.startOffset, ref.rangeInElement.endOffset, refTarget, false) {
-    override fun getReference() = super.getReference() as? JetSimpleNameReference
+    override fun getReference() = super.getReference() as? KtSimpleNameReference
 }
 
 fun createMoveUsageInfoIfPossible(
@@ -173,7 +173,7 @@ fun createMoveUsageInfoIfPossible(
         addImportToOriginalFile: Boolean
 ): UsageInfo? {
     val element = reference.getElement()
-    if (element.getStrictParentOfType<JetSuperExpression>() != null) return null
+    if (element.getStrictParentOfType<KtSuperExpression>() != null) return null
 
     val range = reference.getRangeInElement()!!
     val startOffset = range.getStartOffset()
@@ -188,17 +188,17 @@ fun createMoveUsageInfoIfPossible(
 }
 
 private fun isUnqualifiedExtensionReference(reference: PsiReference, referencedElement: PsiElement): Boolean {
-    return reference is JetReference
-           && (referencedElement.namedUnwrappedElement as? JetDeclaration)?.isExtensionDeclaration() ?: false
-           && reference.element.getNonStrictParentOfType<JetImportDirective>() == null
+    return reference is KtReference
+           && (referencedElement.namedUnwrappedElement as? KtDeclaration)?.isExtensionDeclaration() ?: false
+           && reference.element.getNonStrictParentOfType<KtImportDirective>() == null
 }
 
-public fun guessNewFileName(declarationsToMove: Collection<JetNamedDeclaration>): String? {
+public fun guessNewFileName(declarationsToMove: Collection<KtNamedDeclaration>): String? {
     if (declarationsToMove.isEmpty()) return null
 
     val representative = declarationsToMove.singleOrNull()
-                         ?: declarationsToMove.filterIsInstance<JetClassOrObject>().singleOrNull()
-    representative?.let { return "${it.name}.${JetFileType.EXTENSION}" }
+                         ?: declarationsToMove.filterIsInstance<KtClassOrObject>().singleOrNull()
+    representative?.let { return "${it.name}.${KotlinFileType.EXTENSION}" }
 
     return declarationsToMove.first().containingFile.name
 }
@@ -274,8 +274,8 @@ fun postProcessMoveUsages(usages: List<UsageInfo>,
             }
 
             is MoveRenameUsageInfoForExtension -> {
-                val file = with(usage) { if (addImportToOriginalFile) originalFile else counterpart(originalFile) } as JetFile
-                val declaration = counterpart(usage.getReferencedElement()!!).unwrapped as JetDeclaration
+                val file = with(usage) { if (addImportToOriginalFile) originalFile else counterpart(originalFile) } as KtFile
+                val declaration = counterpart(usage.getReferencedElement()!!).unwrapped as KtDeclaration
                 ImportInsertHelper.getInstance(usage.getProject()).importDescriptor(file, declaration.resolveToDescriptor())
             }
 
@@ -284,7 +284,7 @@ fun postProcessMoveUsages(usages: List<UsageInfo>,
                 val newElement = counterpart(oldElement)
                 usage.getReference()?.let {
                     try {
-                        if (it is JetSimpleNameReference) {
+                        if (it is KtSimpleNameReference) {
                             it.bindToElement(newElement, shorteningMode)
                         }
                         else if (it is PsiReferenceExpression && updateJavaReference(it, oldElement, newElement)) {
@@ -304,7 +304,7 @@ fun postProcessMoveUsages(usages: List<UsageInfo>,
     return nonCodeUsages
 }
 
-var JetFile.updatePackageDirective: Boolean? by UserDataProperty(Key.create("UPDATE_PACKAGE_DIRECTIVE"))
+var KtFile.updatePackageDirective: Boolean? by UserDataProperty(Key.create("UPDATE_PACKAGE_DIRECTIVE"))
 
 // Mostly copied from MoveFilesOrDirectoriesUtil.doMove()
 public fun moveFilesOrDirectories(
@@ -338,7 +338,7 @@ public fun moveFilesOrDirectories(
 
                 elementsToMove.forEach {
                     MoveFilesOrDirectoriesUtil.checkMove(it, selectedDir!!)
-                    if (it is JetFile && it.isInJavaSourceRoot()) {
+                    if (it is KtFile && it.isInJavaSourceRoot()) {
                         it.updatePackageDirective = updatePackageDirective
                     }
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/JavaToKotlinPostconversionPullUpHelper.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/JavaToKotlinPostconversionPullUpHelper.kt
index 76c553dab0a..e0cf7e7ed31 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/JavaToKotlinPostconversionPullUpHelper.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/JavaToKotlinPostconversionPullUpHelper.kt
@@ -25,7 +25,7 @@ import com.intellij.refactoring.memberPullUp.PullUpHelper
 import com.intellij.refactoring.util.classMembers.MemberInfo
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.idea.references.mainReference
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElementSelector
 import org.jetbrains.kotlin.psi.psiUtil.getReceiverExpression
 import java.util.LinkedHashSet
@@ -43,8 +43,8 @@ public class JavaToKotlinPostconversionPullUpHelper(private val data: PullUpData
     override fun moveFieldInitializations(movedFields: LinkedHashSet<PsiField>?) { }
 
     override fun updateUsage(element: PsiElement?) {
-        if (element !is JetSimpleNameExpression) return
-        val qualifier = element.getReceiverExpression()?.getQualifiedElementSelector() as? JetSimpleNameExpression ?: return
+        if (element !is KtSimpleNameExpression) return
+        val qualifier = element.getReceiverExpression()?.getQualifiedElementSelector() as? KtSimpleNameExpression ?: return
         qualifier.mainReference.bindToElement(data.targetClass.unwrapped!!)
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/JavaToKotlinPreconversionPullUpHelper.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/JavaToKotlinPreconversionPullUpHelper.kt
index 0a3201e750a..b6f446933ac 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/JavaToKotlinPreconversionPullUpHelper.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/JavaToKotlinPreconversionPullUpHelper.kt
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.idea.core.refactoring.j2k
 import org.jetbrains.kotlin.idea.core.refactoring.j2kText
 import org.jetbrains.kotlin.idea.core.setVisibility
 import org.jetbrains.kotlin.idea.refactoring.safeDelete.removeOverrideModifier
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.*
 import java.util.*
@@ -44,7 +44,7 @@ public class JavaToKotlinPreconversionPullUpHelper(
         private val dummyTargetClass: PsiClass,
         private val javaHelper: JavaPullUpHelper
 ) : PullUpHelper<MemberInfo> by javaHelper {
-    private val membersToDummyDeclarations = HashMap<PsiMember, JetElement>()
+    private val membersToDummyDeclarations = HashMap<PsiMember, KtElement>()
 
     private val encapsulateFieldsDescriptor = object: EncapsulateFieldsDescriptor {
         override fun getSelectedFields(): Array<out FieldDescriptor>? = arrayOf()
@@ -60,7 +60,7 @@ public class JavaToKotlinPreconversionPullUpHelper(
     private val fieldsToUsages = HashMap<PsiField, List<EncapsulateFieldUsageInfo>>()
     private val dummyAccessorByName = HashMap<String, PsiMethod>()
 
-    private val jvmStaticAnnotation = JetPsiFactory(data.sourceClass.project).createAnnotationEntry("@kotlin.jvm.JvmStatic")
+    private val jvmStaticAnnotation = KtPsiFactory(data.sourceClass.project).createAnnotationEntry("@kotlin.jvm.JvmStatic")
 
     companion object {
         private var PsiMember.originalMember: PsiMember? by CopyableUserDataProperty(Key.create("ORIGINAL_MEMBER"))
@@ -106,10 +106,10 @@ public class JavaToKotlinPreconversionPullUpHelper(
             member.removeOverrideModifier()
         }
 
-        val targetClass = data.targetClass.unwrapped as JetClass
+        val targetClass = data.targetClass.unwrapped as KtClass
         if (member.hasModifierProperty(PsiModifier.ABSTRACT) && !movingSuperInterface) targetClass.makeAbstract()
 
-        val psiFactory = JetPsiFactory(member.project)
+        val psiFactory = KtPsiFactory(member.project)
 
         if (movingSuperInterface) {
             if (getCurrentSuperInterfaceCount() == superInterfaceCount) return
@@ -123,7 +123,7 @@ public class JavaToKotlinPreconversionPullUpHelper(
             member.hasModifierProperty(PsiModifier.STATIC) && member !is PsiClass -> targetClass.getOrCreateCompanionObject()
             else -> targetClass
         }
-        val dummyDeclaration : JetNamedDeclaration = when (member) {
+        val dummyDeclaration : KtNamedDeclaration = when (member) {
             is PsiField -> psiFactory.createProperty("val foo = 0")
             is PsiMethod -> psiFactory.createFunction("fun foo() = 0")
             is PsiClass -> psiFactory.createClass("class Foo")
@@ -142,19 +142,19 @@ public class JavaToKotlinPreconversionPullUpHelper(
         val originalMember = member.originalMember ?: return
         originalMember.originalMember = null
 
-        val targetClass = data.targetClass.unwrapped as? JetClass ?: return
+        val targetClass = data.targetClass.unwrapped as? KtClass ?: return
         val convertedDeclaration = member.j2k() ?: return
         if (member is PsiField || member is PsiMethod) {
             val visibilityModifier = VisibilityUtil.getVisibilityModifier(member.modifierList)
             if (visibilityModifier == PsiModifier.PROTECTED || visibilityModifier == PsiModifier.PACKAGE_LOCAL) {
-                convertedDeclaration.setVisibility(JetTokens.PUBLIC_KEYWORD)
+                convertedDeclaration.setVisibility(KtTokens.PUBLIC_KEYWORD)
             }
         }
-        val newDeclaration = membersToDummyDeclarations[originalMember]?.replace(convertedDeclaration) as JetNamedDeclaration
+        val newDeclaration = membersToDummyDeclarations[originalMember]?.replace(convertedDeclaration) as KtNamedDeclaration
         if (targetClass.isInterface()) {
-            newDeclaration.removeModifier(JetTokens.ABSTRACT_KEYWORD)
+            newDeclaration.removeModifier(KtTokens.ABSTRACT_KEYWORD)
         }
-        if (member.hasModifierProperty(PsiModifier.STATIC) && newDeclaration is JetNamedFunction) {
+        if (member.hasModifierProperty(PsiModifier.STATIC) && newDeclaration is KtNamedFunction) {
             newDeclaration.addAnnotationWithSpace(jvmStaticAnnotation).addToShorteningWaitSet()
         }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpData.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpData.kt
index 56a618a85ec..460495ba358 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpData.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpData.kt
@@ -23,8 +23,8 @@ import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.core.getResolutionScope
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.getClassDescriptorIfAny
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.utils.getDescriptorsFiltered
@@ -36,9 +36,9 @@ import org.jetbrains.kotlin.types.substitutions.getTypeSubstitution
 import org.jetbrains.kotlin.utils.keysToMap
 import java.util.LinkedHashMap
 
-class KotlinPullUpData(val sourceClass: JetClassOrObject,
+class KotlinPullUpData(val sourceClass: KtClassOrObject,
                        val targetClass: PsiNamedElement,
-                       val membersToMove: Collection<JetNamedDeclaration>) {
+                       val membersToMove: Collection<KtNamedDeclaration>) {
     val resolutionFacade = sourceClass.getResolutionFacade()
 
     val sourceClassContext = resolutionFacade.analyzeFullyAndGetResult(listOf(sourceClass)).bindingContext
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpDialog.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpDialog.kt
index bdaf3e123ff..42a82d4dbd6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpDialog.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpDialog.kt
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.psi.*
 
 public class KotlinPullUpDialog(
         project: Project,
-        private val classOrObject: JetClassOrObject,
+        private val classOrObject: KtClassOrObject,
         superClasses: List<PsiNamedElement>,
         memberInfoStorage: KotlinMemberInfoStorage
 ) : KotlinPullUpDialogBase(
@@ -41,7 +41,7 @@ public class KotlinPullUpDialog(
         init()
     }
 
-    private inner class MemberInfoModelImpl : AbstractMemberInfoModel<JetNamedDeclaration, KotlinMemberInfo>() {
+    private inner class MemberInfoModelImpl : AbstractMemberInfoModel<KtNamedDeclaration, KotlinMemberInfo>() {
         // Abstract members remain abstract
         override fun isFixedAbstract(memberInfo: KotlinMemberInfo?) = true
 
@@ -56,16 +56,16 @@ public class KotlinPullUpDialog(
         override fun isAbstractEnabled(memberInfo: KotlinMemberInfo): Boolean {
             val superClass = superClass ?: return false
             if (superClass is PsiClass) return false
-            if (superClass !is JetClass) return false
+            if (superClass !is KtClass) return false
             if (!superClass.isInterface()) return true
 
             val member = memberInfo.member
-            return member is JetNamedFunction || (member is JetProperty && !member.mustBeAbstractInInterface())
+            return member is KtNamedFunction || (member is KtProperty && !member.mustBeAbstractInInterface())
         }
 
         override fun isAbstractWhenDisabled(memberInfo: KotlinMemberInfo): Boolean {
             val member = memberInfo.member
-            return (member is JetProperty && superClass !is PsiClass) || (member is JetNamedFunction && superClass is PsiClass)
+            return (member is KtProperty && superClass !is PsiClass) || (member is KtNamedFunction && superClass is PsiClass)
         }
 
         override fun isMemberEnabled(memberInfo: KotlinMemberInfo): Boolean {
@@ -81,7 +81,7 @@ public class KotlinPullUpDialog(
 
     protected val memberInfoStorage: KotlinMemberInfoStorage get() = myMemberInfoStorage
 
-    protected val sourceClass: JetClassOrObject get() = myClass as JetClassOrObject
+    protected val sourceClass: KtClassOrObject get() = myClass as KtClassOrObject
 
     override fun getDimensionServiceKey() = "#" + javaClass.name
 
@@ -105,10 +105,10 @@ public class KotlinPullUpDialog(
     }
 
     companion object {
-        fun createProcessor(sourceClass: JetClassOrObject,
+        fun createProcessor(sourceClass: KtClassOrObject,
                             targetClass: PsiNamedElement,
                             memberInfos: List<KotlinMemberInfo>): PullUpProcessor {
-            val targetPsiClass = targetClass as? PsiClass ?: (targetClass as JetClass).toLightClass()
+            val targetPsiClass = targetClass as? PsiClass ?: (targetClass as KtClass).toLightClass()
             return PullUpProcessor(sourceClass.toLightClass(),
                                    targetPsiClass,
                                    memberInfos.map { it.toJavaMemberInfo() }.filterNotNull().toTypedArray(),
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpDialogBase.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpDialogBase.java
index a112e34715d..23e2dc48394 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpDialogBase.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpDialogBase.java
@@ -23,8 +23,8 @@ import com.intellij.refactoring.ui.AbstractMemberSelectionTable;
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinOrJavaClassCellRenderer;
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberInfo;
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberInfoStorage;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetNamedDeclaration;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtNamedDeclaration;
 
 import javax.swing.*;
 import java.awt.event.ItemEvent;
@@ -33,10 +33,10 @@ import java.util.List;
 
 // TODO: This is workaround which allows KotlinPullUpDialog to be compiled against both Java 6 and 8
 public abstract class KotlinPullUpDialogBase extends
-                                    PullUpDialogBase<KotlinMemberInfoStorage, KotlinMemberInfo, JetNamedDeclaration, PsiNamedElement> {
+                                    PullUpDialogBase<KotlinMemberInfoStorage, KotlinMemberInfo, KtNamedDeclaration, PsiNamedElement> {
     protected KotlinPullUpDialogBase(
             Project project,
-            JetClassOrObject object,
+            KtClassOrObject object,
             List<PsiNamedElement> superClasses,
             KotlinMemberInfoStorage memberInfoStorage,
             String title
@@ -54,7 +54,7 @@ public abstract class KotlinPullUpDialogBase extends
                     public void itemStateChanged(ItemEvent e) {
                         if (e.getStateChange() == ItemEvent.SELECTED) {
                             if (myMemberSelectionPanel == null) return;
-                            AbstractMemberSelectionTable<JetNamedDeclaration, KotlinMemberInfo> table = myMemberSelectionPanel.getTable();
+                            AbstractMemberSelectionTable<KtNamedDeclaration, KotlinMemberInfo> table = myMemberSelectionPanel.getTable();
                             if (table == null) return;
                             table.setMemberInfos(myMemberInfos);
                             table.fireExternalDataChange();
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHandler.kt
index 160f4996ede..f518e444d04 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHandler.kt
@@ -33,9 +33,9 @@ import org.jetbrains.kotlin.idea.refactoring.AbstractPullPushMembersHandler
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberInfo
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberInfoStorage
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.qualifiedClassNameForRendering
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.types.typeUtil.supertypes
 
@@ -53,7 +53,7 @@ public class KotlinPullUpHandler : AbstractPullPushMembersHandler(
         fun chooseSuperClass(superClasses: List<PsiNamedElement>): PsiNamedElement
     }
 
-    private fun reportNoSuperClasses(project: Project, editor: Editor?, classOrObject: JetClassOrObject) {
+    private fun reportNoSuperClasses(project: Project, editor: Editor?, classOrObject: KtClassOrObject) {
         val message = RefactoringBundle.getCannotRefactorMessage(
                 RefactoringBundle.message("class.does.not.have.base.classes.interfaces.in.current.project",
                                           classOrObject.qualifiedClassNameForRendering())
@@ -62,10 +62,10 @@ public class KotlinPullUpHandler : AbstractPullPushMembersHandler(
     }
 
     override fun invoke(project: Project,
-                       editor: Editor?,
-                       classOrObject: JetClassOrObject?,
-                       member: JetNamedDeclaration?,
-                       dataContext: DataContext?) {
+                        editor: Editor?,
+                        classOrObject: KtClassOrObject?,
+                        member: KtNamedDeclaration?,
+                        dataContext: DataContext?) {
         if (classOrObject == null) {
             reportWrongContext(project, editor)
             return
@@ -78,7 +78,7 @@ public class KotlinPullUpHandler : AbstractPullPushMembersHandler(
                 .map {
                     val descriptor = it.constructor.declarationDescriptor
                     val declaration = descriptor?.let { DescriptorToSourceUtilsIde.getAnyDeclaration(project, it) }
-                    if ((declaration is JetClass || declaration is PsiClass)
+                    if ((declaration is KtClass || declaration is PsiClass)
                         && declaration.canRefactor()) declaration as PsiNamedElement else null
                 }
                 .filterNotNull()
@@ -86,7 +86,7 @@ public class KotlinPullUpHandler : AbstractPullPushMembersHandler(
                 .sortedBy { it.qualifiedClassNameForRendering() }
 
         if (superClasses.isEmpty()) {
-            val containingClass = classOrObject.getStrictParentOfType<JetClassOrObject>()
+            val containingClass = classOrObject.getStrictParentOfType<KtClassOrObject>()
             if (containingClass != null) {
                 invoke(project, editor, containingClass, classOrObject, dataContext)
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelper.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelper.kt
index 4ebb65f3fac..b6a99a886bd 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelper.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelper.kt
@@ -40,7 +40,7 @@ import org.jetbrains.kotlin.idea.intentions.setType
 import org.jetbrains.kotlin.idea.refactoring.safeDelete.removeOverrideModifier
 import org.jetbrains.kotlin.idea.util.anonymousObjectSuperTypeOrNull
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.JetPsiUnifier
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.allChildren
 import org.jetbrains.kotlin.psi.psiUtil.asAssignment
@@ -59,19 +59,19 @@ class KotlinPullUpHelper(
         private val javaData: PullUpData,
         private val data: KotlinPullUpData
 ) : PullUpHelper<MemberInfoBase<PsiMember>> {
-    private fun JetExpression.isMovable(): Boolean {
+    private fun KtExpression.isMovable(): Boolean {
         return accept(
-                object: JetVisitor<Boolean, Nothing?>() {
-                    override fun visitJetElement(element: JetElement, arg: Nothing?): Boolean {
-                        return element.allChildren.all { (it as? JetElement)?.accept(this, arg) ?: true }
+                object: KtVisitor<Boolean, Nothing?>() {
+                    override fun visitJetElement(element: KtElement, arg: Nothing?): Boolean {
+                        return element.allChildren.all { (it as? KtElement)?.accept(this, arg) ?: true }
                     }
 
-                    override fun visitJetFile(file: JetFile, data: Nothing?) = false
+                    override fun visitJetFile(file: KtFile, data: Nothing?) = false
 
-                    override fun visitSimpleNameExpression(expression: JetSimpleNameExpression, arg: Nothing?): Boolean {
+                    override fun visitSimpleNameExpression(expression: KtSimpleNameExpression, arg: Nothing?): Boolean {
                         val resolvedCall = expression.getResolvedCall(data.resolutionFacade.analyze(expression)) ?: return true
                         val receiver = (resolvedCall.getExplicitReceiverValue() as? ExpressionReceiver)?.expression
-                        if (receiver != null && receiver !is JetThisExpression && receiver !is JetSuperExpression) return true
+                        if (receiver != null && receiver !is KtThisExpression && receiver !is KtSuperExpression) return true
 
                         var descriptor: DeclarationDescriptor = resolvedCall.resultingDescriptor
                         if (descriptor is ConstructorDescriptor) {
@@ -93,19 +93,19 @@ class KotlinPullUpHelper(
     }
 
     private fun getCommonInitializer(
-            currentInitializer: JetExpression?,
-            scope: JetBlockExpression?,
+            currentInitializer: KtExpression?,
+            scope: KtBlockExpression?,
             propertyDescriptor: PropertyDescriptor,
-            elementsToRemove: MutableSet<JetElement>): JetExpression? {
+            elementsToRemove: MutableSet<KtElement>): KtExpression? {
         if (scope == null) return currentInitializer
 
-        var initializerCandidate: JetExpression? = null
+        var initializerCandidate: KtExpression? = null
 
         for (statement in scope.statements) {
             statement.asAssignment()?.let body@ {
-                val lhs = JetPsiUtil.safeDeparenthesize(it.left ?: return@body)
-                val receiver = (lhs as? JetQualifiedExpression)?.receiverExpression
-                if (receiver != null && receiver !is JetThisExpression) return@body
+                val lhs = KtPsiUtil.safeDeparenthesize(it.left ?: return@body)
+                val receiver = (lhs as? KtQualifiedExpression)?.receiverExpression
+                if (receiver != null && receiver !is KtThisExpression) return@body
 
                 val resolvedCall = lhs.getResolvedCall(data.resolutionFacade.analyze(it)) ?: return@body
                 if (resolvedCall.resultingDescriptor != propertyDescriptor) return@body
@@ -132,42 +132,42 @@ class KotlinPullUpHelper(
     }
 
     private data class InitializerInfo(
-            val initializer: JetExpression?,
-            val usedProperties: Set<JetProperty>,
-            val usedParameters: Set<JetParameter>,
-            val elementsToRemove: Set<JetElement>
+            val initializer: KtExpression?,
+            val usedProperties: Set<KtProperty>,
+            val usedParameters: Set<KtParameter>,
+            val elementsToRemove: Set<KtElement>
     )
 
-    private fun getInitializerInfo(property: JetProperty,
+    private fun getInitializerInfo(property: KtProperty,
                                    propertyDescriptor: PropertyDescriptor,
-                                   targetConstructor: JetElement): InitializerInfo? {
+                                   targetConstructor: KtElement): InitializerInfo? {
         val sourceConstructors = targetToSourceConstructors[targetConstructor] ?: return null
-        val elementsToRemove = LinkedHashSet<JetElement>()
-        val commonInitializer = sourceConstructors.fold(null as JetExpression?) { commonInitializer, constructor ->
-            val body = (constructor as? JetSecondaryConstructor)?.bodyExpression
+        val elementsToRemove = LinkedHashSet<KtElement>()
+        val commonInitializer = sourceConstructors.fold(null as KtExpression?) { commonInitializer, constructor ->
+            val body = (constructor as? KtSecondaryConstructor)?.bodyExpression
             getCommonInitializer(commonInitializer, body, propertyDescriptor, elementsToRemove)
         }
         if (commonInitializer == null) {
             elementsToRemove.clear()
         }
 
-        val usedProperties = LinkedHashSet<JetProperty>()
-        val usedParameters = LinkedHashSet<JetParameter>()
-        val visitor = object : JetTreeVisitorVoid() {
-            override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+        val usedProperties = LinkedHashSet<KtProperty>()
+        val usedParameters = LinkedHashSet<KtParameter>()
+        val visitor = object : KtTreeVisitorVoid() {
+            override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
                 val context = data.resolutionFacade.analyze(expression)
                 val resolvedCall = expression.getResolvedCall(context) ?: return
                 val receiver = (resolvedCall.getExplicitReceiverValue() as? ExpressionReceiver)?.expression
-                if (receiver != null && receiver !is JetThisExpression) return
+                if (receiver != null && receiver !is KtThisExpression) return
                 val target = (resolvedCall.resultingDescriptor as? DeclarationDescriptorWithSource)?.source?.getPsi()
                 when (target) {
-                    is JetParameter -> usedParameters.add(target)
-                    is JetProperty -> usedProperties.add(target)
+                    is KtParameter -> usedParameters.add(target)
+                    is KtProperty -> usedProperties.add(target)
                 }
             }
         }
         commonInitializer?.accept(visitor)
-        if (targetConstructor == (data.targetClass as? JetClass)?.getPrimaryConstructor() ?: data.targetClass) {
+        if (targetConstructor == (data.targetClass as? KtClass)?.getPrimaryConstructor() ?: data.targetClass) {
             property.initializer?.accept(visitor)
         }
 
@@ -176,35 +176,35 @@ class KotlinPullUpHelper(
 
     private val propertiesToMoveInitializers = with(data) {
         membersToMove
-                .filterIsInstance<JetProperty>()
+                .filterIsInstance<KtProperty>()
                 .filter {
                     val descriptor = memberDescriptors[it] as? PropertyDescriptor
                     descriptor != null && data.sourceClassContext[BindingContext.BACKING_FIELD_REQUIRED, descriptor] ?: false
                 }
     }
 
-    private val targetToSourceConstructors = LinkedHashMap<JetElement, MutableList<JetElement>>().let { result ->
-        if (!data.isInterfaceTarget && data.targetClass is JetClass) {
-            result[data.targetClass.getPrimaryConstructor() ?: data.targetClass] = ArrayList<JetElement>()
+    private val targetToSourceConstructors = LinkedHashMap<KtElement, MutableList<KtElement>>().let { result ->
+        if (!data.isInterfaceTarget && data.targetClass is KtClass) {
+            result[data.targetClass.getPrimaryConstructor() ?: data.targetClass] = ArrayList<KtElement>()
             data.sourceClass.accept(
-                    object : JetTreeVisitorVoid() {
-                        private fun processConstructorReference(expression: JetReferenceExpression, callingConstructorElement: JetElement) {
+                    object : KtTreeVisitorVoid() {
+                        private fun processConstructorReference(expression: KtReferenceExpression, callingConstructorElement: KtElement) {
                             val descriptor = data.resolutionFacade.analyze(expression)[BindingContext.REFERENCE_TARGET, expression]
                             val constructorElement = (descriptor as? DeclarationDescriptorWithSource)?.source?.getPsi() ?: return
                             if (constructorElement == data.targetClass
-                                || (constructorElement as? JetConstructor<*>)?.getContainingClassOrObject() == data.targetClass) {
-                                result.getOrPut(constructorElement as JetElement, { ArrayList() }).add(callingConstructorElement)
+                                || (constructorElement as? KtConstructor<*>)?.getContainingClassOrObject() == data.targetClass) {
+                                result.getOrPut(constructorElement as KtElement, { ArrayList() }).add(callingConstructorElement)
                             }
                         }
 
-                        override fun visitDelegationToSuperCallSpecifier(specifier: JetDelegatorToSuperCall) {
+                        override fun visitDelegationToSuperCallSpecifier(specifier: KtDelegatorToSuperCall) {
                             val constructorRef = specifier.calleeExpression.constructorReferenceExpression ?: return
-                            val containingClass = specifier.getStrictParentOfType<JetClassOrObject>() ?: return
+                            val containingClass = specifier.getStrictParentOfType<KtClassOrObject>() ?: return
                             val callingConstructorElement = containingClass.getPrimaryConstructor() ?: containingClass
                             processConstructorReference(constructorRef, callingConstructorElement)
                         }
 
-                        override fun visitSecondaryConstructor(constructor: JetSecondaryConstructor) {
+                        override fun visitSecondaryConstructor(constructor: KtSecondaryConstructor) {
                             val constructorRef = constructor.getDelegationCall().calleeExpression ?: return
                             processConstructorReference(constructorRef, constructor)
                         }
@@ -214,18 +214,18 @@ class KotlinPullUpHelper(
         result
     }
 
-    private val targetConstructorToPropertyInitializerInfoMap = LinkedHashMap<JetElement, Map<JetProperty, InitializerInfo>>().let { result ->
+    private val targetConstructorToPropertyInitializerInfoMap = LinkedHashMap<KtElement, Map<KtProperty, InitializerInfo>>().let { result ->
         for (targetConstructor in targetToSourceConstructors.keySet()) {
-            val propertyToInitializerInfo = LinkedHashMap<JetProperty, InitializerInfo>()
+            val propertyToInitializerInfo = LinkedHashMap<KtProperty, InitializerInfo>()
             for (property in propertiesToMoveInitializers) {
                 val propertyDescriptor = data.memberDescriptors[property] as? PropertyDescriptor ?: continue
                 propertyToInitializerInfo[property] = getInitializerInfo(property, propertyDescriptor, targetConstructor) ?: continue
             }
             val unmovableProperties = RefactoringUtil.transitiveClosure(
-                    object : RefactoringUtil.Graph<JetProperty> {
+                    object : RefactoringUtil.Graph<KtProperty> {
                         override fun getVertices() = propertyToInitializerInfo.keySet()
 
-                        override fun getTargets(source: JetProperty) = propertyToInitializerInfo[source]?.usedProperties
+                        override fun getTargets(source: KtProperty) = propertyToInitializerInfo[source]?.usedProperties
                     },
                     { !propertyToInitializerInfo.containsKey(it) }
             )
@@ -238,8 +238,8 @@ class KotlinPullUpHelper(
 
     private var dummyField: PsiField? = null
 
-    private fun addMovedMember(newMember: JetNamedDeclaration) {
-        if (newMember is JetProperty) {
+    private fun addMovedMember(newMember: KtNamedDeclaration) {
+        if (newMember is KtProperty) {
             // Add dummy light field since PullUpProcessor won't invoke moveFieldInitializations() if no PsiFields are present
             if (dummyField == null) {
                 val factory = JavaPsiFacade.getElementFactory(newMember.project)
@@ -256,10 +256,10 @@ class KotlinPullUpHelper(
         }
 
         when (newMember) {
-            is JetProperty, is JetNamedFunction -> {
+            is KtProperty, is KtNamedFunction -> {
                 newMember.getRepresentativeLightMethod()?.let { javaData.movedMembers.add(it) }
             }
-            is JetClassOrObject -> {
+            is KtClassOrObject -> {
                 newMember.toLightClass()?.let { javaData.movedMembers.add(it) }
             }
         }
@@ -271,29 +271,29 @@ class KotlinPullUpHelper(
                 .all { it.element.parentsWithSelf.any { it in data.membersToMove } }
     }
 
-    private fun liftToProtected(declaration: JetNamedDeclaration, ignoreUsages: Boolean = false) {
-        if (!declaration.hasModifier(JetTokens.PRIVATE_KEYWORD)) return
-        if (ignoreUsages || willBeUsedInSourceClass(declaration)) declaration.addModifierWithSpace(JetTokens.PROTECTED_KEYWORD)
+    private fun liftToProtected(declaration: KtNamedDeclaration, ignoreUsages: Boolean = false) {
+        if (!declaration.hasModifier(KtTokens.PRIVATE_KEYWORD)) return
+        if (ignoreUsages || willBeUsedInSourceClass(declaration)) declaration.addModifierWithSpace(KtTokens.PROTECTED_KEYWORD)
     }
 
     override fun setCorrectVisibility(info: MemberInfoBase<PsiMember>) {
-        val member = info.member.namedUnwrappedElement as? JetNamedDeclaration ?: return
+        val member = info.member.namedUnwrappedElement as? KtNamedDeclaration ?: return
 
         if (data.isInterfaceTarget) {
-            member.removeModifier(JetTokens.PUBLIC_KEYWORD)
+            member.removeModifier(KtTokens.PUBLIC_KEYWORD)
             return
         }
 
-        if (member.hasModifier(JetTokens.PRIVATE_KEYWORD)) {
+        if (member.hasModifier(KtTokens.PRIVATE_KEYWORD)) {
             member.accept(
-                    object: JetVisitorVoid() {
-                        override fun visitNamedDeclaration(declaration: JetNamedDeclaration) {
+                    object: KtVisitorVoid() {
+                        override fun visitNamedDeclaration(declaration: KtNamedDeclaration) {
                             when (declaration) {
-                                is JetClass -> {
+                                is KtClass -> {
                                     liftToProtected(declaration)
                                     declaration.declarations.forEach { it.accept(this) }
                                 }
-                                is JetNamedFunction, is JetProperty -> {
+                                is KtNamedFunction, is KtProperty -> {
                                     liftToProtected(declaration, declaration == member && info.isToAbstract)
                                 }
                             }
@@ -307,8 +307,8 @@ class KotlinPullUpHelper(
 
     }
 
-    private fun fixOverrideAndGetClashingSuper(sourceMember: JetCallableDeclaration,
-                                               targetMember: JetCallableDeclaration): JetCallableDeclaration? {
+    private fun fixOverrideAndGetClashingSuper(sourceMember: KtCallableDeclaration,
+                                               targetMember: KtCallableDeclaration): KtCallableDeclaration? {
         val memberDescriptor = data.memberDescriptors[sourceMember] as CallableMemberDescriptor
 
         if (memberDescriptor.overriddenDescriptors.isEmpty()) {
@@ -320,14 +320,14 @@ class KotlinPullUpHelper(
         if (clashingSuperDescriptor.overriddenDescriptors.isEmpty()) {
             targetMember.removeOverrideModifier()
         }
-        return clashingSuperDescriptor.source.getPsi() as? JetCallableDeclaration
+        return clashingSuperDescriptor.source.getPsi() as? KtCallableDeclaration
     }
 
-    private fun moveSuperInterface(member: JetClass, substitutor: PsiSubstitutor) {
+    private fun moveSuperInterface(member: KtClass, substitutor: PsiSubstitutor) {
         val classDescriptor = data.memberDescriptors[member] as? ClassDescriptor ?: return
         val currentSpecifier = data.sourceClass.getDelegatorToSuperClassByDescriptor(classDescriptor, data.sourceClassContext) ?: return
         when (data.targetClass) {
-            is JetClass -> {
+            is KtClass -> {
                 data.sourceClass.removeDelegationSpecifier(currentSpecifier)
                 addDelegatorToSuperClass(currentSpecifier, data.targetClass, data.targetClassDescriptor, data.sourceClassContext, data.sourceToTargetClassSubstitutor)
             }
@@ -354,20 +354,20 @@ class KotlinPullUpHelper(
         return
     }
 
-    private fun removeOriginalMemberOrAddOverride(member: JetCallableDeclaration) {
-        if (member.hasModifier(JetTokens.ABSTRACT_KEYWORD)) {
+    private fun removeOriginalMemberOrAddOverride(member: KtCallableDeclaration) {
+        if (member.hasModifier(KtTokens.ABSTRACT_KEYWORD)) {
             member.delete()
         }
         else {
-            member.addModifierWithSpace(JetTokens.OVERRIDE_KEYWORD)
+            member.addModifierWithSpace(KtTokens.OVERRIDE_KEYWORD)
         }
     }
 
-    private fun moveToJavaClass(member: JetNamedDeclaration, substitutor: PsiSubstitutor) {
+    private fun moveToJavaClass(member: KtNamedDeclaration, substitutor: PsiSubstitutor) {
         if (!(data.targetClass is PsiClass && member.canMoveMemberToJavaClass(data.targetClass))) return
 
         // TODO: Drop after PsiTypes in light elements are properly generated
-        if (member is JetCallableDeclaration && member.typeReference == null) {
+        if (member is KtCallableDeclaration && member.typeReference == null) {
             val returnType = (data.memberDescriptors[member] as CallableDescriptor).returnType
             returnType?.anonymousObjectSuperTypeOrNull()?.let { member.setType(it, false) }
         }
@@ -377,14 +377,14 @@ class KotlinPullUpHelper(
         val lightMethod = member.getRepresentativeLightMethod()!!
 
         val movedMember: PsiMember = when (member) {
-            is JetProperty -> {
+            is KtProperty -> {
                 val newType = substitutor.substitute(lightMethod.returnType)
                 val newField = createJavaField(member, data.targetClass)
                 newField.typeElement?.replace(elementFactory.createTypeElement(newType))
                 member.delete()
                 newField
             }
-            is JetNamedFunction -> {
+            is KtNamedFunction -> {
                 val newReturnType = substitutor.substitute(lightMethod.returnType)
                 val newParameterTypes = lightMethod.parameterList.parameters.map { substitutor.substitute(it.type) }
                 val objectType = PsiType.getJavaLangObject(PsiManager.getInstance(project), GlobalSearchScope.allScope(project))
@@ -414,9 +414,9 @@ class KotlinPullUpHelper(
     }
 
     override fun move(info: MemberInfoBase<PsiMember>, substitutor: PsiSubstitutor) {
-        val member = info.member.namedUnwrappedElement as? JetNamedDeclaration ?: return
+        val member = info.member.namedUnwrappedElement as? KtNamedDeclaration ?: return
 
-        if (member is JetClass && info.overrides != null)  {
+        if (member is KtClass && info.overrides != null)  {
             moveSuperInterface(member, substitutor)
             return
         }
@@ -427,29 +427,29 @@ class KotlinPullUpHelper(
         }
 
         val markedElements = markElements(member, data.sourceClassContext, data.sourceClassDescriptor, data.targetClassDescriptor)
-        val memberCopy = member.copy() as JetNamedDeclaration
+        val memberCopy = member.copy() as KtNamedDeclaration
 
-        fun moveClassOrObject(member: JetClassOrObject, memberCopy: JetClassOrObject): JetClassOrObject {
+        fun moveClassOrObject(member: KtClassOrObject, memberCopy: KtClassOrObject): KtClassOrObject {
             if (data.isInterfaceTarget) {
-                memberCopy.removeModifier(JetTokens.INNER_KEYWORD)
+                memberCopy.removeModifier(KtTokens.INNER_KEYWORD)
             }
 
-            val movedMember = addMemberToTarget(memberCopy, data.targetClass as JetClass) as JetClassOrObject
+            val movedMember = addMemberToTarget(memberCopy, data.targetClass as KtClass) as KtClassOrObject
             member.delete()
             return movedMember
         }
 
-        fun moveCallableMember(member: JetCallableDeclaration, memberCopy: JetCallableDeclaration): JetCallableDeclaration {
-            data.targetClass as JetClass
+        fun moveCallableMember(member: KtCallableDeclaration, memberCopy: KtCallableDeclaration): KtCallableDeclaration {
+            data.targetClass as KtClass
 
-            val movedMember: JetCallableDeclaration
+            val movedMember: KtCallableDeclaration
             val clashingSuper = fixOverrideAndGetClashingSuper(member, memberCopy)
 
-            val originalIsAbstract = member.hasModifier(JetTokens.ABSTRACT_KEYWORD)
+            val originalIsAbstract = member.hasModifier(KtTokens.ABSTRACT_KEYWORD)
             val toAbstract = when {
                 info.isToAbstract -> true
                 !data.isInterfaceTarget -> false
-                member is JetProperty -> member.mustBeAbstractInInterface()
+                member is KtProperty -> member.mustBeAbstractInInterface()
                 else -> false
             }
             if (toAbstract) {
@@ -470,10 +470,10 @@ class KotlinPullUpHelper(
             }
 
             if (originalIsAbstract && data.isInterfaceTarget) {
-                movedMember.removeModifier(JetTokens.ABSTRACT_KEYWORD)
+                movedMember.removeModifier(KtTokens.ABSTRACT_KEYWORD)
             }
 
-            if (movedMember.hasModifier(JetTokens.ABSTRACT_KEYWORD)) {
+            if (movedMember.hasModifier(KtTokens.ABSTRACT_KEYWORD)) {
                 data.targetClass.makeAbstract()
             }
             return movedMember
@@ -481,8 +481,8 @@ class KotlinPullUpHelper(
 
         try {
             val movedMember = when (member) {
-                is JetCallableDeclaration -> moveCallableMember(member, memberCopy as JetCallableDeclaration)
-                is JetClassOrObject -> moveClassOrObject(member, memberCopy as JetClassOrObject)
+                is KtCallableDeclaration -> moveCallableMember(member, memberCopy as KtCallableDeclaration)
+                is KtClassOrObject -> moveClassOrObject(member, memberCopy as KtClassOrObject)
                 else -> return
             }
 
@@ -499,37 +499,37 @@ class KotlinPullUpHelper(
     }
 
     override fun moveFieldInitializations(movedFields: LinkedHashSet<PsiField>) {
-        val psiFactory = JetPsiFactory(data.sourceClass)
+        val psiFactory = KtPsiFactory(data.sourceClass)
 
-        fun JetClassOrObject.getOrCreateClassInitializer(): JetClassInitializer {
-            getOrCreateBody().declarations.lastOrNull { it is JetClassInitializer }?.let { return it as JetClassInitializer }
-            return addDeclaration(psiFactory.createAnonymousInitializer()) as JetClassInitializer
+        fun KtClassOrObject.getOrCreateClassInitializer(): KtClassInitializer {
+            getOrCreateBody().declarations.lastOrNull { it is KtClassInitializer }?.let { return it as KtClassInitializer }
+            return addDeclaration(psiFactory.createAnonymousInitializer()) as KtClassInitializer
         }
 
-        fun JetElement.getConstructorBodyBlock(): JetBlockExpression? {
+        fun KtElement.getConstructorBodyBlock(): KtBlockExpression? {
             return when (this) {
-                is JetClassOrObject -> {
+                is KtClassOrObject -> {
                     getOrCreateClassInitializer().body
                 }
-                is JetPrimaryConstructor -> {
+                is KtPrimaryConstructor -> {
                     getContainingClassOrObject().getOrCreateClassInitializer().body
                 }
-                is JetSecondaryConstructor -> {
+                is KtSecondaryConstructor -> {
                     bodyExpression ?: add(psiFactory.createEmptyBody())
                 }
                 else -> null
-            } as? JetBlockExpression
+            } as? KtBlockExpression
         }
 
-        fun JetClassOrObject.getDelegatorToSuperCall(): JetDelegatorToSuperCall? {
-            return getDelegationSpecifiers().singleOrNull { it is JetDelegatorToSuperCall } as? JetDelegatorToSuperCall
+        fun KtClassOrObject.getDelegatorToSuperCall(): KtDelegatorToSuperCall? {
+            return getDelegationSpecifiers().singleOrNull { it is KtDelegatorToSuperCall } as? KtDelegatorToSuperCall
         }
 
-        fun addUsedParameters(constructorElement: JetElement, info: InitializerInfo) {
+        fun addUsedParameters(constructorElement: KtElement, info: InitializerInfo) {
             if (!info.usedParameters.isNotEmpty()) return
-            val constructor: JetConstructor<*> = when (constructorElement) {
-                is JetConstructor<*> -> constructorElement
-                is JetClass -> constructorElement.createPrimaryConstructorIfAbsent()
+            val constructor: KtConstructor<*> = when (constructorElement) {
+                is KtConstructor<*> -> constructorElement
+                is KtClass -> constructorElement.createPrimaryConstructorIfAbsent()
                 else -> return
             }
 
@@ -542,10 +542,10 @@ class KotlinPullUpHelper(
                 }
             }
             targetToSourceConstructors[constructorElement]!!.forEach {
-                val superCall: JetCallElement? = when (it) {
-                    is JetClassOrObject -> it.getDelegatorToSuperCall()
-                    is JetPrimaryConstructor -> it.getContainingClassOrObject().getDelegatorToSuperCall()
-                    is JetSecondaryConstructor -> {
+                val superCall: KtCallElement? = when (it) {
+                    is KtClassOrObject -> it.getDelegatorToSuperCall()
+                    is KtPrimaryConstructor -> it.getContainingClassOrObject().getDelegatorToSuperCall()
+                    is KtSecondaryConstructor -> {
                         if (it.hasImplicitDelegationCall()) {
                             it.replaceImplicitDelegationCallWithExplicit(false)
                         }
@@ -565,8 +565,8 @@ class KotlinPullUpHelper(
 
         for ((constructorElement, propertyToInitializerInfo) in targetConstructorToPropertyInitializerInfoMap.entrySet()) {
             val properties = propertyToInitializerInfo.keySet().sortedWith(
-                    object : Comparator<JetProperty> {
-                        override fun compare(property1: JetProperty, property2: JetProperty): Int {
+                    object : Comparator<KtProperty> {
+                        override fun compare(property1: KtProperty, property2: KtProperty): Int {
                             val info1 = propertyToInitializerInfo[property1]!!
                             val info2 = propertyToInitializerInfo[property2]!!
                             return when {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelperFactory.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelperFactory.kt
index 95d07a4e849..02f79158192 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelperFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelperFactory.kt
@@ -27,18 +27,18 @@ import org.jetbrains.kotlin.asJava.namedUnwrappedElement
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.core.refactoring.createJavaClass
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.parents
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
 public class KotlinPullUpHelperFactory : PullUpHelperFactory {
     private fun PullUpData.toKotlinPullUpData(): KotlinPullUpData? {
-        val sourceClass = sourceClass.unwrapped as? JetClassOrObject ?: return null
+        val sourceClass = sourceClass.unwrapped as? KtClassOrObject ?: return null
         val targetClass = targetClass.unwrapped as? PsiNamedElement ?: return null
         val membersToMove = membersToMove
-                .map { it.namedUnwrappedElement as? JetNamedDeclaration }
+                .map { it.namedUnwrappedElement as? KtNamedDeclaration }
                 .filterNotNull()
                 .sortedBy { it.startOffset }
         return KotlinPullUpData(sourceClass, targetClass, membersToMove)
@@ -67,7 +67,7 @@ public class JavaToKotlinPullUpHelperFactory : PullUpHelperFactory {
     }
 
     private fun createDummyTargetClass(data: PullUpData): PsiClass? {
-        val targetClass = data.targetClass.unwrapped as? JetClass ?: return null
+        val targetClass = data.targetClass.unwrapped as? KtClass ?: return null
 
         val project = targetClass.project
         val targetPackage = targetClass.getContainingJetFile().packageFqName.asString()
@@ -79,13 +79,13 @@ public class JavaToKotlinPullUpHelperFactory : PullUpHelperFactory {
         val elementFactory = PsiElementFactory.SERVICE.getInstance(project)
 
         val dummyTargetClass = createJavaClass(targetClass, null, forcePlainClass = true)
-        val outerClasses = targetClass.parents.filterIsInstance<JetClassOrObject>().toList().asReversed()
+        val outerClasses = targetClass.parents.filterIsInstance<KtClassOrObject>().toList().asReversed()
 
         if (outerClasses.isEmpty()) return dummyFile.add(dummyTargetClass) as PsiClass
 
         val outerPsiClasses = outerClasses.map {
             val psiClass = elementFactory.createClass(it.name!!)
-            if (!(it is JetClass && it.isInner())) {
+            if (!(it is KtClass && it.isInner())) {
                 psiClass.modifierList!!.setModifierProperty(PsiModifier.STATIC, true)
             }
             psiClass
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/markingUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/markingUtils.kt
index 5093f5b20d2..31222bec7c8 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/markingUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/markingUtils.kt
@@ -36,20 +36,20 @@ import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.types.Variance
 import java.util.*
 
-private var JetElement.newFqName: FqName? by CopyableUserDataProperty(Key.create("NEW_FQ_NAME"))
-private var JetElement.replaceWithTargetThis: Boolean? by CopyableUserDataProperty(Key.create("REPLACE_WITH_TARGET_THIS"))
-private var JetElement.newTypeText: ((TypeSubstitutor) -> String?)? by CopyableUserDataProperty(Key.create("NEW_TYPE_TEXT"))
+private var KtElement.newFqName: FqName? by CopyableUserDataProperty(Key.create("NEW_FQ_NAME"))
+private var KtElement.replaceWithTargetThis: Boolean? by CopyableUserDataProperty(Key.create("REPLACE_WITH_TARGET_THIS"))
+private var KtElement.newTypeText: ((TypeSubstitutor) -> String?)? by CopyableUserDataProperty(Key.create("NEW_TYPE_TEXT"))
 
 fun markElements(
-        declaration: JetNamedDeclaration,
+        declaration: KtNamedDeclaration,
         context: BindingContext,
         sourceClassDescriptor: ClassDescriptor, targetClassDescriptor: ClassDescriptor?
-): List<JetElement> {
-    val affectedElements = ArrayList<JetElement>()
+): List<KtElement> {
+    val affectedElements = ArrayList<KtElement>()
 
     declaration.accept(
-            object : JetVisitorVoid() {
-                private fun visitSuperOrThis(expression: JetInstanceExpressionWithLabel) {
+            object : KtVisitorVoid() {
+                private fun visitSuperOrThis(expression: KtInstanceExpressionWithLabel) {
                     if (targetClassDescriptor == null) return
 
                     val referenceTarget = context[BindingContext.REFERENCE_TARGET, expression.instanceReference]
@@ -63,7 +63,7 @@ fun markElements(
                     element.allChildren.forEach { it.accept(this) }
                 }
 
-                override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+                override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
                     val resolvedCall = expression.getResolvedCall(context) ?: return
                     var receiver = resolvedCall.getExplicitReceiverValue()
                     if (!receiver.exists()) {
@@ -84,15 +84,15 @@ fun markElements(
                     }
                 }
 
-                override fun visitThisExpression(expression: JetThisExpression) {
+                override fun visitThisExpression(expression: KtThisExpression) {
                     visitSuperOrThis(expression)
                 }
 
-                override fun visitSuperExpression(expression: JetSuperExpression) {
+                override fun visitSuperExpression(expression: KtSuperExpression) {
                     visitSuperOrThis(expression)
                 }
 
-                override fun visitTypeReference(typeReference: JetTypeReference) {
+                override fun visitTypeReference(typeReference: KtTypeReference) {
                     val oldType = context[BindingContext.TYPE, typeReference] ?: return
                     typeReference.newTypeText = f@ { substitutor ->
                         substitutor.substitute(oldType, Variance.INVARIANT)?.let { IdeDescriptorRenderers.SOURCE_CODE.renderType(it) }
@@ -106,20 +106,20 @@ fun markElements(
 }
 
 fun applyMarking(
-        declaration: JetNamedDeclaration,
+        declaration: KtNamedDeclaration,
         substitutor: TypeSubstitutor, targetClassDescriptor: ClassDescriptor
 ) {
-    val psiFactory = JetPsiFactory(declaration)
+    val psiFactory = KtPsiFactory(declaration)
     val targetThis = psiFactory.createExpression("this@${targetClassDescriptor.name.asString()}")
     val shorteningOptionsForThis = ShortenReferences.Options(removeThisLabels = true, removeThis = true)
 
     declaration.accept(
-            object : JetVisitorVoid() {
-                private fun visitSuperOrThis(expression: JetInstanceExpressionWithLabel) {
+            object : KtVisitorVoid() {
+                private fun visitSuperOrThis(expression: KtInstanceExpressionWithLabel) {
                     expression.replaceWithTargetThis?.let {
                         expression.replaceWithTargetThis = null
 
-                        val newThisExpression = expression.replace(targetThis) as JetExpression
+                        val newThisExpression = expression.replace(targetThis) as KtExpression
                         newThisExpression.getQualifiedExpressionForReceiverOrThis().addToShorteningWaitSet(shorteningOptionsForThis)
                     }
                 }
@@ -130,7 +130,7 @@ fun applyMarking(
                     }
                 }
 
-                override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+                override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
                     expression.newFqName?.let {
                         expression.newFqName = null
 
@@ -138,27 +138,27 @@ fun applyMarking(
                     }
                 }
 
-                override fun visitThisExpression(expression: JetThisExpression) {
+                override fun visitThisExpression(expression: KtThisExpression) {
                     this.visitSuperOrThis(expression)
                 }
 
-                override fun visitSuperExpression(expression: JetSuperExpression) {
+                override fun visitSuperExpression(expression: KtSuperExpression) {
                     this.visitSuperOrThis(expression)
                 }
 
-                override fun visitTypeReference(typeReference: JetTypeReference) {
+                override fun visitTypeReference(typeReference: KtTypeReference) {
                     typeReference.newTypeText?.let f@ {
                         typeReference.newTypeText = null
 
                         val newTypeText = it(substitutor) ?: return@f
-                        (typeReference.replace(psiFactory.createType(newTypeText)) as JetElement).addToShorteningWaitSet()
+                        (typeReference.replace(psiFactory.createType(newTypeText)) as KtElement).addToShorteningWaitSet()
                     }
                 }
             }
     )
 }
 
-fun clearMarking(markedElements: List<JetElement>) {
+fun clearMarking(markedElements: List<KtElement>) {
     markedElements.forEach {
         it.newFqName = null
         it.newTypeText = null
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpConflictsUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpConflictsUtils.kt
index 1f18b55a647..9ce5c31e626 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpConflictsUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpConflictsUtils.kt
@@ -25,11 +25,11 @@ import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.core.refactoring.checkConflictsInteractively
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberInfo
-import org.jetbrains.kotlin.idea.references.JetReference
+import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.idea.search.declarationsSearch.HierarchySearchRequest
 import org.jetbrains.kotlin.idea.search.declarationsSearch.searchInheritors
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.allChildren
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
@@ -42,7 +42,7 @@ import org.jetbrains.kotlin.types.substitutions.getTypeSubstitutor
 import org.jetbrains.kotlin.util.findCallableMemberBySignature
 
 fun checkConflicts(project: Project,
-                   sourceClass: JetClassOrObject,
+                   sourceClass: KtClassOrObject,
                    targetClass: PsiNamedElement,
                    memberInfos: List<KotlinMemberInfo>,
                    onShowConflicts: () -> Unit = {},
@@ -89,7 +89,7 @@ internal fun KotlinPullUpData.getClashingMemberInTargetClass(memberDescriptor: C
 }
 
 private fun KotlinPullUpData.checkClashWithSuperDeclaration(
-        member: JetNamedDeclaration,
+        member: KtNamedDeclaration,
         memberDescriptor: DeclarationDescriptor,
         conflicts: MultiMap<PsiElement, String>) {
     if (memberDescriptor is CallableMemberDescriptor) {
@@ -102,17 +102,17 @@ private fun KotlinPullUpData.checkClashWithSuperDeclaration(
 }
 
 private fun KotlinPullUpData.checkAccidentalOverrides(
-        member: JetNamedDeclaration,
+        member: KtNamedDeclaration,
         memberDescriptor: DeclarationDescriptor,
         conflicts: MultiMap<PsiElement, String>) {
-    if (memberDescriptor is CallableDescriptor && !member.hasModifier(JetTokens.PRIVATE_KEYWORD)) {
+    if (memberDescriptor is CallableDescriptor && !member.hasModifier(KtTokens.PRIVATE_KEYWORD)) {
         val memberDescriptorInTargetClass = memberDescriptor.substitute(sourceToTargetClassSubstitutor)
         if (memberDescriptorInTargetClass != null) {
             HierarchySearchRequest<PsiElement>(targetClass, targetClass.useScope)
                     .searchInheritors()
                     .asSequence()
                     .filterNot { it.unwrapped == sourceClass || it.unwrapped == targetClass }
-                    .map { it.unwrapped as? JetClassOrObject }
+                    .map { it.unwrapped as? KtClassOrObject }
                     .filterNotNull()
                     .forEach {
                         val subClassDescriptor = resolutionFacade.resolveToDescriptor(it) as ClassDescriptor
@@ -134,7 +134,7 @@ private fun KotlinPullUpData.checkAccidentalOverrides(
 }
 
 private fun KotlinPullUpData.checkInnerClassToInterface(
-        member: JetNamedDeclaration,
+        member: KtNamedDeclaration,
         memberDescriptor: DeclarationDescriptor,
         conflicts: MultiMap<PsiElement, String>) {
     if (isInterfaceTarget && memberDescriptor is ClassDescriptor && memberDescriptor.isInner) {
@@ -163,10 +163,10 @@ private fun KotlinPullUpData.checkVisibility(
 
     val member = memberInfo.member
     val childrenToCheck = member.allChildren.toArrayList()
-    if (memberInfo.isToAbstract && member is JetCallableDeclaration) {
+    if (memberInfo.isToAbstract && member is KtCallableDeclaration) {
         when (member) {
-            is JetNamedFunction -> childrenToCheck.remove(member.bodyExpression)
-            is JetProperty -> {
+            is KtNamedFunction -> childrenToCheck.remove(member.bodyExpression)
+            is KtProperty -> {
                 childrenToCheck.remove(member.initializer)
                 childrenToCheck.remove(member.delegateExpression)
                 childrenToCheck.removeAll(member.accessors)
@@ -186,13 +186,13 @@ private fun KotlinPullUpData.checkVisibility(
 
     childrenToCheck.forEach {
         it.accept(
-                object : JetTreeVisitorVoid() {
-                    override fun visitReferenceExpression(expression: JetReferenceExpression) {
+                object : KtTreeVisitorVoid() {
+                    override fun visitReferenceExpression(expression: KtReferenceExpression) {
                         super.visitReferenceExpression(expression)
 
                         val context = resolutionFacade.analyze(expression)
                         expression.references
-                                .flatMap { (it as? JetReference)?.resolveToDescriptors(context) ?: emptyList() }
+                                .flatMap { (it as? KtReference)?.resolveToDescriptors(context) ?: emptyList() }
                                 .forEach(::reportConflictIfAny)
 
                     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpUtils.kt
index 2ba98fa9e51..e3598ec8910 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpUtils.kt
@@ -25,8 +25,8 @@ import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.intentions.setType
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.anonymousObjectSuperTypeOrNull
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -35,78 +35,78 @@ import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.typeUtil.isUnit
 
-fun JetProperty.mustBeAbstractInInterface() =
+fun KtProperty.mustBeAbstractInInterface() =
         hasInitializer() || hasDelegate() || (!hasInitializer() && !hasDelegate() && accessors.isEmpty())
 
-fun JetNamedDeclaration.canMoveMemberToJavaClass(targetClass: PsiClass): Boolean {
+fun KtNamedDeclaration.canMoveMemberToJavaClass(targetClass: PsiClass): Boolean {
     return when (this) {
-        is JetProperty -> {
+        is KtProperty -> {
             if (targetClass.isInterface) return false
-            if (hasModifier(JetTokens.OPEN_KEYWORD) || hasModifier(JetTokens.ABSTRACT_KEYWORD)) return false
+            if (hasModifier(KtTokens.OPEN_KEYWORD) || hasModifier(KtTokens.ABSTRACT_KEYWORD)) return false
             if (accessors.isNotEmpty() || delegateExpression != null) return false
             true
         }
-        is JetNamedFunction -> true
+        is KtNamedFunction -> true
         else -> false
     }
 }
 
-fun addMemberToTarget(targetMember: JetNamedDeclaration, targetClass: JetClassOrObject): JetNamedDeclaration {
+fun addMemberToTarget(targetMember: KtNamedDeclaration, targetClass: KtClassOrObject): KtNamedDeclaration {
     val anchor = targetClass.declarations.filterIsInstance(targetMember.javaClass).lastOrNull()
     val movedMember = when {
-        anchor == null && targetMember is JetProperty -> targetClass.addDeclarationBefore(targetMember, null)
+        anchor == null && targetMember is KtProperty -> targetClass.addDeclarationBefore(targetMember, null)
         else -> targetClass.addDeclarationAfter(targetMember, anchor)
     }
-    return movedMember as JetNamedDeclaration
+    return movedMember as KtNamedDeclaration
 }
 
 fun doAddCallableMember(
-        memberCopy: JetCallableDeclaration,
-        clashingSuper: JetCallableDeclaration?,
-        targetClass: JetClass): JetCallableDeclaration {
-    if (clashingSuper != null && clashingSuper.hasModifier(JetTokens.ABSTRACT_KEYWORD)) {
+        memberCopy: KtCallableDeclaration,
+        clashingSuper: KtCallableDeclaration?,
+        targetClass: KtClass): KtCallableDeclaration {
+    if (clashingSuper != null && clashingSuper.hasModifier(KtTokens.ABSTRACT_KEYWORD)) {
         return clashingSuper.replaced(memberCopy)
     }
-    return addMemberToTarget(memberCopy, targetClass) as JetCallableDeclaration
+    return addMemberToTarget(memberCopy, targetClass) as KtCallableDeclaration
 }
 
 // TODO: Formatting rules don't apply here for some reason
-fun JetNamedDeclaration.addModifierWithSpace(modifier: JetModifierKeywordToken) {
+fun KtNamedDeclaration.addModifierWithSpace(modifier: KtModifierKeywordToken) {
     addModifier(modifier)
-    addAfter(JetPsiFactory(this).createWhiteSpace(), modifierList)
+    addAfter(KtPsiFactory(this).createWhiteSpace(), modifierList)
 }
 
 // TODO: Formatting rules don't apply here for some reason
-fun JetNamedDeclaration.addAnnotationWithSpace(annotationEntry: JetAnnotationEntry): JetAnnotationEntry {
+fun KtNamedDeclaration.addAnnotationWithSpace(annotationEntry: KtAnnotationEntry): KtAnnotationEntry {
     val result = addAnnotationEntry(annotationEntry)
-    addAfter(JetPsiFactory(this).createWhiteSpace(), modifierList)
+    addAfter(KtPsiFactory(this).createWhiteSpace(), modifierList)
     return result
 }
 
-fun JetClass.makeAbstract() {
+fun KtClass.makeAbstract() {
     if (!isInterface()) {
-        addModifierWithSpace(JetTokens.ABSTRACT_KEYWORD)
+        addModifierWithSpace(KtTokens.ABSTRACT_KEYWORD)
     }
 }
 
-fun JetClassOrObject.getDelegatorToSuperClassByDescriptor(
+fun KtClassOrObject.getDelegatorToSuperClassByDescriptor(
         descriptor: ClassDescriptor,
         context: BindingContext
-): JetDelegatorToSuperClass? {
+): KtDelegatorToSuperClass? {
     return getDelegationSpecifiers()
-            .filterIsInstance<JetDelegatorToSuperClass>()
+            .filterIsInstance<KtDelegatorToSuperClass>()
             .firstOrNull {
                 val referencedType = context[BindingContext.TYPE, it.typeReference]
                 referencedType?.constructor?.declarationDescriptor == descriptor
             }
 }
 
-fun makeAbstract(member: JetCallableDeclaration,
+fun makeAbstract(member: KtCallableDeclaration,
                  originalMemberDescriptor: CallableMemberDescriptor,
                  substitutor: TypeSubstitutor,
-                 targetClass: JetClass) {
+                 targetClass: KtClass) {
     if (!targetClass.isInterface()) {
-        member.addModifierWithSpace(JetTokens.ABSTRACT_KEYWORD)
+        member.addModifierWithSpace(KtTokens.ABSTRACT_KEYWORD)
     }
 
     val builtIns = originalMemberDescriptor.builtIns
@@ -120,17 +120,17 @@ fun makeAbstract(member: JetCallableDeclaration,
                    ?: builtIns.nullableAnyType
         }
 
-        if (member is JetProperty || !type.isUnit()) {
+        if (member is KtProperty || !type.isUnit()) {
             member.setType(type, false)
         }
     }
 
     val deleteFrom = when (member) {
-        is JetProperty -> {
+        is KtProperty -> {
             member.equalsToken ?: member.delegate ?: member.accessors.firstOrNull()
         }
 
-        is JetNamedFunction -> {
+        is KtNamedFunction -> {
             member.equalsToken ?: member.bodyExpression
         }
 
@@ -143,8 +143,8 @@ fun makeAbstract(member: JetCallableDeclaration,
 }
 
 fun addDelegatorToSuperClass(
-        delegator: JetDelegatorToSuperClass,
-        targetClass: JetClassOrObject,
+        delegator: KtDelegatorToSuperClass,
+        targetClass: KtClassOrObject,
         targetClassDescriptor: ClassDescriptor,
         context: BindingContext,
         substitutor: TypeSubstitutor
@@ -158,6 +158,6 @@ fun addDelegatorToSuperClass(
     if (!(typeInTargetClass != null && !typeInTargetClass.isError)) return
 
     val renderedType = IdeDescriptorRenderers.SOURCE_CODE.renderType(typeInTargetClass)
-    val newSpecifier = JetPsiFactory(targetClass).createDelegatorToSuperClass(renderedType)
+    val newSpecifier = KtPsiFactory(targetClass).createDelegatorToSuperClass(renderedType)
     targetClass.addDelegationSpecifier(newSpecifier).addToShorteningWaitSet()
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownDialog.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownDialog.kt
index 744e611f652..8e3318bf873 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownDialog.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownDialog.kt
@@ -25,10 +25,10 @@ import com.intellij.refactoring.ui.RefactoringDialog
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberInfo
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberSelectionPanel
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.qualifiedClassNameForRendering
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtProperty
 import java.awt.BorderLayout
 import java.awt.GridBagConstraints
 import java.awt.GridBagLayout
@@ -40,14 +40,14 @@ import javax.swing.JPanel
 public class KotlinPushDownDialog(
         project: Project,
         private val memberInfos: List<KotlinMemberInfo>,
-        private val sourceClass: JetClass
+        private val sourceClass: KtClass
 ) : RefactoringDialog(project, true) {
     init {
         title = PUSH_MEMBERS_DOWN
         init()
     }
 
-    private var memberInfoModel: AbstractMemberInfoModel<JetNamedDeclaration, KotlinMemberInfo>? = null
+    private var memberInfoModel: AbstractMemberInfoModel<KtNamedDeclaration, KotlinMemberInfo>? = null
 
     public val selectedMemberInfos: List<KotlinMemberInfo>
         get() = memberInfos.filter { it.isChecked && memberInfoModel?.isMemberEnabled(it) ?: false }
@@ -79,12 +79,12 @@ public class KotlinPushDownDialog(
                 RefactoringBundle.message("keep.abstract.column.header"))
         panel.add(memberSelectionPanel, BorderLayout.CENTER)
 
-        memberInfoModel = object : AbstractMemberInfoModel<JetNamedDeclaration, KotlinMemberInfo>() {
+        memberInfoModel = object : AbstractMemberInfoModel<KtNamedDeclaration, KotlinMemberInfo>() {
             override fun isFixedAbstract(member: KotlinMemberInfo?) = null
 
             override fun isAbstractEnabled(memberInfo: KotlinMemberInfo): Boolean {
                 val member = memberInfo.member
-                return member is JetNamedFunction || member is JetProperty
+                return member is KtNamedFunction || member is KtProperty
             }
         }
         memberInfoModel!!.memberInfoChanged(MemberInfoChange(memberInfos))
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownHandler.kt
index 5cac22c17d6..85ea55f07b4 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownHandler.kt
@@ -30,10 +30,10 @@ import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberInfo
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberInfoStorage
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.qualifiedClassNameForRendering
 import org.jetbrains.kotlin.idea.refactoring.pullUp.PULL_MEMBERS_UP
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
-import org.jetbrains.kotlin.psi.JetObjectDeclaration
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.isInheritable
 
@@ -52,7 +52,7 @@ public class KotlinPushDownHandler : AbstractPullPushMembersHandler(
         fun adjustMembers(members: List<KotlinMemberInfo>): List<KotlinMemberInfo>
     }
 
-    private fun reportFinalClassOrObject(project: Project, editor: Editor?, classOrObject: JetClassOrObject) {
+    private fun reportFinalClassOrObject(project: Project, editor: Editor?, classOrObject: KtClassOrObject) {
         val message = RefactoringBundle.getCannotRefactorMessage(
                 "${RefactoringUIUtil.getDescription(classOrObject, false)} is final".capitalize()
         )
@@ -61,15 +61,15 @@ public class KotlinPushDownHandler : AbstractPullPushMembersHandler(
 
     override fun invoke(project: Project,
                         editor: Editor?,
-                        classOrObject: JetClassOrObject?,
-                        member: JetNamedDeclaration?,
+                        classOrObject: KtClassOrObject?,
+                        member: KtNamedDeclaration?,
                         dataContext: DataContext?) {
         if (classOrObject == null) {
             reportWrongContext(project, editor)
             return
         }
 
-        if (!(classOrObject is JetClass && classOrObject.isInheritable())) {
+        if (!(classOrObject is KtClass && classOrObject.isInheritable())) {
             reportFinalClassOrObject(project, editor, classOrObject)
             return
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownProcessor.kt
index 30b1daad4ed..b8a22f93896 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownProcessor.kt
@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.idea.refactoring.pullUp.*
 import org.jetbrains.kotlin.idea.search.declarationsSearch.HierarchySearchRequest
 import org.jetbrains.kotlin.idea.search.declarationsSearch.searchInheritors
 import org.jetbrains.kotlin.idea.util.application.runReadAction
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.source.getPsi
@@ -50,7 +50,7 @@ import org.jetbrains.kotlin.utils.keysToMap
 import java.util.ArrayList
 
 public class KotlinPushDownContext(
-        val sourceClass: JetClass,
+        val sourceClass: KtClass,
         val membersToMove: List<KotlinMemberInfo>
 ) {
     val resolutionFacade = sourceClass.getResolutionFacade()
@@ -66,7 +66,7 @@ public class KotlinPushDownContext(
 
 public class KotlinPushDownProcessor(
         project: Project,
-        sourceClass: JetClass,
+        sourceClass: KtClass,
         membersToMove: List<KotlinMemberInfo>
 ) : BaseRefactoringProcessor(project) {
     private val context = KotlinPushDownContext(sourceClass, membersToMove)
@@ -94,7 +94,7 @@ public class KotlinPushDownProcessor(
     }
 
     override fun getAfterData(usages: Array<out UsageInfo>) = RefactoringEventData().apply {
-        addElements(usages.map { it.element as? JetClassOrObject }.filterNotNull())
+        addElements(usages.map { it.element as? KtClassOrObject }.filterNotNull())
     }
 
     override fun findUsages(): Array<out UsageInfo> {
@@ -122,7 +122,7 @@ public class KotlinPushDownProcessor(
         return showConflicts(conflicts, usages)
     }
 
-    private fun pushDownToClass(targetClass: JetClassOrObject) {
+    private fun pushDownToClass(targetClass: KtClassOrObject) {
         val targetClassDescriptor = context.resolutionFacade.resolveToDescriptor(targetClass) as ClassDescriptor
         val substitutor = getTypeSubstitutor(context.sourceClassDescriptor.defaultType, targetClassDescriptor.defaultType)
                           ?: TypeSubstitutor.EMPTY
@@ -131,39 +131,39 @@ public class KotlinPushDownProcessor(
             val memberDescriptor = context.memberDescriptors[member] ?: continue
 
             val movedMember = when (member) {
-                is JetProperty, is JetNamedFunction -> {
+                is KtProperty, is KtNamedFunction -> {
                     memberDescriptor as CallableMemberDescriptor
 
                     val targetMemberDescriptor = memberDescriptor.substitute(substitutor)?.let {
                         targetClassDescriptor.findCallableMemberBySignature(it as CallableMemberDescriptor)
                     }
-                    val targetMember = targetMemberDescriptor?.source?.getPsi() as? JetCallableDeclaration
+                    val targetMember = targetMemberDescriptor?.source?.getPsi() as? KtCallableDeclaration
                     targetMember?.apply {
                         if (memberDescriptor.modality != Modality.ABSTRACT && memberInfo.isToAbstract) {
-                            addModifierWithSpace(JetTokens.OVERRIDE_KEYWORD)
+                            addModifierWithSpace(KtTokens.OVERRIDE_KEYWORD)
                         }
                         else if (memberDescriptor.overriddenDescriptors.isEmpty()) {
-                            removeModifier(JetTokens.OVERRIDE_KEYWORD)
+                            removeModifier(KtTokens.OVERRIDE_KEYWORD)
                         }
                         else {
-                            addModifierWithSpace(JetTokens.OVERRIDE_KEYWORD)
+                            addModifierWithSpace(KtTokens.OVERRIDE_KEYWORD)
                         }
                     } ?: addMemberToTarget(member, targetClass).apply {
                         if (context.sourceClassDescriptor.kind == ClassKind.INTERFACE) {
                             if (targetClassDescriptor.kind != ClassKind.INTERFACE && memberDescriptor.modality == Modality.ABSTRACT) {
-                                addModifierWithSpace(JetTokens.ABSTRACT_KEYWORD)
+                                addModifierWithSpace(KtTokens.ABSTRACT_KEYWORD)
                             }
                         }
                         if (memberDescriptor.modality != Modality.ABSTRACT && memberInfo.isToAbstract) {
-                            if (hasModifier(JetTokens.PRIVATE_KEYWORD)) {
-                                addModifierWithSpace(JetTokens.PROTECTED_KEYWORD)
+                            if (hasModifier(KtTokens.PRIVATE_KEYWORD)) {
+                                addModifierWithSpace(KtTokens.PROTECTED_KEYWORD)
                             }
-                            addModifierWithSpace(JetTokens.OVERRIDE_KEYWORD)
+                            addModifierWithSpace(KtTokens.OVERRIDE_KEYWORD)
                         }
                     }
                 }
 
-                is JetClassOrObject -> {
+                is KtClassOrObject -> {
                     if (memberInfo.overrides != null) {
                         context.sourceClass.getDelegatorToSuperClassByDescriptor(
                                 memberDescriptor as ClassDescriptor,
@@ -189,13 +189,13 @@ public class KotlinPushDownProcessor(
             val member = memberInfo.member
             val memberDescriptor = context.memberDescriptors[member] ?: continue
             when (member) {
-                is JetProperty, is JetNamedFunction -> {
-                    member as JetCallableDeclaration
+                is KtProperty, is KtNamedFunction -> {
+                    member as KtCallableDeclaration
                     memberDescriptor as CallableMemberDescriptor
 
                     if (memberDescriptor.modality != Modality.ABSTRACT && memberInfo.isToAbstract) {
-                        if (member.hasModifier(JetTokens.PRIVATE_KEYWORD)) {
-                            member.addModifierWithSpace(JetTokens.PROTECTED_KEYWORD)
+                        if (member.hasModifier(KtTokens.PRIVATE_KEYWORD)) {
+                            member.addModifierWithSpace(KtTokens.PROTECTED_KEYWORD)
                         }
                         makeAbstract(member, memberDescriptor, TypeSubstitutor.EMPTY, context.sourceClass)
                         member.typeReference?.addToShorteningWaitSet()
@@ -204,7 +204,7 @@ public class KotlinPushDownProcessor(
                         member.delete()
                     }
                 }
-                is JetClassOrObject -> {
+                is KtClassOrObject -> {
                     if (memberInfo.overrides != null) {
                         context.sourceClass.getDelegatorToSuperClassByDescriptor(
                                 memberDescriptor as ClassDescriptor,
@@ -222,12 +222,12 @@ public class KotlinPushDownProcessor(
     }
 
     override fun performRefactoring(usages: Array<out UsageInfo>) {
-        val markedElements = ArrayList<JetElement>()
+        val markedElements = ArrayList<KtElement>()
         try {
             context.membersToMove.forEach {
                 markedElements += markElements(it.member, context.sourceClassContext, context.sourceClassDescriptor, null)
             }
-            usages.forEach { (it.element as? JetClassOrObject)?.let { pushDownToClass(it) } }
+            usages.forEach { (it.element as? KtClassOrObject)?.let { pushDownToClass(it) } }
             removeOriginalMembers()
         }
         finally {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/pushDownConflictsUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/pushDownConflictsUtils.kt
index 5c27620b37f..e30d4c9c54d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/pushDownConflictsUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/pushDownConflictsUtils.kt
@@ -25,9 +25,9 @@ import com.intellij.util.containers.MultiMap
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.refactoring.pullUp.renderForConflicts
-import org.jetbrains.kotlin.idea.references.JetReference
+import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.idea.references.mainReference
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForReceiver
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -47,14 +47,14 @@ fun analyzePushDownConflicts(context: KotlinPushDownContext,
 
     val conflicts = MultiMap<PsiElement, String>()
 
-    val membersToPush = ArrayList<JetNamedDeclaration>()
-    val membersToKeepAbstract = ArrayList<JetNamedDeclaration>()
+    val membersToPush = ArrayList<KtNamedDeclaration>()
+    val membersToKeepAbstract = ArrayList<KtNamedDeclaration>()
     for (info in context.membersToMove) {
         val member = info.member
-        if (!info.isChecked || (member is JetClassOrObject && info.overrides != null)) continue
+        if (!info.isChecked || (member is KtClassOrObject && info.overrides != null)) continue
 
         membersToPush += member
-        if ((member is JetNamedFunction || member is JetProperty)
+        if ((member is KtNamedFunction || member is KtProperty)
             && info.isToAbstract
             && (context.memberDescriptors[member] as CallableMemberDescriptor).modality != Modality.ABSTRACT) {
             membersToKeepAbstract += member
@@ -72,10 +72,10 @@ private fun checkConflicts(
         conflicts: MultiMap<PsiElement, String>,
         context: KotlinPushDownContext,
         targetClass: PsiElement,
-        membersToKeepAbstract: List<JetNamedDeclaration>,
-        membersToPush: ArrayList<JetNamedDeclaration>
+        membersToKeepAbstract: List<KtNamedDeclaration>,
+        membersToPush: ArrayList<KtNamedDeclaration>
 ) {
-    if (targetClass !is JetClassOrObject) {
+    if (targetClass !is KtClassOrObject) {
         conflicts.putValue(
                 targetClass,
                 "Non-Kotlin ${RefactoringUIUtil.getDescription(targetClass, false)} won't be affected by the refactoring"
@@ -87,7 +87,7 @@ private fun checkConflicts(
     val substitutor = getTypeSubstitutor(context.sourceClassDescriptor.defaultType, targetClassDescriptor.defaultType)
                       ?: TypeSubstitutor.EMPTY
 
-    if (!context.sourceClass.isInterface() && targetClass is JetClass && targetClass.isInterface()) {
+    if (!context.sourceClass.isInterface() && targetClass is KtClass && targetClass.isInterface()) {
         val message = "${targetClassDescriptor.renderForConflicts()} " +
                       "inherits from ${context.sourceClassDescriptor.renderForConflicts()}.\n" +
                       "It won't be affected by the refactoring"
@@ -105,22 +105,22 @@ private fun checkConflicts(
 private fun checkMemberClashing(
         conflicts: MultiMap<PsiElement, String>,
         context: KotlinPushDownContext,
-        member: JetNamedDeclaration,
-        membersToKeepAbstract: List<JetNamedDeclaration>,
+        member: KtNamedDeclaration,
+        membersToKeepAbstract: List<KtNamedDeclaration>,
         substitutor: TypeSubstitutor,
-        targetClass: JetClassOrObject,
+        targetClass: KtClassOrObject,
         targetClassDescriptor: ClassDescriptor) {
     when (member) {
-        is JetNamedFunction, is JetProperty -> {
+        is KtNamedFunction, is KtProperty -> {
             val memberDescriptor = context.memberDescriptors[member] as CallableMemberDescriptor
             val clashingDescriptor = targetClassDescriptor.findCallableMemberBySignature(memberDescriptor.substitute(substitutor) as CallableMemberDescriptor)
-            val clashingDeclaration = clashingDescriptor?.source?.getPsi() as? JetNamedDeclaration
+            val clashingDeclaration = clashingDescriptor?.source?.getPsi() as? KtNamedDeclaration
             if (clashingDescriptor != null && clashingDeclaration != null) {
                 if (memberDescriptor.modality != Modality.ABSTRACT && member !in membersToKeepAbstract) {
                     val message = "${targetClassDescriptor.renderForConflicts()} already contains ${clashingDescriptor.renderForConflicts()}"
                     conflicts.putValue(clashingDeclaration, CommonRefactoringUtil.capitalize(message))
                 }
-                if (!clashingDeclaration.hasModifier(JetTokens.OVERRIDE_KEYWORD)) {
+                if (!clashingDeclaration.hasModifier(KtTokens.OVERRIDE_KEYWORD)) {
                     val message = "${clashingDescriptor.renderForConflicts()} in ${targetClassDescriptor.renderForConflicts()} " +
                                   "will override corresponding member of ${context.sourceClassDescriptor.renderForConflicts()} " +
                                   "after refactoring"
@@ -129,9 +129,9 @@ private fun checkMemberClashing(
             }
         }
 
-        is JetClassOrObject -> {
+        is KtClassOrObject -> {
             targetClass.declarations
-                    .filterIsInstance<JetClassOrObject>()
+                    .filterIsInstance<KtClassOrObject>()
                     .firstOrNull() { it.name == member.name }
                     ?.let {
                         val message = "${targetClassDescriptor.renderForConflicts()} " +
@@ -145,14 +145,14 @@ private fun checkMemberClashing(
 private fun checkSuperCalls(
         conflicts: MultiMap<PsiElement, String>,
         context: KotlinPushDownContext,
-        member: JetNamedDeclaration,
-        membersToPush: ArrayList<JetNamedDeclaration>
+        member: KtNamedDeclaration,
+        membersToPush: ArrayList<KtNamedDeclaration>
 ) {
     member.accept(
-            object : JetTreeVisitorVoid() {
-                override fun visitSuperExpression(expression: JetSuperExpression) {
+            object : KtTreeVisitorVoid() {
+                override fun visitSuperExpression(expression: KtSuperExpression) {
                     val qualifiedExpression = expression.getQualifiedExpressionForReceiver() ?: return
-                    val refExpr = qualifiedExpression.selectorExpression.getCalleeExpressionIfAny() as? JetSimpleNameExpression ?: return
+                    val refExpr = qualifiedExpression.selectorExpression.getCalleeExpressionIfAny() as? KtSimpleNameExpression ?: return
                     for (descriptor in refExpr.mainReference.resolveToDescriptors(context.sourceClassContext)) {
                         val memberDescriptor = descriptor as? CallableMemberDescriptor ?: continue
                         val containingClass = memberDescriptor.containingDeclaration as? ClassDescriptor ?: continue
@@ -172,11 +172,11 @@ private fun checkSuperCalls(
 private fun checkExternalUsages(
         conflicts: MultiMap<PsiElement, String>,
         context: KotlinPushDownContext,
-        member: JetNamedDeclaration,
+        member: KtNamedDeclaration,
         targetClassDescriptor: ClassDescriptor
 ) {
     for (ref in ReferencesSearch.search(member, member.resolveScope, false)) {
-        val calleeExpr = ref.element as? JetSimpleNameExpression ?: continue
+        val calleeExpr = ref.element as? KtSimpleNameExpression ?: continue
         val resolvedCall = calleeExpr.getResolvedCall(context.resolutionFacade.analyze(calleeExpr)) ?: continue
         val callElement = resolvedCall.call.callElement
         val dispatchReceiver = resolvedCall.dispatchReceiver
@@ -191,7 +191,7 @@ private fun checkExternalUsages(
 private fun checkVisibility(
         conflicts: MultiMap<PsiElement, String>,
         context: KotlinPushDownContext,
-        member: JetNamedDeclaration,
+        member: KtNamedDeclaration,
         targetClassDescriptor: ClassDescriptor
 ) {
     fun reportConflictIfAny(targetDescriptor: DeclarationDescriptor) {
@@ -206,12 +206,12 @@ private fun checkVisibility(
     }
 
     member.accept(
-            object : JetTreeVisitorVoid() {
-                override fun visitReferenceExpression(expression: JetReferenceExpression) {
+            object : KtTreeVisitorVoid() {
+                override fun visitReferenceExpression(expression: KtReferenceExpression) {
                     super.visitReferenceExpression(expression)
 
                     expression.references
-                            .flatMap { (it as? JetReference)?.resolveToDescriptors(context.sourceClassContext) ?: emptyList() }
+                            .flatMap { (it as? KtReference)?.resolveToDescriptors(context.sourceClassContext) ?: emptyList() }
                             .forEach(::reportConflictIfAny)
 
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/AutomaticInheritorRenamer.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/AutomaticInheritorRenamer.kt
index 0feabaeaff9..e5684b4345b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/AutomaticInheritorRenamer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/AutomaticInheritorRenamer.kt
@@ -28,9 +28,9 @@ import com.intellij.refactoring.rename.naming.InheritorRenamer
 import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.asJava.unwrapped
-import org.jetbrains.kotlin.psi.JetClass
+import org.jetbrains.kotlin.psi.KtClass
 
-public class AutomaticInheritorRenamer(klass: JetClass, newName: String): AutomaticRenamer() {
+public class AutomaticInheritorRenamer(klass: KtClass, newName: String): AutomaticRenamer() {
     init {
         val lightClass = LightClassUtil.getPsiClass(klass)
         if (lightClass != null) {
@@ -50,12 +50,12 @@ public class AutomaticInheritorRenamer(klass: JetClass, newName: String): Automa
 }
 
 public class AutomaticInheritorRenamerFactory : AutomaticRenamerFactory {
-    override fun isApplicable(element: PsiElement) = element is JetClass
+    override fun isApplicable(element: PsiElement) = element is KtClass
     override fun getOptionName() = RefactoringBundle.message("rename.inheritors")
     override fun isEnabled() = JavaRefactoringSettings.getInstance().isToRenameInheritors()
     override fun setEnabled(enabled: Boolean) = JavaRefactoringSettings.getInstance().setRenameInheritors(enabled)
 
     override fun createRenamer(element: PsiElement, newName: String, usages: Collection<UsageInfo>): AutomaticRenamer {
-        return AutomaticInheritorRenamer(element as JetClass, newName)
+        return AutomaticInheritorRenamer(element as KtClass, newName)
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/AutomaticOverloadsRenamer.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/AutomaticOverloadsRenamer.kt
index fff4a9e83a3..35a0e23bd35 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/AutomaticOverloadsRenamer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/AutomaticOverloadsRenamer.kt
@@ -28,12 +28,12 @@ import com.intellij.refactoring.rename.naming.AutomaticRenamerFactory
 import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.idea.stubindex.JetTopLevelFunctionByPackageIndex
 import org.jetbrains.kotlin.idea.stubindex.JetTopLevelFunctionFqnNameIndex
-import org.jetbrains.kotlin.psi.JetClassBody
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtClassBody
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedFunction
 
-public class AutomaticOverloadsRenamer(function: JetNamedFunction, newName: String) : AutomaticRenamer() {
+public class AutomaticOverloadsRenamer(function: KtNamedFunction, newName: String) : AutomaticRenamer() {
     init {
         myElements.addAll(function.getOverloads().filter { it != function })
         suggestAllNames(function.getName(), newName)
@@ -45,10 +45,10 @@ public class AutomaticOverloadsRenamer(function: JetNamedFunction, newName: Stri
     override fun isSelectedByDefault(): Boolean = true
 }
 
-private fun JetNamedFunction.getOverloads(): Collection<JetNamedFunction> {
+private fun KtNamedFunction.getOverloads(): Collection<KtNamedFunction> {
     val parent = getParent()
     when (parent) {
-        is JetFile -> {
+        is KtFile -> {
             val module = ModuleUtilCore.findModuleForPsiElement(this)
             if (module != null) {
                 val searchScope = GlobalSearchScope.moduleScope(module)
@@ -58,8 +58,8 @@ private fun JetNamedFunction.getOverloads(): Collection<JetNamedFunction> {
                 }
             }
         }
-        is JetClassBody -> {
-            return parent.getDeclarations().filterIsInstance<JetNamedFunction>().filter { it.getName() == this.getName() }
+        is KtClassBody -> {
+            return parent.getDeclarations().filterIsInstance<KtNamedFunction>().filter { it.getName() == this.getName() }
         }
     }
     return emptyList()
@@ -67,13 +67,13 @@ private fun JetNamedFunction.getOverloads(): Collection<JetNamedFunction> {
 
 public class AutomaticOverloadsRenamerFactory : AutomaticRenamerFactory {
     override fun isApplicable(element: PsiElement): Boolean {
-        return element is JetNamedFunction && element.getName() != null
-               && (element.getParent() is JetFile || element.getParent() is JetClassBody)
+        return element is KtNamedFunction && element.getName() != null
+               && (element.getParent() is KtFile || element.getParent() is KtClassBody)
     }
 
     override fun getOptionName() = RefactoringBundle.message("rename.overloads")
     override fun isEnabled() = JavaRefactoringSettings.getInstance().isRenameOverloads()
     override fun setEnabled(enabled: Boolean) = JavaRefactoringSettings.getInstance().setRenameOverloads(enabled)
     override fun createRenamer(element: PsiElement, newName: String, usages: Collection<UsageInfo>)
-            = AutomaticOverloadsRenamer(element as JetNamedFunction, newName)
+            = AutomaticOverloadsRenamer(element as KtNamedFunction, newName)
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/AutomaticVariableRenamer.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/AutomaticVariableRenamer.kt
index 8b16338a1d0..6876b2c1c60 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/AutomaticVariableRenamer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/AutomaticVariableRenamer.kt
@@ -32,16 +32,16 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
-import org.jetbrains.kotlin.psi.JetParameter
-import org.jetbrains.kotlin.psi.JetVariableDeclaration
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
+import org.jetbrains.kotlin.psi.KtParameter
+import org.jetbrains.kotlin.psi.KtVariableDeclaration
+import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.lazy.NoDescriptorForDeclarationException
 import org.jetbrains.kotlin.resolve.source.PsiSourceElement
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import java.util.*
 
 public class AutomaticVariableRenamer(
@@ -49,7 +49,7 @@ public class AutomaticVariableRenamer(
         newClassName: String,
         usages: Collection<UsageInfo>
 ) : AutomaticRenamer() {
-    private val toUnpluralize = ArrayList<JetNamedDeclaration>()
+    private val toUnpluralize = ArrayList<KtNamedDeclaration>()
 
     init {
         for (usage in usages) {
@@ -57,8 +57,8 @@ public class AutomaticVariableRenamer(
 
             val parameterOrVariable = PsiTreeUtil.getParentOfType(
                     usageElement,
-                    javaClass<JetVariableDeclaration>(),
-                    javaClass<JetParameter>()
+                    javaClass<KtVariableDeclaration>(),
+                    javaClass<KtParameter>()
             ) ?: continue
 
             if (parameterOrVariable.getTypeReference()?.isAncestor(usageElement) != true) continue
@@ -108,7 +108,7 @@ public class AutomaticVariableRenamer(
     }
 }
 
-private fun JetType.isCollectionLikeOf(classPsiElement: PsiNamedElement): Boolean {
+private fun KtType.isCollectionLikeOf(classPsiElement: PsiNamedElement): Boolean {
     val klass = this.getConstructor().getDeclarationDescriptor() as? ClassDescriptor ?: return false
     if (KotlinBuiltIns.isArray(this) || DescriptorUtils.isSubclass(klass, klass.builtIns.getCollection())) {
         val typeArgument = this.getArguments().singleOrNull()?.getType() ?: return false
@@ -120,7 +120,7 @@ private fun JetType.isCollectionLikeOf(classPsiElement: PsiNamedElement): Boolea
 
 
 public class AutomaticVariableRenamerFactory: AutomaticRenamerFactory {
-    override fun isApplicable(element: PsiElement) = element is JetClass || element is PsiClass
+    override fun isApplicable(element: PsiElement) = element is KtClass || element is PsiClass
 
     override fun createRenamer(element: PsiElement, newName: String, usages: Collection<UsageInfo>) =
             AutomaticVariableRenamer(element as PsiNamedElement, newName, usages)
@@ -132,11 +132,11 @@ public class AutomaticVariableRenamerFactory: AutomaticRenamerFactory {
 }
 
 public class AutomaticVariableInJavaRenamerFactory: AutomaticRenamerFactory {
-    override fun isApplicable(element: PsiElement) = element is JetClass && element.toLightClass() != null
+    override fun isApplicable(element: PsiElement) = element is KtClass && element.toLightClass() != null
 
     override fun createRenamer(element: PsiElement, newName: String, usages: Collection<UsageInfo>) =
             // Using java variable renamer for java usages
-            com.intellij.refactoring.rename.naming.AutomaticVariableRenamer((element as JetClass).toLightClass()!!, newName, usages)
+            com.intellij.refactoring.rename.naming.AutomaticVariableRenamer((element as KtClass).toLightClass()!!, newName, usages)
 
     override fun isEnabled() = JavaRefactoringSettings.getInstance().isToRenameVariables()
     override fun setEnabled(enabled: Boolean) = JavaRefactoringSettings.getInstance().setRenameVariables(enabled)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameDynamicMemberHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameDynamicMemberHandler.kt
index d18f81c7701..f6cc6889233 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameDynamicMemberHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameDynamicMemberHandler.kt
@@ -21,7 +21,7 @@ import com.intellij.psi.PsiElement
 import com.intellij.openapi.editor.Editor
 import com.intellij.psi.PsiFile
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.actionSystem.DataContext
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.resolve.calls.tasks.isDynamic
 public class RenameDynamicMemberHandler: VariableInplaceRenameHandler() {
     override fun isAvailable(element: PsiElement?, editor: Editor, file: PsiFile): Boolean {
         val callee = PsiTreeUtil.findElementOfClassAtOffset(
-                file, editor.getCaretModel().getOffset(), javaClass<JetSimpleNameExpression>(), false
+                file, editor.getCaretModel().getOffset(), javaClass<KtSimpleNameExpression>(), false
         ) ?: return false
         val calleeDescriptor = callee.analyze()[BindingContext.REFERENCE_TARGET, callee] ?: return false
         return calleeDescriptor.isDynamic()
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinClassProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinClassProcessor.kt
index e249cb86ba6..88211b71d59 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinClassProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinClassProcessor.kt
@@ -28,16 +28,16 @@ import org.jetbrains.kotlin.asJava.KotlinLightClassForExplicitDeclaration
 import org.jetbrains.kotlin.asJava.KotlinLightClassForFacade
 import org.jetbrains.kotlin.idea.JetBundle
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetConstructor
-import org.jetbrains.kotlin.psi.JetObjectDeclaration
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtConstructor
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 
 public class RenameKotlinClassProcessor : RenameKotlinPsiProcessor() {
     override fun canProcessElement(element: PsiElement): Boolean {
-        return element is JetClassOrObject || element is KotlinLightClass || element is JetConstructor<*>
+        return element is KtClassOrObject || element is KotlinLightClass || element is KtConstructor<*>
     }
 
     override fun substituteElementToRename(element: PsiElement, editor: Editor?): PsiElement? {
@@ -59,21 +59,21 @@ public class RenameKotlinClassProcessor : RenameKotlinPsiProcessor() {
     }
 
     override fun findReferences(element: PsiElement): Collection<PsiReference> {
-        if (element is JetObjectDeclaration && element.isCompanion()) {
+        if (element is KtObjectDeclaration && element.isCompanion()) {
             return super.findReferences(element).filter { !it.isCompanionObjectClassReference() }
         }
         return super.findReferences(element)
     }
 
     private fun PsiReference.isCompanionObjectClassReference(): Boolean {
-        if (this !is JetSimpleNameReference) {
+        if (this !is KtSimpleNameReference) {
             return false
         }
         val bindingContext = element.analyze(BodyResolveMode.PARTIAL)
         return bindingContext[BindingContext.SHORT_REFERENCE_TO_COMPANION_OBJECT, element] != null
     }
 
-    private fun getJetClassOrObject(element: PsiElement?, showErrors: Boolean, editor: Editor?): JetClassOrObject? = when (element) {
+    private fun getJetClassOrObject(element: PsiElement?, showErrors: Boolean, editor: Editor?): KtClassOrObject? = when (element) {
         is KotlinLightClass ->
             if (element is KotlinLightClassForExplicitDeclaration) {
                 element.getOrigin()
@@ -95,10 +95,10 @@ public class RenameKotlinClassProcessor : RenameKotlinPsiProcessor() {
                 null
             }
 
-        is JetConstructor<*> ->
+        is KtConstructor<*> ->
             element.getContainingClassOrObject()
 
         else ->
-            element as? JetClassOrObject
+            element as? KtClassOrObject
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFileProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFileProcessor.kt
index 7c0005107b4..92c5a59d1a8 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFileProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFileProcessor.kt
@@ -22,20 +22,20 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.search.SearchScope
 import com.intellij.refactoring.rename.RenamePsiFileProcessor
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.search.allScope
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
 class RenameKotlinFileProcessor() : RenamePsiFileProcessor() {
-    override fun canProcessElement(element: PsiElement) = element is JetFile
+    override fun canProcessElement(element: PsiElement) = element is KtFile
 
     override fun prepareRenaming(element: PsiElement?,
                                  newName: String,
                                  allRenames: MutableMap<PsiElement, String>,
                                  scope: SearchScope) {
-        val jetFile = element as? JetFile ?: return
-        if (FileTypeManager.getInstance().getFileTypeByFileName(newName) != JetFileType.INSTANCE) {
+        val jetFile = element as? KtFile ?: return
+        if (FileTypeManager.getInstance().getFileTypeByFileName(newName) != KotlinFileType.INSTANCE) {
             return
         }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFunctionProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFunctionProcessor.kt
index f15bb137afe..fba58a86daa 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFunctionProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFunctionProcessor.kt
@@ -27,16 +27,16 @@ import org.jetbrains.kotlin.asJava.KotlinLightMethod
 import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.idea.util.application.runReadAction
-import org.jetbrains.kotlin.psi.JetFunction
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetSecondaryConstructor
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtSecondaryConstructor
 
 public class RenameKotlinFunctionProcessor : RenameKotlinPsiProcessor() {
     private val javaMethodProcessorInstance = RenameJavaMethodProcessor()
 
     override fun canProcessElement(element: PsiElement): Boolean {
-        return element is JetNamedFunction || (element is KotlinLightMethod && element.getOrigin() is JetNamedFunction)
+        return element is KtNamedFunction || (element is KotlinLightMethod && element.getOrigin() is KtNamedFunction)
     }
 
     override fun substituteElementToRename(element: PsiElement?, editor: Editor?): PsiElement?  {
@@ -49,7 +49,7 @@ public class RenameKotlinFunctionProcessor : RenameKotlinPsiProcessor() {
         val substitutedJavaElement = javaMethodProcessorInstance.substituteElementToRename(wrappedMethod, editor)
 
         return when (substitutedJavaElement) {
-            is KotlinLightMethod -> substitutedJavaElement.getOrigin() as? JetNamedFunction
+            is KotlinLightMethod -> substitutedJavaElement.getOrigin() as? KtNamedFunction
             else -> substitutedJavaElement
         }
     }
@@ -64,13 +64,13 @@ public class RenameKotlinFunctionProcessor : RenameKotlinPsiProcessor() {
     override fun renameElement(element: PsiElement?, newName: String?, usages: Array<out UsageInfo>?, listener: RefactoringElementListener?) {
         super.renameElement(element, newName, usages, listener)
 
-        (element?.unwrapped as? JetNamedDeclaration)?.let { dropOverrideKeywordIfNecessary(it) }
+        (element?.unwrapped as? KtNamedDeclaration)?.let { dropOverrideKeywordIfNecessary(it) }
     }
 
     private fun wrapPsiMethod(element: PsiElement?): PsiMethod? = when (element) {
         is KotlinLightMethod -> element
-        is JetNamedFunction, is JetSecondaryConstructor -> runReadAction {
-            LightClassUtil.getLightClassMethod(element as JetFunction)
+        is KtNamedFunction, is KtSecondaryConstructor -> runReadAction {
+            LightClassUtil.getLightClassMethod(element as KtFunction)
         }
         else -> throw IllegalStateException("Can't be for element $element there because of canProcessElement()")
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinImplicitLambdaParameter.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinImplicitLambdaParameter.kt
index 848f9b31224..d1e87876fc9 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinImplicitLambdaParameter.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinImplicitLambdaParameter.kt
@@ -26,12 +26,12 @@ import com.intellij.refactoring.rename.inplace.VariableInplaceRenameHandler
 import org.jetbrains.kotlin.idea.intentions.ReplaceItWithExplicitFunctionLiteralParamIntention
 import org.jetbrains.kotlin.idea.intentions.isAutoCreatedItUsage
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
-import org.jetbrains.kotlin.psi.JetNameReferenceExpression
+import org.jetbrains.kotlin.psi.KtNameReferenceExpression
 
 public class RenameKotlinImplicitLambdaParameter: VariableInplaceRenameHandler() {
     override fun isAvailable(element: PsiElement?, editor: Editor, file: PsiFile): Boolean {
         val nameExpression = PsiTreeUtil.findElementOfClassAtOffset(
-                file, editor.getCaretModel().getOffset(), javaClass<JetNameReferenceExpression>(), false)
+                file, editor.getCaretModel().getOffset(), javaClass<KtNameReferenceExpression>(), false)
 
         return nameExpression != null && isAutoCreatedItUsage(nameExpression)
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinParameterProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinParameterProcessor.kt
index 72f09b06e24..0592710120c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinParameterProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinParameterProcessor.kt
@@ -26,19 +26,19 @@ import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeSignatureC
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.modify
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.runChangeSignature
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetParameter
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.OverrideResolver
 
 public class RenameKotlinParameterProcessor : RenameKotlinPsiProcessor() {
     override fun canProcessElement(element: PsiElement): Boolean {
-        return element is JetParameter && element.getParent().getParent() is JetNamedFunction
+        return element is KtParameter && element.getParent().getParent() is KtNamedFunction
     }
 
     override fun renameElement(element: PsiElement, newName: String, usages: Array<out UsageInfo>, listener: RefactoringElementListener?) {
-        val function = (element as JetParameter).getParent().getParent() as JetNamedFunction
+        val function = (element as KtParameter).getParent().getParent() as KtNamedFunction
         val paramIndex = function.getValueParameters().indexOf(element)
         assert(paramIndex != -1, { "couldn't find parameter in parent ${element.getElementTextWithContext()}" })
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt
index f724e93922d..3c87550b6a1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt
@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.util.application.runReadAction
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
@@ -49,7 +49,7 @@ import org.jetbrains.kotlin.resolve.OverrideResolver
 public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
     override fun canProcessElement(element: PsiElement): Boolean {
         val namedUnwrappedElement = element.namedUnwrappedElement
-        return namedUnwrappedElement is JetProperty || (namedUnwrappedElement is JetParameter && namedUnwrappedElement.hasValOrVar())
+        return namedUnwrappedElement is KtProperty || (namedUnwrappedElement is KtParameter && namedUnwrappedElement.hasValOrVar())
     }
 
     /* Can't properly update getters and setters in Java */
@@ -58,7 +58,7 @@ public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
     override fun substituteElementToRename(element: PsiElement?, editor: Editor?): PsiElement? {
         val namedUnwrappedElement = element?.namedUnwrappedElement
 
-        val callableDeclaration = namedUnwrappedElement as? JetCallableDeclaration
+        val callableDeclaration = namedUnwrappedElement as? KtCallableDeclaration
         if (callableDeclaration == null) throw IllegalStateException("Can't be for element $element there because of canProcessElement()")
 
         val deepestSuperDeclaration = findDeepestOverriddenDeclaration(callableDeclaration)
@@ -72,7 +72,7 @@ public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
 
         val containsText: String? =
                 deepestSuperDeclaration.getFqName()?.parent()?.asString() ?:
-                (deepestSuperDeclaration.getParent() as? JetClassOrObject)?.getName()
+                (deepestSuperDeclaration.getParent() as? KtClassOrObject)?.getName()
 
         val result = Messages.showYesNoCancelDialog(
                 deepestSuperDeclaration.getProject(),
@@ -90,8 +90,8 @@ public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
     override fun prepareRenaming(element: PsiElement?, newName: String?, allRenames: MutableMap<PsiElement, String>, scope: SearchScope) {
         val namedUnwrappedElement = element?.namedUnwrappedElement
         val propertyMethods = when(namedUnwrappedElement) {
-            is JetProperty -> runReadAction { LightClassUtil.getLightClassPropertyMethods(namedUnwrappedElement) }
-            is JetParameter -> runReadAction { LightClassUtil.getLightClassPropertyMethods(namedUnwrappedElement) }
+            is KtProperty -> runReadAction { LightClassUtil.getLightClassPropertyMethods(namedUnwrappedElement) }
+            is KtParameter -> runReadAction { LightClassUtil.getLightClassPropertyMethods(namedUnwrappedElement) }
             else -> throw IllegalStateException("Can't be for element $element there because of canProcessElement()")
         }
 
@@ -107,12 +107,12 @@ public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
     }
 
     override fun renameElement(element: PsiElement?, newName: String?, usages: Array<out UsageInfo>, listener: RefactoringElementListener?) {
-        if (element !is JetProperty && element !is JetParameter) {
+        if (element !is KtProperty && element !is KtParameter) {
             super.renameElement(element, newName, usages, listener)
             return
         }
 
-        val name = (element as JetNamedDeclaration).getName()!!
+        val name = (element as KtNamedDeclaration).getName()!!
         val oldGetterName = JvmAbi.getterName(name)
         val oldSetterName = JvmAbi.setterName(name)
 
@@ -177,8 +177,8 @@ public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
         }
     }
 
-    private fun findDeepestOverriddenDeclaration(declaration: JetCallableDeclaration): JetCallableDeclaration? {
-        if (declaration.getModifierList()?.hasModifier(JetTokens.OVERRIDE_KEYWORD) == true) {
+    private fun findDeepestOverriddenDeclaration(declaration: KtCallableDeclaration): KtCallableDeclaration? {
+        if (declaration.getModifierList()?.hasModifier(KtTokens.OVERRIDE_KEYWORD) == true) {
             val bindingContext = declaration.analyze()
             var descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, declaration]
             if (descriptor is ValueParameterDescriptor) {
@@ -195,7 +195,7 @@ public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
                 val deepest = supers.first()
                 if (deepest != descriptor) {
                     val superPsiElement = DescriptorToSourceUtils.descriptorToDeclaration(deepest)
-                    return superPsiElement as? JetCallableDeclaration
+                    return superPsiElement as? KtCallableDeclaration
                 }
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPsiProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPsiProcessor.kt
index 18b086323aa..2cd17e34055 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPsiProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPsiProcessor.kt
@@ -19,10 +19,10 @@ package org.jetbrains.kotlin.idea.refactoring.rename
 import com.intellij.refactoring.rename.RenamePsiElementProcessor
 import com.intellij.psi.PsiElement
 import com.intellij.usageView.UsageInfo
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 
 abstract class RenameKotlinPsiProcessor : RenamePsiElementProcessor() {
-    override fun canProcessElement(element: PsiElement): Boolean = element is JetNamedDeclaration
+    override fun canProcessElement(element: PsiElement): Boolean = element is KtNamedDeclaration
 
     override fun findCollisions(
             element: PsiElement?,
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameOnSecondaryConstructorHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameOnSecondaryConstructorHandler.kt
index 6f98aecd522..48dd71a884d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameOnSecondaryConstructorHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameOnSecondaryConstructorHandler.kt
@@ -25,10 +25,10 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.refactoring.rename.RenameHandler
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
-import org.jetbrains.kotlin.psi.JetBlockExpression
-import org.jetbrains.kotlin.psi.JetParameterList
-import org.jetbrains.kotlin.psi.JetSecondaryConstructor
-import org.jetbrains.kotlin.psi.JetValueArgumentList
+import org.jetbrains.kotlin.psi.KtBlockExpression
+import org.jetbrains.kotlin.psi.KtParameterList
+import org.jetbrains.kotlin.psi.KtSecondaryConstructor
+import org.jetbrains.kotlin.psi.KtValueArgumentList
 
 
 public class RenameOnSecondaryConstructorHandler : RenameHandler {
@@ -39,8 +39,8 @@ public class RenameOnSecondaryConstructorHandler : RenameHandler {
         val file = CommonDataKeys.PSI_FILE.getData(dataContext) ?: return false
 
         val element = PsiTreeUtil.findElementOfClassAtOffsetWithStopSet(
-                file, editor.getCaretModel().getOffset(), javaClass<JetSecondaryConstructor>(), false,
-                javaClass<JetBlockExpression>(), javaClass<JetValueArgumentList>(), javaClass<JetParameterList>()
+                file, editor.getCaretModel().getOffset(), javaClass<KtSecondaryConstructor>(), false,
+                javaClass<KtBlockExpression>(), javaClass<KtValueArgumentList>(), javaClass<KtParameterList>()
         )
         return element != null;
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/renameUtil.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/renameUtil.kt
index d325eedcdfe..96f73bb98fc 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/renameUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/renameUtil.kt
@@ -25,8 +25,8 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle
 import org.jetbrains.kotlin.idea.references.AbstractJetReference
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 
 fun checkConflictsAndReplaceUsageInfos(result: MutableList<UsageInfo>) {
     val usagesToAdd = ArrayList<UsageInfo>()
@@ -55,8 +55,8 @@ class UnresolvableConventionViolationUsageInfo(
     override fun getDescription(): String = JetRefactoringBundle.message("naming.convention.will.be.violated.after.rename")
 }
 
-fun dropOverrideKeywordIfNecessary(element: JetNamedDeclaration) {
+fun dropOverrideKeywordIfNecessary(element: KtNamedDeclaration) {
     if ((element.resolveToDescriptor() as CallableDescriptor).overriddenDescriptors.isEmpty()) {
-        element.removeModifier(JetTokens.OVERRIDE_KEYWORD)
+        element.removeModifier(KtTokens.OVERRIDE_KEYWORD)
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinJavaSafeDeleteDelegate.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinJavaSafeDeleteDelegate.kt
index f41f06f93c4..23b651adfbb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinJavaSafeDeleteDelegate.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinJavaSafeDeleteDelegate.kt
@@ -25,7 +25,7 @@ import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.idea.references.JetReference
+import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
 import org.jetbrains.kotlin.psi.psiUtil.parameterIndex
@@ -36,15 +36,15 @@ public class KotlinJavaSafeDeleteDelegate : JavaSafeDeleteDelegate {
     override fun createUsageInfoForParameter(
             reference: PsiReference, usages: MutableList<UsageInfo>, parameter: PsiParameter, method: PsiMethod
     ) {
-        if (reference !is JetReference) return
+        if (reference !is KtReference) return
 
         val element = reference.getElement()
 
-        val callExpression = element.getNonStrictParentOfType<JetCallExpression>()
+        val callExpression = element.getNonStrictParentOfType<KtCallExpression>()
         if (callExpression == null) return
 
         val calleeExpression = callExpression.getCalleeExpression()
-        if (!(calleeExpression is JetReferenceExpression && calleeExpression.isAncestor(element))) return
+        if (!(calleeExpression is KtReferenceExpression && calleeExpression.isAncestor(element))) return
 
         val bindingContext = element.analyze()
 
@@ -52,13 +52,13 @@ public class KotlinJavaSafeDeleteDelegate : JavaSafeDeleteDelegate {
         if (descriptor == null) return
 
         val originalDeclaration = method.unwrapped
-        if (originalDeclaration !is PsiMethod && originalDeclaration !is JetDeclaration) return
+        if (originalDeclaration !is PsiMethod && originalDeclaration !is KtDeclaration) return
 
         if (originalDeclaration != DescriptorToSourceUtils.descriptorToDeclaration(descriptor)) return
 
         val args = callExpression.getValueArguments()
 
-        val namedArguments = args.filter { arg -> arg is JetValueArgument && arg.getArgumentName()?.getText() == parameter.getName() }
+        val namedArguments = args.filter { arg -> arg is KtValueArgument && arg.getArgumentName()?.getText() == parameter.getName() }
         if (!namedArguments.isEmpty()) {
             usages.add(SafeDeleteValueArgumentListUsageInfo(namedArguments.first(), parameter))
             return
@@ -72,7 +72,7 @@ public class KotlinJavaSafeDeleteDelegate : JavaSafeDeleteDelegate {
 
         val argCount = args.size()
         if (parameterIndex < argCount) {
-            usages.add(SafeDeleteValueArgumentListUsageInfo((args.get(parameterIndex) as JetValueArgument), parameter))
+            usages.add(SafeDeleteValueArgumentListUsageInfo((args.get(parameterIndex) as KtValueArgument), parameter))
         } else {
             val lambdaArgs = callExpression.getFunctionLiteralArguments()
             val lambdaIndex = parameterIndex - argCount
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinOverridingDialog.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinOverridingDialog.java
index 26cc70e7971..f5d7f21caa0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinOverridingDialog.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinOverridingDialog.java
@@ -39,10 +39,10 @@ import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil;
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
-import org.jetbrains.kotlin.psi.JetProperty;
-import org.jetbrains.kotlin.psi.JetPsiUtil;
+import org.jetbrains.kotlin.psi.KtElement;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
+import org.jetbrains.kotlin.psi.KtProperty;
+import org.jetbrains.kotlin.psi.KtPsiUtil;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
@@ -91,9 +91,9 @@ class KotlinOverridingDialog extends DialogWrapper {
     }
 
     private static String formatElement(PsiElement element) {
-        element = JetPsiUtil.ascendIfPropertyAccessor(element);
-        if (element instanceof JetNamedFunction || element instanceof JetProperty) {
-            BindingContext bindingContext = ResolutionUtils.analyze((JetElement) element, BodyResolveMode.FULL);
+        element = KtPsiUtil.ascendIfPropertyAccessor(element);
+        if (element instanceof KtNamedFunction || element instanceof KtProperty) {
+            BindingContext bindingContext = ResolutionUtils.analyze((KtElement) element, BodyResolveMode.FULL);
 
             DeclarationDescriptor declarationDescriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element);
             if (declarationDescriptor instanceof CallableMemberDescriptor) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteOverridingUsageInfo.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteOverridingUsageInfo.kt
index 05f9c8f91ff..5da820b9be3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteOverridingUsageInfo.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteOverridingUsageInfo.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.refactoring.safeDelete
 import com.intellij.psi.PsiElement
 import com.intellij.refactoring.safeDelete.usageInfo.SafeDeleteCustomUsageInfo
 import com.intellij.refactoring.safeDelete.usageInfo.SafeDeleteUsageInfo
-import org.jetbrains.kotlin.psi.JetPsiUtil
+import org.jetbrains.kotlin.psi.KtPsiUtil
 
 public class KotlinSafeDeleteOverridingUsageInfo(
         overridingElement: PsiElement, superElement: PsiElement
@@ -27,6 +27,6 @@ public class KotlinSafeDeleteOverridingUsageInfo(
     public val overridingElement: PsiElement get() = getElement()!!
 
     public override fun performRefactoring(): Unit {
-        JetPsiUtil.ascendIfPropertyAccessor(getElement())?.delete()
+        KtPsiUtil.ascendIfPropertyAccessor(getElement())?.delete()
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteProcessor.kt
index 58ca85aedc9..3737b5b147d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteProcessor.kt
@@ -39,9 +39,9 @@ import org.jetbrains.kotlin.idea.JetBundle
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.deleteElementAndCleanParent
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil
-import org.jetbrains.kotlin.idea.references.JetReference
+import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.idea.search.usagesSearch.processDelegationCallConstructorUsages
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -59,7 +59,7 @@ public class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
         fun getIgnoranceCondition(): Condition<PsiElement> {
             return object : Condition<PsiElement> {
                 override fun value(t: PsiElement?): Boolean {
-                    if (t is JetFile) return false
+                    if (t is KtFile) return false
                     return deleteList.any { element -> JavaSafeDeleteProcessor.isInside(t, element.unwrapped) }
                 }
             }
@@ -90,10 +90,10 @@ public class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
 
                     is SafeDeleteReferenceJavaDeleteUsageInfo ->
                         usageInfo.getElement()?.let { usageElement ->
-                            if (usageElement.getNonStrictParentOfType<JetValueArgumentName>() != null) null
+                            if (usageElement.getNonStrictParentOfType<KtValueArgumentName>() != null) null
                             else {
-                                usageElement.getNonStrictParentOfType<JetImportDirective>()?.let { importDirective ->
-                                    SafeDeleteImportDirectiveUsageInfo(importDirective, element.unwrapped as JetDeclaration)
+                                usageElement.getNonStrictParentOfType<KtImportDirective>()?.let { importDirective ->
+                                    SafeDeleteImportDirectiveUsageInfo(importDirective, element.unwrapped as KtDeclaration)
                                 } ?: if (forceReferencedElementUnwrapping) {
                                     SafeDeleteReferenceJavaDeleteUsageInfo(usageElement, element.unwrapped, usageInfo.isSafeDelete())
                                 } else usageInfo
@@ -113,44 +113,44 @@ public class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
                         .filterNotNull()
                         .fold(insideDeleted) { condition1, condition2 -> Conditions.or(condition1, condition2) }
 
-        fun findUsagesByJavaProcessor(jetDeclaration: JetDeclaration): NonCodeUsageSearchInfo {
+        fun findUsagesByJavaProcessor(ktDeclaration: KtDeclaration): NonCodeUsageSearchInfo {
             return NonCodeUsageSearchInfo(
                     findUsagesByJavaProcessor(
-                            jetDeclaration.toLightElements().asSequence(),
+                            ktDeclaration.toLightElements().asSequence(),
                             getIgnoranceCondition()
                     ),
-                    jetDeclaration
+                    ktDeclaration
             )
         }
 
-        fun findKotlinDeclarationUsages(declaration: JetDeclaration): NonCodeUsageSearchInfo {
+        fun findKotlinDeclarationUsages(declaration: KtDeclaration): NonCodeUsageSearchInfo {
             ReferencesSearch.search(declaration, declaration.getUseScope())
                     .asSequence()
                     .filterNot { reference -> getIgnoranceCondition().value(reference.getElement()) }
                     .mapTo(usages) { reference ->
-                        reference.getElement().getNonStrictParentOfType<JetImportDirective>()?.let { importDirective ->
-                            SafeDeleteImportDirectiveUsageInfo(importDirective, element.unwrapped as JetDeclaration)
+                        reference.getElement().getNonStrictParentOfType<KtImportDirective>()?.let { importDirective ->
+                            SafeDeleteImportDirectiveUsageInfo(importDirective, element.unwrapped as KtDeclaration)
                         } ?: SafeDeleteReferenceSimpleDeleteUsageInfo(element, declaration, false)
                     }
 
             return getSearchInfo(declaration)
         }
 
-        fun findTypeParameterUsages(parameter: JetTypeParameter) {
-            val owner = parameter.getNonStrictParentOfType<JetTypeParameterListOwner>()
+        fun findTypeParameterUsages(parameter: KtTypeParameter) {
+            val owner = parameter.getNonStrictParentOfType<KtTypeParameterListOwner>()
             if (owner == null) return
 
             val parameterList = owner.getTypeParameters()
             val parameterIndex = parameterList.indexOf(parameter)
 
             for (reference in ReferencesSearch.search(owner)) {
-                if (reference !is JetReference) continue
+                if (reference !is KtReference) continue
 
                 val referencedElement = reference.getElement()
 
-                val argList = referencedElement.getNonStrictParentOfType<JetUserType>()?.let { jetType ->
+                val argList = referencedElement.getNonStrictParentOfType<KtUserType>()?.let { jetType ->
                     jetType.getTypeArgumentList()
-                } ?: referencedElement.getNonStrictParentOfType<JetCallExpression>()?.let { callExpression ->
+                } ?: referencedElement.getNonStrictParentOfType<KtCallExpression>()?.let { callExpression ->
                     callExpression.getTypeArgumentList()
                 } ?: null
 
@@ -170,21 +170,21 @@ public class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
         }
 
         return when (element) {
-            is JetClassOrObject -> {
+            is KtClassOrObject -> {
                 element.toLightClass()?.let { klass ->
                     findDelegationCallUsages(klass)
                     findUsagesByJavaProcessor(klass, false)
                 }
             }
 
-            is JetSecondaryConstructor -> {
+            is KtSecondaryConstructor -> {
                 element.getRepresentativeLightMethod()?.let { method ->
                     findDelegationCallUsages(method)
                     findUsagesByJavaProcessor(method, false)
                 }
             }
 
-            is JetNamedFunction -> {
+            is KtNamedFunction -> {
                 if (!LightClassUtil.canGenerateLightClass(element)) {
                     findKotlinDeclarationUsages(element)
                 }
@@ -196,7 +196,7 @@ public class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
             is PsiMethod ->
                 findUsagesByJavaProcessor(element, false)
 
-            is JetProperty -> {
+            is KtProperty -> {
                 if (!LightClassUtil.canGenerateLightClass(element)) {
                     findKotlinDeclarationUsages(element)
                 }
@@ -205,12 +205,12 @@ public class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
                 }
             }
 
-            is JetTypeParameter -> {
+            is KtTypeParameter -> {
                 findTypeParameterUsages(element)
                 findUsagesByJavaProcessor(element)
             }
 
-            is JetParameter ->
+            is KtParameter ->
                 findUsagesByJavaProcessor(element)
 
             else -> null
@@ -218,14 +218,14 @@ public class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
     }
 
     override fun findConflicts(element: PsiElement, allElementsToDelete: Array<out PsiElement>): MutableCollection<String>? {
-        if (element is JetNamedFunction || element is JetProperty) {
-            val jetClass = element.getNonStrictParentOfType<JetClass>()
+        if (element is KtNamedFunction || element is KtProperty) {
+            val jetClass = element.getNonStrictParentOfType<KtClass>()
             if (jetClass == null || jetClass.getBody() != element.getParent()) return null
 
             val modifierList = jetClass.getModifierList()
-            if (modifierList != null && modifierList.hasModifier(JetTokens.ABSTRACT_KEYWORD)) return null
+            if (modifierList != null && modifierList.hasModifier(KtTokens.ABSTRACT_KEYWORD)) return null
 
-            val bindingContext = (element as JetElement).analyze()
+            val bindingContext = (element as KtElement).analyze()
 
             val declarationDescriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element)
             if (declarationDescriptor !is CallableMemberDescriptor) return null
@@ -284,21 +284,21 @@ public class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
         when (element) {
             is PsiMethod -> element.cleanUpOverrides()
 
-            is JetNamedFunction ->
+            is KtNamedFunction ->
                 if (!element.isLocal()) {
                     element.getRepresentativeLightMethod()?.cleanUpOverrides()
                 }
 
-            is JetProperty ->
+            is KtProperty ->
                 if (!element.isLocal()) {
                     element.toLightMethods().forEach { method -> method.cleanUpOverrides() }
                 }
 
-            is JetTypeParameter ->
+            is KtTypeParameter ->
                 element.deleteElementAndCleanParent()
 
-            is JetParameter ->
-                (element.getParent() as JetParameterList).removeParameter(element)
+            is KtParameter ->
+                (element.getParent() as KtParameterList).removeParameter(element)
         }
     }
 
@@ -306,7 +306,7 @@ public class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
             element: PsiElement, module: Module?, allElementsToDelete: Collection<PsiElement>
     ): Collection<PsiElement>? {
         when (element) {
-            is JetParameter ->
+            is KtParameter ->
                 return element.toPsiParameters().flatMap { psiParameter ->
                     JetRefactoringUtil.checkParametersInMethodHierarchy(psiParameter) ?: emptyList()
                 }.ifEmpty { listOf(element) }
@@ -318,9 +318,9 @@ public class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
         if (ApplicationManager.getApplication()!!.isUnitTestMode()) return Collections.singletonList(element)
 
         return when (element) {
-            is JetNamedFunction, is JetProperty ->
+            is KtNamedFunction, is KtProperty ->
                 JetRefactoringUtil.checkSuperMethods(
-                        element as JetDeclaration, allElementsToDelete, "super.methods.delete.with.usage.search"
+                        element as KtDeclaration, allElementsToDelete, "super.methods.delete.with.usage.search"
                 )
 
             else -> super.getElementsToSearch(element, module, allElementsToDelete)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteImportDirectiveUsageInfo.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteImportDirectiveUsageInfo.kt
index c545c24c34e..174c6ff7e5b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteImportDirectiveUsageInfo.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteImportDirectiveUsageInfo.kt
@@ -19,14 +19,14 @@ package org.jetbrains.kotlin.idea.refactoring.safeDelete
 import com.intellij.refactoring.safeDelete.usageInfo.SafeDeleteReferenceSimpleDeleteUsageInfo
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.core.targetDescriptors
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetImportDirective
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtImportDirective
 
 public class SafeDeleteImportDirectiveUsageInfo(
-        importDirective: JetImportDirective, declaration: JetDeclaration
+        importDirective: KtImportDirective, declaration: KtDeclaration
 ) : SafeDeleteReferenceSimpleDeleteUsageInfo(importDirective, declaration, importDirective.isSafeToDelete(declaration))
 
-private fun JetImportDirective.isSafeToDelete(declaration: JetDeclaration): Boolean {
+private fun KtImportDirective.isSafeToDelete(declaration: KtDeclaration): Boolean {
     val referencedDescriptor = targetDescriptors().singleOrNull() ?: return false
     return referencedDescriptor == declaration.resolveToDescriptor()
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteTypeArgumentListUsageInfo.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteTypeArgumentListUsageInfo.kt
index 45025d9375d..375e914eddd 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteTypeArgumentListUsageInfo.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteTypeArgumentListUsageInfo.kt
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.idea.core.deleteElementAndCleanParent
 
 public class SafeDeleteTypeArgumentListUsageInfo(
-        typeProjection: JetTypeProjection, parameter: JetTypeParameter
+        typeProjection: KtTypeProjection, parameter: KtTypeParameter
 ) : SafeDeleteReferenceSimpleDeleteUsageInfo(typeProjection, parameter, true) {
     public override fun deleteElement() {
         getElement()?.deleteElementAndCleanParent()
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteValueArgumentListUsageInfo.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteValueArgumentListUsageInfo.kt
index 37ab09c5c5e..0b249c52af1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteValueArgumentListUsageInfo.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteValueArgumentListUsageInfo.kt
@@ -18,16 +18,16 @@ package org.jetbrains.kotlin.idea.refactoring.safeDelete
 
 import com.intellij.psi.PsiElement
 import com.intellij.refactoring.safeDelete.usageInfo.SafeDeleteReferenceSimpleDeleteUsageInfo
-import org.jetbrains.kotlin.psi.JetValueArgument
-import org.jetbrains.kotlin.psi.JetValueArgumentList
+import org.jetbrains.kotlin.psi.KtValueArgument
+import org.jetbrains.kotlin.psi.KtValueArgumentList
 
 public class SafeDeleteValueArgumentListUsageInfo(
-        valueArgument: JetValueArgument, parameter: PsiElement
+        valueArgument: KtValueArgument, parameter: PsiElement
 ) : SafeDeleteReferenceSimpleDeleteUsageInfo(valueArgument, parameter, true) {
     public override fun deleteElement() {
-        val element = getElement() as? JetValueArgument ?: return
+        val element = getElement() as? KtValueArgument ?: return
         val parent = element.getParent()
-        if (parent is JetValueArgumentList) {
+        if (parent is KtValueArgumentList) {
             parent.removeArgument(element)
         }
         else {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/utils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/utils.kt
index bb178115ae8..6566109ac90 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/utils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/utils.kt
@@ -20,30 +20,30 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.search.searches.OverridingMethodsSearch
 import org.jetbrains.kotlin.asJava.unwrapped
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 
 public fun PsiElement.canDeleteElement(): Boolean {
-    if (this is JetObjectDeclaration && isObjectLiteral()) return false
+    if (this is KtObjectDeclaration && isObjectLiteral()) return false
 
-    if (this is JetParameter) {
-        val parameterList = getParent() as? JetParameterList ?: return false
-        val declaration = parameterList.getParent() as? JetDeclaration ?: return false
-        return declaration !is JetPropertyAccessor
+    if (this is KtParameter) {
+        val parameterList = getParent() as? KtParameterList ?: return false
+        val declaration = parameterList.getParent() as? KtDeclaration ?: return false
+        return declaration !is KtPropertyAccessor
     }
 
-    return this is JetClassOrObject
-        || this is JetSecondaryConstructor
-        || this is JetNamedFunction
+    return this is KtClassOrObject
+        || this is KtSecondaryConstructor
+        || this is KtNamedFunction
         || this is PsiMethod
-        || this is JetProperty
-        || this is JetTypeParameter
+        || this is KtProperty
+        || this is KtTypeParameter
 }
 
 fun PsiElement.removeOverrideModifier() {
     when (this) {
-        is JetNamedFunction, is JetProperty -> {
-            (this as JetModifierListOwner).getModifierList()?.getModifier(JetTokens.OVERRIDE_KEYWORD)?.delete()
+        is KtNamedFunction, is KtProperty -> {
+            (this as KtModifierListOwner).getModifierList()?.getModifier(KtTokens.OVERRIDE_KEYWORD)?.delete()
         }
         is PsiMethod -> {
             getModifierList().getAnnotations().firstOrNull {
diff --git a/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfiguration.java b/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfiguration.java
index 3a8aee5b58b..4060483820f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfiguration.java
+++ b/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfiguration.java
@@ -53,11 +53,10 @@ import org.jetbrains.kotlin.asJava.KotlinLightClassForExplicitDeclaration;
 import org.jetbrains.kotlin.asJava.KotlinLightMethod;
 import org.jetbrains.kotlin.idea.MainFunctionDetector;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
-import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetDeclaration;
-import org.jetbrains.kotlin.psi.JetDeclarationContainer;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtDeclarationContainer;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
 
@@ -243,15 +242,15 @@ public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurati
     @Override
     public RefactoringElementListener getRefactoringElementListener(PsiElement element) {
         FqName fqNameBeingRenamed = null;
-        if (element instanceof JetDeclarationContainer) {
-            fqNameBeingRenamed = KotlinRunConfigurationProducer.Companion.getStartClassFqName((JetDeclarationContainer) element);
+        if (element instanceof KtDeclarationContainer) {
+            fqNameBeingRenamed = KotlinRunConfigurationProducer.Companion.getStartClassFqName((KtDeclarationContainer) element);
         }
         else if (element instanceof PsiPackage) {
             fqNameBeingRenamed = new FqName(((PsiPackage) element).getQualifiedName());
         }
         FqName ourClassName = new FqName(MAIN_CLASS_NAME);
         if (fqNameBeingRenamed != null && fqNameBeingRenamed.isAncestorOf(ourClassName)) {
-            if (element instanceof JetDeclarationContainer) {
+            if (element instanceof KtDeclarationContainer) {
                 return new RefactoringElementAdapter() {
                     @Override
                     public void undoElementMovedOrRenamed(@NotNull PsiElement newElement, @NotNull String oldQualifiedName) {
@@ -283,7 +282,7 @@ public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurati
     }
 
     private void updateMainClassName(PsiElement element) {
-        JetDeclarationContainer container = KotlinRunConfigurationProducer.Companion.getEntryPointContainer(element);
+        KtDeclarationContainer container = KotlinRunConfigurationProducer.Companion.getEntryPointContainer(element);
         FqName name = KotlinRunConfigurationProducer.Companion.getStartClassFqName(container);
         if (name != null) {
             MAIN_CLASS_NAME = name.asString();
@@ -305,17 +304,17 @@ public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurati
     }
 
     @NotNull
-    private static Collection<JetNamedFunction> getMainFunCandidates(@NotNull PsiClass psiClass) {
+    private static Collection<KtNamedFunction> getMainFunCandidates(@NotNull PsiClass psiClass) {
         return CollectionsKt.filterNotNull(
                 ArraysKt.map(
                         psiClass.getAllMethods(),
-                        new Function1<PsiMethod, JetNamedFunction>() {
+                        new Function1<PsiMethod, KtNamedFunction>() {
                             @Override
-                            public JetNamedFunction invoke(PsiMethod method) {
+                            public KtNamedFunction invoke(PsiMethod method) {
                                 if (!(method instanceof KotlinLightMethod)) return null;
 
-                                JetDeclaration declaration = ((KotlinLightMethod) method).getOrigin();
-                                return declaration instanceof JetNamedFunction ? (JetNamedFunction) declaration : null;
+                                KtDeclaration declaration = ((KotlinLightMethod) method).getOrigin();
+                                return declaration instanceof KtNamedFunction ? (KtNamedFunction) declaration : null;
                             }
                         }
                 )
@@ -323,8 +322,8 @@ public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurati
     }
 
     @Nullable
-    private static JetNamedFunction findMainFun(@NotNull PsiClass psiClass) {
-        for (JetNamedFunction function : getMainFunCandidates(psiClass)) {
+    private static KtNamedFunction findMainFun(@NotNull PsiClass psiClass) {
+        for (KtNamedFunction function : getMainFunCandidates(psiClass)) {
             BindingContext bindingContext = ResolutionUtils.analyze(function, BodyResolveMode.FULL);
             MainFunctionDetector mainFunctionDetector = new MainFunctionDetector(bindingContext);
             if (mainFunctionDetector.isMain(function)) return function;
@@ -363,7 +362,7 @@ public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurati
             PsiClass psiClass = JavaExecutionUtil.findMainClass(module, runClass);
             if (psiClass == null) throw CantRunException.classNotFound(runClass, module);
 
-            JetNamedFunction mainFun = findMainFun(psiClass);
+            KtNamedFunction mainFun = findMainFun(psiClass);
             if (mainFun == null) throw new CantRunException(noFunctionFoundMessage(psiClass));
 
             Module classModule = ModuleUtilCore.findModuleForPsiElement(mainFun);
diff --git a/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfigurationType.java b/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfigurationType.java
index f04ab6abcfd..f6c162fa047 100644
--- a/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfigurationType.java
+++ b/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfigurationType.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.run;
 import com.intellij.execution.configurations.*;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.idea.JetIcons;
+import org.jetbrains.kotlin.idea.KtIcons;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
 
 public class JetRunConfigurationType extends ConfigurationTypeBase {
@@ -28,7 +28,7 @@ public class JetRunConfigurationType extends ConfigurationTypeBase {
     }
 
     public JetRunConfigurationType() {
-        super("JetRunConfigurationType", KotlinLanguage.NAME, KotlinLanguage.NAME, JetIcons.LAUNCH);
+        super("JetRunConfigurationType", KotlinLanguage.NAME, KotlinLanguage.NAME, KtIcons.LAUNCH);
         addFactory(new JetRunConfigurationFactory(this));
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/run/JetTestNgConfigurationProducer.java b/idea/src/org/jetbrains/kotlin/idea/run/JetTestNgConfigurationProducer.java
index db3a7ece990..7ae887ad842 100644
--- a/idea/src/org/jetbrains/kotlin/idea/run/JetTestNgConfigurationProducer.java
+++ b/idea/src/org/jetbrains/kotlin/idea/run/JetTestNgConfigurationProducer.java
@@ -64,26 +64,26 @@ public class JetTestNgConfigurationProducer extends TestNGConfigurationProducer
             return false;
         }
 
-        if (!(leaf.getContainingFile() instanceof JetFile)) {
+        if (!(leaf.getContainingFile() instanceof KtFile)) {
             return false;
         }
 
-        JetFile jetFile = (JetFile) leaf.getContainingFile();
+        KtFile jetFile = (KtFile) leaf.getContainingFile();
 
         if (ProjectStructureUtil.isJsKotlinModule(jetFile)) {
             return false;
         }
 
-        JetNamedDeclaration declarationToRun = getDeclarationToRun(leaf);
+        KtNamedDeclaration declarationToRun = getDeclarationToRun(leaf);
 
-        if (declarationToRun instanceof JetNamedFunction) {
-            JetNamedFunction function = (JetNamedFunction) declarationToRun;
+        if (declarationToRun instanceof KtNamedFunction) {
+            KtNamedFunction function = (KtNamedFunction) declarationToRun;
 
             @SuppressWarnings("unchecked")
-            JetElement owner = PsiTreeUtil.getParentOfType(function, JetFunction.class, JetClass.class);
+            KtElement owner = PsiTreeUtil.getParentOfType(function, KtFunction.class, KtClass.class);
 
-            if (owner instanceof JetClass) {
-                PsiClass delegate = LightClassUtil.INSTANCE$.getPsiClass((JetClass) owner);
+            if (owner instanceof KtClass) {
+                PsiClass delegate = LightClassUtil.INSTANCE$.getPsiClass((KtClass) owner);
                 if (delegate != null) {
                     for (PsiMethod method : delegate.getMethods()) {
                         if (method.getNavigationElement() == function) {
@@ -97,8 +97,8 @@ public class JetTestNgConfigurationProducer extends TestNGConfigurationProducer
             }
         }
 
-        if (declarationToRun instanceof JetClass) {
-            PsiClass delegate = LightClassUtil.INSTANCE$.getPsiClass((JetClassOrObject) declarationToRun);
+        if (declarationToRun instanceof KtClass) {
+            PsiClass delegate = LightClassUtil.INSTANCE$.getPsiClass((KtClassOrObject) declarationToRun);
             if (!isTestNGClass(delegate)) {
                 return false;
             }
@@ -111,7 +111,7 @@ public class JetTestNgConfigurationProducer extends TestNGConfigurationProducer
 
     @Override
     public void onFirstRun(ConfigurationFromContext configuration, ConfigurationContext context, Runnable startRunnable) {
-        JetNamedDeclaration declarationToRun = getDeclarationToRun(configuration.getSourceElement());
+        KtNamedDeclaration declarationToRun = getDeclarationToRun(configuration.getSourceElement());
         final PsiNamedElement lightElement = CollectionsKt.firstOrNull(LightClassUtilsKt.toLightElements(declarationToRun));
 
         // Copied from TestNGInClassConfigurationProducer.onFirstRun()
@@ -166,15 +166,15 @@ public class JetTestNgConfigurationProducer extends TestNGConfigurationProducer
     }
 
     @Nullable
-    private static JetNamedDeclaration getDeclarationToRun(@NotNull PsiElement leaf) {
-        if (!(leaf.getContainingFile() instanceof JetFile)) return null;
-        JetFile jetFile = (JetFile) leaf.getContainingFile();
+    private static KtNamedDeclaration getDeclarationToRun(@NotNull PsiElement leaf) {
+        if (!(leaf.getContainingFile() instanceof KtFile)) return null;
+        KtFile jetFile = (KtFile) leaf.getContainingFile();
 
-        JetNamedFunction function = PsiTreeUtil.getParentOfType(leaf, JetNamedFunction.class, false);
+        KtNamedFunction function = PsiTreeUtil.getParentOfType(leaf, KtNamedFunction.class, false);
         if (function != null) return function;
 
-        JetClass jetClass = PsiTreeUtil.getParentOfType(leaf, JetClass.class, false);
-        if (jetClass != null) return jetClass;
+        KtClass ktClass = PsiTreeUtil.getParentOfType(leaf, KtClass.class, false);
+        if (ktClass != null) return ktClass;
 
         return getClassDeclarationInFile(jetFile);
     }
@@ -204,12 +204,12 @@ public class JetTestNgConfigurationProducer extends TestNGConfigurationProducer
     }
 
     @Nullable
-    static JetClass getClassDeclarationInFile(JetFile jetFile) {
-        JetClass tempSingleDeclaration = null;
+    static KtClass getClassDeclarationInFile(KtFile jetFile) {
+        KtClass tempSingleDeclaration = null;
 
-        for (JetDeclaration jetDeclaration : jetFile.getDeclarations()) {
-            if (jetDeclaration instanceof JetClass) {
-                JetClass declaration = (JetClass) jetDeclaration;
+        for (KtDeclaration ktDeclaration : jetFile.getDeclarations()) {
+            if (ktDeclaration instanceof KtClass) {
+                KtClass declaration = (KtClass) ktDeclaration;
 
                 if (tempSingleDeclaration == null) {
                     tempSingleDeclaration = declaration;
diff --git a/idea/src/org/jetbrains/kotlin/idea/run/KotlinJUnitRunConfigurationProducer.kt b/idea/src/org/jetbrains/kotlin/idea/run/KotlinJUnitRunConfigurationProducer.kt
index c7f97bb9192..f64087ac77a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/run/KotlinJUnitRunConfigurationProducer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/run/KotlinJUnitRunConfigurationProducer.kt
@@ -31,10 +31,10 @@ import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.idea.project.ProjectStructureUtil
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetFunction
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 
 public class KotlinJUnitRunConfigurationProducer : RunConfigurationProducer<JUnitConfiguration>(JUnitConfigurationType.getInstance()) {
@@ -81,11 +81,11 @@ public class KotlinJUnitRunConfigurationProducer : RunConfigurationProducer<JUni
             return false
         }
 
-        if (leaf.getContainingFile() !is JetFile) {
+        if (leaf.getContainingFile() !is KtFile) {
             return false
         }
 
-        val jetFile = leaf.getContainingFile() as JetFile
+        val jetFile = leaf.getContainingFile() as KtFile
 
         if (ProjectStructureUtil.isJsKotlinModule(jetFile)) {
             return false
@@ -133,10 +133,10 @@ public class KotlinJUnitRunConfigurationProducer : RunConfigurationProducer<JUni
     }
 
     private fun getTestMethodLocation(leaf: PsiElement): Location<PsiMethod>? {
-        val function = leaf.getParentOfType<JetNamedFunction>(false) ?: return null
-        val owner = PsiTreeUtil.getParentOfType(function, javaClass<JetFunction>(), javaClass<JetClass>())
+        val function = leaf.getParentOfType<KtNamedFunction>(false) ?: return null
+        val owner = PsiTreeUtil.getParentOfType(function, javaClass<KtFunction>(), javaClass<KtClass>())
 
-        if (owner is JetClass) {
+        if (owner is KtClass) {
             val delegate = LightClassUtil.getPsiClass(owner) ?: return null
             val method = delegate.getMethods().firstOrNull() { it.getNavigationElement() == function } ?: return null
             val methodLocation = PsiLocation.fromPsiElement(method)
@@ -148,8 +148,8 @@ public class KotlinJUnitRunConfigurationProducer : RunConfigurationProducer<JUni
     }
 
     private fun getTestClass(leaf: PsiElement): PsiClass? {
-        val containingFile = leaf.getContainingFile() as? JetFile ?: return null
-        var jetClass = leaf.getParentOfType<JetClass>(false)
+        val containingFile = leaf.getContainingFile() as? KtFile ?: return null
+        var jetClass = leaf.getParentOfType<KtClass>(false)
         if (!jetClass.isJUnitTestClass()) {
             jetClass = getTestClassInFile(containingFile)
         }
@@ -159,9 +159,9 @@ public class KotlinJUnitRunConfigurationProducer : RunConfigurationProducer<JUni
         return null
     }
 
-    private fun JetClass?.isJUnitTestClass() =
+    private fun KtClass?.isJUnitTestClass() =
             LightClassUtil.getPsiClass(this)?.let { JUnitUtil.isTestClass(it, false, true) } ?: false
 
-    private fun getTestClassInFile(jetFile: JetFile) =
-            jetFile.getDeclarations().filterIsInstance<JetClass>().singleOrNull { it.isJUnitTestClass() }
+    private fun getTestClassInFile(jetFile: KtFile) =
+            jetFile.getDeclarations().filterIsInstance<KtClass>().singleOrNull { it.isJUnitTestClass() }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/run/KotlinRunConfigurationProducer.kt b/idea/src/org/jetbrains/kotlin/idea/run/KotlinRunConfigurationProducer.kt
index a1c568c7b24..7f8a2bd45ee 100644
--- a/idea/src/org/jetbrains/kotlin/idea/run/KotlinRunConfigurationProducer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/run/KotlinRunConfigurationProducer.kt
@@ -48,7 +48,7 @@ public class KotlinRunConfigurationProducer : RunConfigurationProducer<JetRunCon
         return true
     }
 
-    private fun getEntryPointContainer(location: Location<*>?): JetDeclarationContainer? {
+    private fun getEntryPointContainer(location: Location<*>?): KtDeclarationContainer? {
         if (location == null) return null
         if (DumbService.getInstance(location.getProject()).isDumb()) return null
 
@@ -77,9 +77,9 @@ public class KotlinRunConfigurationProducer : RunConfigurationProducer<JetRunCon
     }
 
     companion object {
-        public fun getEntryPointContainer(locationElement: PsiElement): JetDeclarationContainer? {
+        public fun getEntryPointContainer(locationElement: PsiElement): KtDeclarationContainer? {
             val psiFile = locationElement.getContainingFile()
-            if (!(psiFile is JetFile && ProjectRootsUtil.isInProjectOrLibSource(psiFile))) return null
+            if (!(psiFile is KtFile && ProjectRootsUtil.isInProjectOrLibSource(psiFile))) return null
 
             val resolutionFacade = psiFile.getResolutionFacade()
             val mainFunctionDetector = MainFunctionDetector { resolutionFacade.resolveToDescriptor(it) as FunctionDescriptor }
@@ -87,7 +87,7 @@ public class KotlinRunConfigurationProducer : RunConfigurationProducer<JetRunCon
             var currentElement = locationElement.declarationContainer(false)
             while (currentElement != null) {
                 var entryPointContainer = currentElement
-                if (entryPointContainer is JetClass) {
+                if (entryPointContainer is KtClass) {
                     entryPointContainer = entryPointContainer.getCompanionObjects().singleOrNull()
                 }
                 if (entryPointContainer != null && mainFunctionDetector.hasMain(entryPointContainer.getDeclarations())) return entryPointContainer
@@ -97,12 +97,12 @@ public class KotlinRunConfigurationProducer : RunConfigurationProducer<JetRunCon
             return null
         }
 
-        public fun getStartClassFqName(container: JetDeclarationContainer?): FqName? = when(container) {
+        public fun getStartClassFqName(container: KtDeclarationContainer?): FqName? = when(container) {
             null -> null
-            is JetFile -> container.javaFileFacadeFqName
-            is JetClassOrObject -> {
-                if (container is JetObjectDeclaration && container.isCompanion()) {
-                    val containerClass = container.getParentOfType<JetClass>(true)
+            is KtFile -> container.javaFileFacadeFqName
+            is KtClassOrObject -> {
+                if (container is KtObjectDeclaration && container.isCompanion()) {
+                    val containerClass = container.getParentOfType<KtClass>(true)
                     containerClass?.getFqName()
                 } else {
                     container.getFqName()
@@ -111,12 +111,12 @@ public class KotlinRunConfigurationProducer : RunConfigurationProducer<JetRunCon
             else -> throw IllegalArgumentException("Invalid entry-point container: " + (container as PsiElement).getText())
         }
 
-        private fun PsiElement.declarationContainer(strict: Boolean): JetDeclarationContainer? {
+        private fun PsiElement.declarationContainer(strict: Boolean): KtDeclarationContainer? {
             val element = if (strict)
-                PsiTreeUtil.getParentOfType(this, javaClass<JetClassOrObject>(), javaClass<JetFile>())
+                PsiTreeUtil.getParentOfType(this, javaClass<KtClassOrObject>(), javaClass<KtFile>())
             else
-                PsiTreeUtil.getNonStrictParentOfType(this, javaClass<JetClassOrObject>(), javaClass<JetFile>())
-            return element as JetDeclarationContainer?
+                PsiTreeUtil.getNonStrictParentOfType(this, javaClass<KtClassOrObject>(), javaClass<KtFile>())
+            return element as KtDeclarationContainer?
         }
 
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/JetTargetElementEvaluator.kt b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/JetTargetElementEvaluator.kt
index 7d6960da491..63a933b1234 100644
--- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/JetTargetElementEvaluator.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/JetTargetElementEvaluator.kt
@@ -22,17 +22,17 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.psi.psiUtil.isAbstract
 import com.intellij.psi.PsiReference
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetPrimaryConstructor
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtPrimaryConstructor
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 
 public class JetTargetElementEvaluator : TargetElementEvaluatorEx {
-    override fun includeSelfInGotoImplementation(element: PsiElement): Boolean = !(element is JetClass && element.isAbstract())
+    override fun includeSelfInGotoImplementation(element: PsiElement): Boolean = !(element is KtClass && element.isAbstract())
 
     override fun getElementByReference(ref: PsiReference, flags: Int): PsiElement? = null
 
     override fun isIdentifierPart(file: PsiFile, text: CharSequence?, offset: Int): Boolean {
         // '(' is considered identifier part if it belongs to primary constructor without 'constructor' keyword
-        return file.findElementAt(offset)?.getNonStrictParentOfType<JetPrimaryConstructor>()?.getTextOffset() == offset
+        return file.findElementAt(offset)?.getNonStrictParentOfType<KtPrimaryConstructor>()?.getTextOffset() == offset
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt
index dd46d4a1c85..5bb7b2162f1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt
@@ -44,12 +44,12 @@ public class KotlinAnnotatedElementsSearcher : QueryExecutor<PsiModifierListOwne
     override fun execute(p: AnnotatedElementsSearch.Parameters, consumer: Processor<PsiModifierListOwner>): Boolean {
         return processAnnotatedMembers(p.annotationClass, p.scope) { declaration ->
             when (declaration) {
-                is JetClass -> {
+                is KtClass -> {
                     val lightClass = LightClassUtil.getPsiClass(declaration)
                     consumer.process(lightClass)
                 }
-                is JetNamedFunction, is JetSecondaryConstructor -> {
-                    val wrappedMethod = LightClassUtil.getLightClassMethod(declaration as JetFunction)
+                is KtNamedFunction, is KtSecondaryConstructor -> {
+                    val wrappedMethod = LightClassUtil.getLightClassMethod(declaration as KtFunction)
                     consumer.process(wrappedMethod)
                 }
                 else -> true
@@ -60,7 +60,7 @@ public class KotlinAnnotatedElementsSearcher : QueryExecutor<PsiModifierListOwne
     companion object {
         private val LOG = Logger.getInstance("#com.intellij.psi.impl.search.AnnotatedMembersSearcher")
 
-        public fun processAnnotatedMembers(annClass: PsiClass, useScope: SearchScope, consumer: (JetDeclaration) -> Boolean): Boolean {
+        public fun processAnnotatedMembers(annClass: PsiClass, useScope: SearchScope, consumer: (KtDeclaration) -> Boolean): Boolean {
             assert(annClass.isAnnotationType()) { "Annotation type should be passed to annotated members search" }
 
             val annotationFQN = annClass.getQualifiedName()
@@ -70,9 +70,9 @@ public class KotlinAnnotatedElementsSearcher : QueryExecutor<PsiModifierListOwne
                 if (notJetAnnotationEntry(elt)) continue
 
                 val result = runReadAction(fun(): Boolean {
-                    val declaration = elt.getStrictParentOfType<JetDeclaration>() ?: return true
+                    val declaration = elt.getStrictParentOfType<KtDeclaration>() ?: return true
 
-                    val annotationEntry = elt as JetAnnotationEntry
+                    val annotationEntry = elt as KtAnnotationEntry
 
                     val context = annotationEntry.analyze(BodyResolveMode.PARTIAL)
                     val annotationDescriptor = context.get(BindingContext.ANNOTATION, annotationEntry) ?: return true
@@ -98,12 +98,12 @@ public class KotlinAnnotatedElementsSearcher : QueryExecutor<PsiModifierListOwne
                     return JetAnnotationsIndex.getInstance().get(name, annClass.getProject(), useScope)
                 }
 
-                return (useScope as LocalSearchScope).scope.flatMap { it.collectDescendantsOfType<JetAnnotationEntry>() }
+                return (useScope as LocalSearchScope).scope.flatMap { it.collectDescendantsOfType<KtAnnotationEntry>() }
             })
         }
 
         private fun notJetAnnotationEntry(found: PsiElement): Boolean {
-            if (found is JetAnnotationEntry) return false
+            if (found is KtAnnotationEntry) return false
 
             val faultyContainer = PsiUtilCore.getVirtualFile(found)
             LOG.error("Non annotation in annotations list: $faultyContainer; element:$found")
diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinClassesWithAnnotatedMembersSearcher.kt b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinClassesWithAnnotatedMembersSearcher.kt
index d4c59cdf245..c20bd81590c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinClassesWithAnnotatedMembersSearcher.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinClassesWithAnnotatedMembersSearcher.kt
@@ -22,20 +22,20 @@ import com.intellij.psi.search.searches.ClassesWithAnnotatedMembersSearch
 import com.intellij.psi.search.searches.ScopedQueryExecutor
 import com.intellij.util.Processor
 import org.jetbrains.kotlin.asJava.LightClassUtil
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.search.allScope
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 
 class KotlinClassesWithAnnotatedMembersSearcher : ScopedQueryExecutor<PsiClass, ClassesWithAnnotatedMembersSearch.Parameters> {
     override fun getScope(param: ClassesWithAnnotatedMembersSearch.Parameters): GlobalSearchScope {
-        return GlobalSearchScope.getScopeRestrictedByFileTypes(param.annotationClass.project.allScope(), JetFileType.INSTANCE)
+        return GlobalSearchScope.getScopeRestrictedByFileTypes(param.annotationClass.project.allScope(), KotlinFileType.INSTANCE)
     }
 
     override fun execute(queryParameters: ClassesWithAnnotatedMembersSearch.Parameters, consumer: Processor<PsiClass>): Boolean {
-        val processed = hashSetOf<JetClassOrObject>()
+        val processed = hashSetOf<KtClassOrObject>()
         return KotlinAnnotatedElementsSearcher.processAnnotatedMembers(queryParameters.annotationClass, queryParameters.scope) { declaration ->
-            val jetClass = declaration.getNonStrictParentOfType<JetClassOrObject>()
+            val jetClass = declaration.getNonStrictParentOfType<KtClassOrObject>()
             if (jetClass != null && processed.add(jetClass)) {
                 val lightClass = LightClassUtil.getPsiClass(jetClass)
                 if (lightClass != null) consumer.process(lightClass) else true
diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDefinitionsSearcher.java b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDefinitionsSearcher.java
index 31e723b62da..a26f2b5ea62 100644
--- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDefinitionsSearcher.java
+++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDefinitionsSearcher.java
@@ -42,29 +42,29 @@ public class KotlinDefinitionsSearcher implements QueryExecutor<PsiElement, Defi
         PsiElement element = queryParameters.getElement();
         SearchScope scope = queryParameters.getScope();
 
-        if (element instanceof JetClass) {
-            return processClassImplementations((JetClass) element, consumer);
+        if (element instanceof KtClass) {
+            return processClassImplementations((KtClass) element, consumer);
         }
 
-        if (element instanceof JetNamedFunction || element instanceof JetSecondaryConstructor) {
-            return processFunctionImplementations((JetFunction) element, scope, consumer);
+        if (element instanceof KtNamedFunction || element instanceof KtSecondaryConstructor) {
+            return processFunctionImplementations((KtFunction) element, scope, consumer);
         }
 
-        if (element instanceof JetProperty) {
-            return processPropertyImplementations((JetProperty) element, scope, consumer);
+        if (element instanceof KtProperty) {
+            return processPropertyImplementations((KtProperty) element, scope, consumer);
         }
 
-        if (element instanceof JetParameter) {
-            JetParameter parameter = (JetParameter) element;
-            if (JetPsiUtil.getClassIfParameterIsProperty(parameter) != null) {
-                return processPropertyImplementations((JetParameter) element, scope, consumer);
+        if (element instanceof KtParameter) {
+            KtParameter parameter = (KtParameter) element;
+            if (KtPsiUtil.getClassIfParameterIsProperty(parameter) != null) {
+                return processPropertyImplementations((KtParameter) element, scope, consumer);
             }
         }
 
         return true;
      }
 
-    private static boolean processClassImplementations(final JetClass klass, Processor<PsiElement> consumer) {
+    private static boolean processClassImplementations(final KtClass klass, Processor<PsiElement> consumer) {
         PsiClass psiClass = ApplicationManager.getApplication().runReadAction(new Computable<PsiClass>() {
             @Override
             public PsiClass compute() {
@@ -77,7 +77,7 @@ public class KotlinDefinitionsSearcher implements QueryExecutor<PsiElement, Defi
         return true;
     }
 
-    private static boolean processFunctionImplementations(final JetFunction function, SearchScope scope, Processor<PsiElement> consumer) {
+    private static boolean processFunctionImplementations(final KtFunction function, SearchScope scope, Processor<PsiElement> consumer) {
         PsiMethod psiMethod = ApplicationManager.getApplication().runReadAction(new Computable<PsiMethod>() {
             @Override
             public PsiMethod compute() {
@@ -92,7 +92,7 @@ public class KotlinDefinitionsSearcher implements QueryExecutor<PsiElement, Defi
         return true;
     }
 
-    private static boolean processPropertyImplementations(@NotNull final JetParameter parameter, @NotNull SearchScope scope, @NotNull Processor<PsiElement> consumer) {
+    private static boolean processPropertyImplementations(@NotNull final KtParameter parameter, @NotNull SearchScope scope, @NotNull Processor<PsiElement> consumer) {
         LightClassUtil.PropertyAccessorsPsiMethods accessorsPsiMethods = ApplicationManager.getApplication().runReadAction(
                 new Computable<LightClassUtil.PropertyAccessorsPsiMethods>() {
                     @Override
@@ -104,7 +104,7 @@ public class KotlinDefinitionsSearcher implements QueryExecutor<PsiElement, Defi
         return processPropertyImplementationsMethods(accessorsPsiMethods, scope, consumer);
     }
 
-    private static boolean processPropertyImplementations(@NotNull final JetProperty property, @NotNull SearchScope scope, @NotNull Processor<PsiElement> consumer) {
+    private static boolean processPropertyImplementations(@NotNull final KtProperty property, @NotNull SearchScope scope, @NotNull Processor<PsiElement> consumer) {
         LightClassUtil.PropertyAccessorsPsiMethods accessorsPsiMethods = ApplicationManager.getApplication().runReadAction(
                 new Computable<LightClassUtil.PropertyAccessorsPsiMethods>() {
                     @Override
@@ -124,12 +124,12 @@ public class KotlinDefinitionsSearcher implements QueryExecutor<PsiElement, Defi
             for (PsiMethod implementation : implementations) {
                 PsiElement mirrorElement = implementation instanceof KotlinLightMethod
                                            ? ((KotlinLightMethod) implementation).getOrigin() : null;
-                if (mirrorElement instanceof JetProperty || mirrorElement instanceof JetParameter) {
+                if (mirrorElement instanceof KtProperty || mirrorElement instanceof KtParameter) {
                     if (!consumer.process(mirrorElement)) {
                         return false;
                     }
                 }
-                else if (mirrorElement instanceof JetPropertyAccessor && mirrorElement.getParent() instanceof JetProperty) {
+                else if (mirrorElement instanceof KtPropertyAccessor && mirrorElement.getParent() instanceof KtProperty) {
                     if (!consumer.process(mirrorElement.getParent())) {
                         return false;
                     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinOverridingMethodReferenceSearcher.kt b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinOverridingMethodReferenceSearcher.kt
index 81bbe798045..9db4c82578f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinOverridingMethodReferenceSearcher.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinOverridingMethodReferenceSearcher.kt
@@ -28,10 +28,10 @@ import com.intellij.util.Processor
 import org.jetbrains.kotlin.asJava.KotlinLightMethod
 import org.jetbrains.kotlin.asJava.getRepresentativeLightMethod
 import org.jetbrains.kotlin.asJava.toLightMethods
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetFunction
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 
 public class KotlinOverridingMethodReferenceSearcher : MethodUsagesSearcher() {
     override fun getTextOccurrenceProcessor(methods: Array<out PsiMethod>,
@@ -39,7 +39,7 @@ public class KotlinOverridingMethodReferenceSearcher : MethodUsagesSearcher() {
                                             strictSignatureSearch: Boolean): MethodTextOccurrenceProcessor? {
         return object: MethodTextOccurrenceProcessor(aClass, strictSignatureSearch, *methods) {
             override fun processInexactReference(ref: PsiReference, refElement: PsiElement?, method: PsiMethod, consumer: Processor<PsiReference>): Boolean {
-                if (refElement !is JetCallableDeclaration) return true
+                if (refElement !is KtCallableDeclaration) return true
                 return refElement.getRepresentativeLightMethod()?.let { super.processInexactReference(ref, it, method, consumer) } ?: true
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinOverridingMethodsWithGenericsSearcher.kt b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinOverridingMethodsWithGenericsSearcher.kt
index 836b04bb19a..7fd51c4df75 100644
--- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinOverridingMethodsWithGenericsSearcher.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinOverridingMethodsWithGenericsSearcher.kt
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.util.application.runReadAction
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.OverrideResolver
 
@@ -38,7 +38,7 @@ public class KotlinOverridingMethodsWithGenericsSearcher : QueryExecutor<PsiMeth
         val method = p.method
         if (method !is KotlinLightMethod) return true
 
-        val declaration = method.getOrigin() as? JetCallableDeclaration
+        val declaration = method.getOrigin() as? KtCallableDeclaration
         if (declaration == null) return true
 
         val callDescriptor = runReadAction { declaration.resolveToDescriptor() }
@@ -59,7 +59,7 @@ public class KotlinOverridingMethodsWithGenericsSearcher : QueryExecutor<PsiMeth
         })
     }
 
-    private fun findOverridingMethod(inheritor: PsiClass, callableDeclaration: JetCallableDeclaration): PsiMethod? {
+    private fun findOverridingMethod(inheritor: PsiClass, callableDeclaration: KtCallableDeclaration): PsiMethod? {
         // Leave Java classes search to JavaOverridingMethodsSearcher
         if (inheritor !is KotlinLightClass) return null
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinPropertyAccessorsReferenceSearcher.kt b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinPropertyAccessorsReferenceSearcher.kt
index 8316b0efd52..f68c20b02bb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinPropertyAccessorsReferenceSearcher.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinPropertyAccessorsReferenceSearcher.kt
@@ -25,9 +25,9 @@ import com.intellij.psi.search.UsageSearchContext
 import com.intellij.psi.search.searches.MethodReferencesSearch
 import com.intellij.util.Processor
 import org.jetbrains.kotlin.asJava.namedUnwrappedElement
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.resolve.getJavaMethodDescriptor
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.synthetic.JavaSyntheticPropertiesScope
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
@@ -49,7 +49,7 @@ public class KotlinPropertyAccessorsReferenceSearcher() : QueryExecutorBase<PsiR
 
     private fun propertyName(method: PsiMethod): String? {
         val unwrapped = method.namedUnwrappedElement
-        if (unwrapped is JetProperty) {
+        if (unwrapped is KtProperty) {
             return unwrapped.getName()
         }
 
@@ -61,7 +61,7 @@ public class KotlinPropertyAccessorsReferenceSearcher() : QueryExecutorBase<PsiR
 
     private fun restrictToKotlinSources(originalScope: SearchScope): SearchScope {
         return when (originalScope) {
-            is GlobalSearchScope -> GlobalSearchScope.getScopeRestrictedByFileTypes(originalScope, JetFileType.INSTANCE)
+            is GlobalSearchScope -> GlobalSearchScope.getScopeRestrictedByFileTypes(originalScope, KotlinFileType.INSTANCE)
             else -> originalScope
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/testIntegration/KotlinCreateTestIntention.kt b/idea/src/org/jetbrains/kotlin/idea/testIntegration/KotlinCreateTestIntention.kt
index c31f4f1c6d3..56c669f5704 100644
--- a/idea/src/org/jetbrains/kotlin/idea/testIntegration/KotlinCreateTestIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/testIntegration/KotlinCreateTestIntention.kt
@@ -43,23 +43,23 @@ import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingRangeIntention
 import org.jetbrains.kotlin.idea.util.application.executeCommand
 import org.jetbrains.kotlin.idea.util.application.runWithAlternativeResolveEnabled
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetEnumEntry
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtEnumEntry
+import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.utils.addToStdlib.singletonList
 import java.util.*
 
-class KotlinCreateTestIntention : JetSelfTargetingRangeIntention<JetClassOrObject>(
-        JetClassOrObject::class.java,
+class KotlinCreateTestIntention : JetSelfTargetingRangeIntention<KtClassOrObject>(
+        KtClassOrObject::class.java,
         CodeInsightBundle.message("intention.create.test")
 ) {
-    override fun applicabilityRange(element: JetClassOrObject): TextRange? {
+    override fun applicabilityRange(element: KtClassOrObject): TextRange? {
         if (element.isLocal()) return null
-        if (element is JetEnumEntry) return null
-        if (element is JetClass && (element.isAnnotation() || element.isInterface())) return null
+        if (element is KtEnumEntry) return null
+        if (element is KtClass && (element.isAnnotation() || element.isInterface())) return null
         if (ModuleUtilCore.findModuleForPsiElement(element) == null) return null
         if (element.resolveToDescriptorIfAny() == null) return null
 
@@ -69,7 +69,7 @@ class KotlinCreateTestIntention : JetSelfTargetingRangeIntention<JetClassOrObjec
         )
     }
 
-    override fun applyTo(element: JetClassOrObject, editor: Editor) {
+    override fun applyTo(element: KtClassOrObject, editor: Editor) {
         object : CreateTestAction() {
             // Based on the com.intellij.testIntegration.createTest.JavaTestGenerator.createTestClass()
             private fun findTestClass(targetDirectory: PsiDirectory, className: String): PsiClass? {
@@ -148,7 +148,7 @@ class KotlinCreateTestIntention : JetSelfTargetingRangeIntention<JetClassOrObjec
                             runWriteAction {
                                 val existingMethodNames = existingClass
                                         .declarations
-                                        .filterIsInstance<JetNamedFunction>()
+                                        .filterIsInstance<KtNamedFunction>()
                                         .mapTo(HashSet()) { it.name }
                                 generatedClass
                                         .methods
diff --git a/idea/src/org/jetbrains/kotlin/idea/testIntegration/KotlinTestFinder.kt b/idea/src/org/jetbrains/kotlin/idea/testIntegration/KotlinTestFinder.kt
index 14b0fc1283f..60e36637a20 100644
--- a/idea/src/org/jetbrains/kotlin/idea/testIntegration/KotlinTestFinder.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/testIntegration/KotlinTestFinder.kt
@@ -30,7 +30,7 @@ import com.intellij.util.containers.HashSet
 import org.jetbrains.kotlin.asJava.KotlinLightClassForExplicitDeclaration
 import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 import java.util.*
 import java.util.regex.Pattern
@@ -41,7 +41,7 @@ class KotlinTestFinder : JavaTestFinder() {
     override fun findSourceElement(from: PsiElement): PsiClass? {
         super.findSourceElement(from)?.let { return it }
 
-        val classOrObject = from.parentsWithSelf.filterIsInstance<JetClassOrObject>().firstOrNull { !it.isLocal() } ?: return null
+        val classOrObject = from.parentsWithSelf.filterIsInstance<KtClassOrObject>().firstOrNull { !it.isLocal() } ?: return null
         if (classOrObject.resolveToDescriptorIfAny() == null) return null
         return classOrObject.toLightClass()
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/testIntegration/testIntegrationUtils.kt b/idea/src/org/jetbrains/kotlin/idea/testIntegration/testIntegrationUtils.kt
index 82fc5d46fba..b15b48b2fba 100644
--- a/idea/src/org/jetbrains/kotlin/idea/testIntegration/testIntegrationUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/testIntegration/testIntegrationUtils.kt
@@ -21,9 +21,9 @@ import com.intellij.openapi.extensions.Extensions
 import com.intellij.testIntegration.TestFramework
 import com.intellij.util.SmartList
 import org.jetbrains.kotlin.asJava.toLightClass
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 
-public fun findSuitableFrameworks(klass: JetClassOrObject): List<TestFramework> {
+public fun findSuitableFrameworks(klass: KtClassOrObject): List<TestFramework> {
     val lightClass = klass.toLightClass() ?: return emptyList()
     val frameworks = Extensions.getExtensions(TestFramework.EXTENSION_NAME).filter { it.language == JavaLanguage.INSTANCE }
     return frameworks.firstOrNull { it.isTestClass(lightClass) }?.let { listOf(it) }
diff --git a/idea/src/org/jetbrains/kotlin/idea/util/DebuggerUtils.java b/idea/src/org/jetbrains/kotlin/idea/util/DebuggerUtils.java
index 6b2c9b6a388..102dc956c0a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/util/DebuggerUtils.java
+++ b/idea/src/org/jetbrains/kotlin/idea/util/DebuggerUtils.java
@@ -25,9 +25,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.io.FileUtilRt;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.search.GlobalSearchScope;
-import kotlin.CollectionsKt;
 import kotlin.Pair;
-import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
@@ -36,7 +34,6 @@ import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde;
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade;
 import org.jetbrains.kotlin.idea.stubindex.StaticFacadeIndexUtil;
-import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
@@ -58,7 +55,7 @@ public class DebuggerUtils {
     private static final Set<String> KOTLIN_EXTENSIONS = Sets.newHashSet("kt", "kts");
 
     @Nullable
-    public static JetFile findSourceFileForClass(
+    public static KtFile findSourceFileForClass(
             @NotNull Project project,
             @NotNull GlobalSearchScope searchScope,
             @NotNull JvmClassName className,
@@ -68,10 +65,10 @@ public class DebuggerUtils {
         if (!KOTLIN_EXTENSIONS.contains(extension)) return null;
         if (DumbService.getInstance(project).isDumb()) return null;
 
-        Collection<JetFile> filesInPackage = findFilesWithExactPackage(className.getPackageFqName(), searchScope, project);
-        Collection<JetFile> filesWithExactName = Collections2.filter(filesInPackage, new Predicate<JetFile>() {
+        Collection<KtFile> filesInPackage = findFilesWithExactPackage(className.getPackageFqName(), searchScope, project);
+        Collection<KtFile> filesWithExactName = Collections2.filter(filesInPackage, new Predicate<KtFile>() {
             @Override
-            public boolean apply(@Nullable JetFile file) {
+            public boolean apply(@Nullable KtFile file) {
                 return file != null && file.getName().equals(fileName);
             }
         });
@@ -84,9 +81,9 @@ public class DebuggerUtils {
 
         // Static facade or inner class of such facade?
         FqName partFqName = className.getFqNameForClassNameWithoutDollars();
-        Collection<JetFile> filesForPart = StaticFacadeIndexUtil.findFilesForFilePart(partFqName, searchScope, project);
+        Collection<KtFile> filesForPart = StaticFacadeIndexUtil.findFilesForFilePart(partFqName, searchScope, project);
         if (!filesForPart.isEmpty()) {
-            for (JetFile file : filesForPart) {
+            for (KtFile file : filesForPart) {
                 if (file.getName().equals(fileName)) {
                     return file;
                 }
@@ -99,13 +96,13 @@ public class DebuggerUtils {
     }
 
     @NotNull
-    public static Pair<BindingContext, List<JetFile>> analyzeInlinedFunctions(
+    public static Pair<BindingContext, List<KtFile>> analyzeInlinedFunctions(
             @NotNull ResolutionFacade resolutionFacadeForFile,
             @NotNull BindingContext bindingContextForFile,
-            @NotNull JetFile file,
+            @NotNull KtFile file,
             boolean analyzeOnlyReifiedInlineFunctions
     ) {
-        Set<JetElement> analyzedElements = new HashSet<JetElement>();
+        Set<KtElement> analyzedElements = new HashSet<KtElement>();
         BindingContext context = analyzeElementWithInline(
                 resolutionFacadeForFile,
                 bindingContextForFile,
@@ -116,25 +113,25 @@ public class DebuggerUtils {
 
         //We processing another files just to annotate anonymous classes within their inline functions
         //Bytecode not produced for them cause of filtering via generateClassFilter
-        Set<JetFile> toProcess = new LinkedHashSet<JetFile>();
+        Set<KtFile> toProcess = new LinkedHashSet<KtFile>();
         toProcess.add(file);
 
-        for (JetElement collectedElement : analyzedElements) {
-            JetFile containingFile = collectedElement.getContainingJetFile();
+        for (KtElement collectedElement : analyzedElements) {
+            KtFile containingFile = collectedElement.getContainingJetFile();
             toProcess.add(containingFile);
         }
 
-        return new Pair<BindingContext, List<JetFile>>(context, new ArrayList<JetFile>(toProcess));
+        return new Pair<BindingContext, List<KtFile>>(context, new ArrayList<KtFile>(toProcess));
     }
 
     @NotNull
-    public static Collection<JetElement> analyzeElementWithInline(
+    public static Collection<KtElement> analyzeElementWithInline(
             @NotNull ResolutionFacade resolutionFacade,
             @NotNull BindingContext bindingContext,
-            @NotNull JetNamedFunction function,
+            @NotNull KtNamedFunction function,
             boolean analyzeInlineFunctions
     ) {
-        Set<JetElement> analyzedElements = new HashSet<JetElement>();
+        Set<KtElement> analyzedElements = new HashSet<KtElement>();
         analyzeElementWithInline(resolutionFacade, bindingContext, function, 1, analyzedElements, !analyzeInlineFunctions);
         return analyzedElements;
     }
@@ -143,17 +140,17 @@ public class DebuggerUtils {
     private static BindingContext analyzeElementWithInline(
             @NotNull ResolutionFacade resolutionFacade,
             @NotNull final BindingContext bindingContext,
-            @NotNull JetElement element,
+            @NotNull KtElement element,
             int deep,
-            @NotNull final Set<JetElement> analyzedElements,
+            @NotNull final Set<KtElement> analyzedElements,
             final boolean analyzeInlineFunctions
     ) {
         final Project project = element.getProject();
-        final Set<JetNamedFunction> collectedElements = new HashSet<JetNamedFunction>();
+        final Set<KtNamedFunction> collectedElements = new HashSet<KtNamedFunction>();
 
-        element.accept(new JetTreeVisitorVoid() {
+        element.accept(new KtTreeVisitorVoid() {
             @Override
-            public void visitExpression(@NotNull JetExpression expression) {
+            public void visitExpression(@NotNull KtExpression expression) {
                 super.visitExpression(expression);
 
                 Call call = bindingContext.get(BindingContext.CALL, expression);
@@ -164,10 +161,10 @@ public class DebuggerUtils {
             }
 
             @Override
-            public void visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration) {
+            public void visitMultiDeclaration(@NotNull KtMultiDeclaration multiDeclaration) {
                 super.visitMultiDeclaration(multiDeclaration);
 
-                for (JetMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
+                for (KtMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
                     ResolvedCall<FunctionDescriptor> resolvedCall =
                             bindingContext.get(BindingContext.COMPONENT_RESOLVED_CALL, entry);
                     checkResolveCall(resolvedCall);
@@ -175,7 +172,7 @@ public class DebuggerUtils {
             }
 
             @Override
-            public void visitForExpression(@NotNull JetForExpression expression) {
+            public void visitForExpression(@NotNull KtForExpression expression) {
                 super.visitForExpression(expression);
 
                 checkResolveCall(bindingContext.get(BindingContext.LOOP_RANGE_ITERATOR_RESOLVED_CALL, expression.getLoopRange()));
@@ -191,8 +188,8 @@ public class DebuggerUtils {
 
                 if (InlineUtil.isInline(descriptor) && (analyzeInlineFunctions || hasReifiedTypeParameters(descriptor))) {
                     PsiElement declaration = DescriptorToSourceUtilsIde.INSTANCE$.getAnyDeclaration(project, descriptor);
-                    if (declaration != null && declaration instanceof JetNamedFunction && !analyzedElements.contains(declaration)) {
-                        collectedElements.add((JetNamedFunction) declaration);
+                    if (declaration != null && declaration instanceof KtNamedFunction && !analyzedElements.contains(declaration)) {
+                        collectedElements.add((KtNamedFunction) declaration);
                     }
                 }
             }
@@ -202,8 +199,8 @@ public class DebuggerUtils {
 
         if (!collectedElements.isEmpty() && deep < 10) {
             List<BindingContext> innerContexts = new ArrayList<BindingContext>();
-            for (JetNamedFunction inlineFunctions : collectedElements) {
-                JetExpression body = inlineFunctions.getBodyExpression();
+            for (KtNamedFunction inlineFunctions : collectedElements) {
+                KtExpression body = inlineFunctions.getBodyExpression();
                 if (body != null) {
                     BindingContext bindingContextForFunction = resolutionFacade.analyze(body, BodyResolveMode.FULL);
                     innerContexts.add(analyzeElementWithInline(resolutionFacade, bindingContextForFunction, inlineFunctions, deep + 1,
diff --git a/idea/src/org/jetbrains/kotlin/idea/util/DialogWithEditor.kt b/idea/src/org/jetbrains/kotlin/idea/util/DialogWithEditor.kt
index c6c159e3a38..324f1ae249b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/util/DialogWithEditor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/util/DialogWithEditor.kt
@@ -44,10 +44,10 @@ public open class DialogWithEditor(
 
     private fun createEditor(): Editor {
         val editorFactory = EditorFactory.getInstance()!!
-        val virtualFile = LightVirtualFile("dummy.kt", JetFileType.INSTANCE, initialText)
+        val virtualFile = LightVirtualFile("dummy.kt", KotlinFileType.INSTANCE, initialText)
         val document = FileDocumentManager.getInstance().getDocument(virtualFile)!!
 
-        val editor = editorFactory.createEditor(document, project, JetFileType.INSTANCE, false)
+        val editor = editorFactory.createEditor(document, project, KotlinFileType.INSTANCE, false)
         val settings = editor.getSettings()
         settings.setVirtualSpace(false)
         settings.setLineMarkerAreaShown(false)
diff --git a/idea/src/org/jetbrains/kotlin/idea/util/ImportInsertHelperImpl.kt b/idea/src/org/jetbrains/kotlin/idea/util/ImportInsertHelperImpl.kt
index e269feab529..891d621e5ad 100644
--- a/idea/src/org/jetbrains/kotlin/idea/util/ImportInsertHelperImpl.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/util/ImportInsertHelperImpl.kt
@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.resolve.ImportPath
 import org.jetbrains.kotlin.resolve.descriptorUtil.getImportableDescriptor
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.getDescriptorsFiltered
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.utils.addIfNotNull
@@ -76,7 +76,7 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
         }
     }
 
-    override fun isImportedWithDefault(importPath: ImportPath, contextFile: JetFile): Boolean {
+    override fun isImportedWithDefault(importPath: ImportPath, contextFile: KtFile): Boolean {
         val defaultImports = contextFile.platform.defaultModuleParameters.defaultImports
         return importPath.isImported(defaultImports)
     }
@@ -95,15 +95,15 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
         }
     }
 
-    override fun importDescriptor(file: JetFile, descriptor: DeclarationDescriptor)
+    override fun importDescriptor(file: KtFile, descriptor: DeclarationDescriptor)
             = Importer(file).importDescriptor(descriptor)
 
     private inner class Importer(
-            private val file: JetFile
+            private val file: KtFile
     ) {
         private val resolutionFacade = file.getResolutionFacade()
 
-        private fun isAlreadyImported(target: DeclarationDescriptor, topLevelScope: JetScope, targetFqName: FqName): Boolean {
+        private fun isAlreadyImported(target: DeclarationDescriptor, topLevelScope: KtScope, targetFqName: FqName): Boolean {
             val name = target.name
             when (target) {
                 is ClassDescriptor -> {
@@ -132,7 +132,7 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
             val targetFqName = target.importableFqName ?: return ImportDescriptorResult.FAIL
             if (isAlreadyImported(target, topLevelScope, targetFqName)) return ImportDescriptorResult.ALREADY_IMPORTED
 
-            val imports = if (file is JetCodeFragment)
+            val imports = if (file is KtCodeFragment)
                 file.importsAsImportList()?.getImports() ?: listOf()
             else
                 file.getImportDirectives()
@@ -175,7 +175,7 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
             return addExplicitImport(target)
         }
 
-        private fun shouldTryStarImport(containerFqName: FqName, target: DeclarationDescriptor, imports: Collection<JetImportDirective>): Boolean {
+        private fun shouldTryStarImport(containerFqName: FqName, target: DeclarationDescriptor, imports: Collection<KtImportDirective>): Boolean {
             if (containerFqName.isRoot) return false
 
             val container = target.containingDeclaration
@@ -262,7 +262,7 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
             return ImportDescriptorResult.IMPORT_ADDED
         }
 
-        private fun getMemberScope(fqName: FqName, moduleDescriptor: ModuleDescriptor): JetScope? {
+        private fun getMemberScope(fqName: FqName, moduleDescriptor: ModuleDescriptor): KtScope? {
             val packageView = moduleDescriptor.getPackage(fqName)
             if (!packageView.isEmpty()) {
                 return packageView.memberScope
@@ -322,20 +322,20 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
 
             val classesToCheck = importedClasses.map { it.getName() to it }.toMap().toLinkedMap()
             val result = LinkedHashSet<ClassifierDescriptor>()
-            file.accept(object : JetVisitorVoid() {
+            file.accept(object : KtVisitorVoid() {
                 override fun visitElement(element: PsiElement) {
                     if (classesToCheck.isEmpty()) return
                     element.acceptChildren(this)
                 }
 
-                override fun visitImportList(importList: JetImportList) {
+                override fun visitImportList(importList: KtImportList) {
                 }
 
-                override fun visitPackageDirective(directive: JetPackageDirective) {
+                override fun visitPackageDirective(directive: KtPackageDirective) {
                 }
 
-                override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
-                    if (JetPsiUtil.isSelectorInQualified(expression)) return
+                override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
+                    if (KtPsiUtil.isSelectorInQualified(expression)) return
 
                     val refName = expression.getReferencedNameAsName()
                     val descriptor = classesToCheck[refName]
@@ -351,13 +351,13 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
             return result
         }
 
-        private fun targetFqName(ref: JetReferenceExpression): FqName?
+        private fun targetFqName(ref: KtReferenceExpression): FqName?
                 = ref.resolveTargets().map { it.importableFqName }.toSet().singleOrNull()
 
-        private fun JetReferenceExpression.resolveTargets(): Collection<DeclarationDescriptor>
+        private fun KtReferenceExpression.resolveTargets(): Collection<DeclarationDescriptor>
                 = this.getImportableTargets(resolutionFacade.analyze(this, BodyResolveMode.PARTIAL))
 
-        private fun addImport(fqName: FqName, allUnder: Boolean): JetImportDirective {
+        private fun addImport(fqName: FqName, allUnder: Boolean): KtImportDirective {
             //TODO: it's a temporary hack for JetCodeFragment's and non-physical files
             // We should increment modification tracker after inserting import to invalidate resolve caches.
             // Without this modification references with new import won't be resolved.
@@ -365,8 +365,8 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
 
             val importPath = ImportPath(fqName, allUnder)
 
-            val psiFactory = JetPsiFactory(project)
-            if (file is JetCodeFragment) {
+            val psiFactory = KtPsiFactory(project)
+            if (file is KtCodeFragment) {
                 val newDirective = psiFactory.createImportDirective(importPath)
                 file.addImportsFromString(newDirective.getText())
                 return newDirective
@@ -378,7 +378,7 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
                 val imports = importList.getImports()
                 if (imports.isEmpty()) { //TODO: strange hack
                     importList.add(psiFactory.createNewLine())
-                    return importList.add(newDirective) as JetImportDirective
+                    return importList.add(newDirective) as KtImportDirective
                 }
                 else {
                     val insertAfter = imports
@@ -386,7 +386,7 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
                                 val directivePath = it.getImportPath()
                                 directivePath != null && ImportPathComparator.compare(directivePath, importPath) <= 0
                             }
-                    return importList.addAfter(newDirective, insertAfter) as JetImportDirective
+                    return importList.addAfter(newDirective, insertAfter) as KtImportDirective
                 }
             }
             else {
diff --git a/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/JetPsiRange.kt b/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/JetPsiRange.kt
index 171126152e7..64dcd88406d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/JetPsiRange.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/JetPsiRange.kt
@@ -17,8 +17,8 @@
 package org.jetbrains.kotlin.idea.util.psi.patternMatching
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetTreeVisitorVoid
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtTreeVisitorVoid
+import org.jetbrains.kotlin.psi.KtElement
 import java.util.ArrayList
 import com.intellij.psi.PsiWhiteSpace
 import com.intellij.psi.PsiComment
@@ -67,8 +67,8 @@ public interface JetPsiRange {
 
         val matches = ArrayList<Match>()
         scope.accept(
-                object: JetTreeVisitorVoid() {
-                    override fun visitJetElement(element: JetElement) {
+                object: KtTreeVisitorVoid() {
+                    override fun visitJetElement(element: KtElement) {
                         val range = element
                                 .siblings()
                                 .filter(SIGNIFICANT_FILTER)
diff --git a/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/JetPsiUnifier.kt b/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/JetPsiUnifier.kt
index bd4d37c3a40..c03ad8ee5d4 100644
--- a/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/JetPsiUnifier.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/JetPsiUnifier.kt
@@ -20,75 +20,75 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.UnificationResult.*
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.UnificationResult.Status.*
 import java.util.HashMap
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetPsiUtil
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtPsiUtil
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import com.intellij.util.containers.ContainerUtil
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import java.util.Collections
-import org.jetbrains.kotlin.psi.JetReferenceExpression
+import org.jetbrains.kotlin.psi.KtReferenceExpression
 import org.jetbrains.kotlin.psi.Call
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import com.intellij.psi.impl.source.tree.LeafPsiElement
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetTypeReference
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtTypeReference
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.psi.ValueArgument
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
-import org.jetbrains.kotlin.psi.JetIfExpression
-import org.jetbrains.kotlin.psi.JetUnaryExpression
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetConstantExpression
+import org.jetbrains.kotlin.psi.KtIfExpression
+import org.jetbrains.kotlin.psi.KtUnaryExpression
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtConstantExpression
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
-import org.jetbrains.kotlin.psi.JetArrayAccessExpression
-import org.jetbrains.kotlin.lexer.JetToken
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtArrayAccessExpression
+import org.jetbrains.kotlin.lexer.KtToken
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
-import org.jetbrains.kotlin.psi.JetLabelReferenceExpression
+import org.jetbrains.kotlin.psi.KtLabelReferenceExpression
 import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.types.ErrorUtils
 import com.intellij.lang.ASTNode
 import com.intellij.util.containers.MultiMap
-import org.jetbrains.kotlin.psi.JetCallableReferenceExpression
+import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver
-import org.jetbrains.kotlin.psi.JetThisExpression
-import org.jetbrains.kotlin.psi.JetStringTemplateEntryWithExpression
+import org.jetbrains.kotlin.psi.KtThisExpression
+import org.jetbrains.kotlin.psi.KtStringTemplateEntryWithExpression
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.JetPsiRange.Empty
-import org.jetbrains.kotlin.psi.JetMultiDeclaration
-import org.jetbrains.kotlin.psi.JetFunction
-import org.jetbrains.kotlin.psi.JetClassBody
+import org.jetbrains.kotlin.psi.KtMultiDeclaration
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.psi.KtClassBody
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.psi.JetDeclarationWithBody
+import org.jetbrains.kotlin.psi.KtDeclarationWithBody
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
-import org.jetbrains.kotlin.psi.JetWithExpressionInitializer
-import org.jetbrains.kotlin.psi.JetParameter
+import org.jetbrains.kotlin.psi.KtWithExpressionInitializer
+import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
-import org.jetbrains.kotlin.psi.JetTypeParameter
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtTypeParameter
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
-import org.jetbrains.kotlin.psi.JetClass
+import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetClassInitializer
-import org.jetbrains.kotlin.psi.JetTypeParameterListOwner
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtClassInitializer
+import org.jetbrains.kotlin.psi.KtTypeParameterListOwner
 import org.jetbrains.kotlin.psi.doNotAnalyze
-import org.jetbrains.kotlin.psi.JetReturnExpression
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetDelegatorToSuperClass
-import org.jetbrains.kotlin.psi.JetDelegationSpecifier
+import org.jetbrains.kotlin.psi.KtReturnExpression
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtDelegatorToSuperClass
+import org.jetbrains.kotlin.psi.KtDelegationSpecifier
 import org.jetbrains.kotlin.idea.core.refactoring.getContextForContainingDeclarationBody
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
-import org.jetbrains.kotlin.psi.JetOperationReferenceExpression
+import org.jetbrains.kotlin.psi.KtOperationReferenceExpression
 
 public interface UnificationResult {
     public enum class Status {
@@ -108,15 +108,15 @@ public interface UnificationResult {
     }
 
     interface Matched: UnificationResult {
-        val substitution: Map<UnifierParameter, JetExpression>
+        val substitution: Map<UnifierParameter, KtExpression>
         override val status: Status get() = MATCHED
     }
 
-    class StronglyMatched(override val substitution: Map<UnifierParameter, JetExpression>): Matched
+    class StronglyMatched(override val substitution: Map<UnifierParameter, KtExpression>): Matched
 
     class WeaklyMatched(
-            override val substitution: Map<UnifierParameter, JetExpression>,
-            val weakMatches: Map<JetElement, JetElement>
+            override val substitution: Map<UnifierParameter, KtExpression>,
+            val weakMatches: Map<KtElement, KtElement>
     ): Matched
 
     val status: Status
@@ -125,7 +125,7 @@ public interface UnificationResult {
 
 public class UnifierParameter(
         val descriptor: DeclarationDescriptor,
-        val expectedType: JetType
+        val expectedType: KtType
 )
 
 public class JetPsiUnifier(
@@ -142,14 +142,14 @@ public class JetPsiUnifier(
     ) {
         val patternContext: BindingContext = originalPattern.getBindingContext()
         val targetContext: BindingContext = originalTarget.getBindingContext()
-        val substitution = HashMap<UnifierParameter, JetExpression>()
+        val substitution = HashMap<UnifierParameter, KtExpression>()
         val declarationPatternsToTargets = MultiMap<DeclarationDescriptor, DeclarationDescriptor>()
-        val weakMatches = HashMap<JetElement, JetElement>()
+        val weakMatches = HashMap<KtElement, KtElement>()
         var checkEquivalence: Boolean = false
 
         private fun JetPsiRange.getBindingContext(): BindingContext {
-            val element = (this as? JetPsiRange.ListRange)?.startElement as? JetElement
-            if ((element?.getContainingFile() as? JetFile)?.doNotAnalyze != null) return BindingContext.EMPTY
+            val element = (this as? JetPsiRange.ListRange)?.startElement as? KtElement
+            if ((element?.getContainingFile() as? KtFile)?.doNotAnalyze != null) return BindingContext.EMPTY
             return element?.getContextForContainingDeclarationBody() ?: BindingContext.EMPTY
         }
 
@@ -157,8 +157,8 @@ public class JetPsiUnifier(
             if (d1 == d2 || d2 in declarationPatternsToTargets[d1] || d1 in declarationPatternsToTargets[d2]) return true
             if (d1 == null || d2 == null) return false
 
-            val decl1 = DescriptorToSourceUtils.descriptorToDeclaration(d1) as? JetDeclaration
-            val decl2 = DescriptorToSourceUtils.descriptorToDeclaration(d2) as? JetDeclaration
+            val decl1 = DescriptorToSourceUtils.descriptorToDeclaration(d1) as? KtDeclaration
+            val decl2 = DescriptorToSourceUtils.descriptorToDeclaration(d2) as? KtDeclaration
             if (decl1 == null || decl2 == null) return false
             if (decl1 == decl2) return true
 
@@ -202,15 +202,15 @@ public class JetPsiUnifier(
 
         private fun matchResolvedCalls(rc1: ResolvedCall<*>, rc2: ResolvedCall<*>): Status? {
             fun checkSpecialOperations(): Boolean {
-                val op1 = (rc1.getCall().getCalleeExpression() as? JetSimpleNameExpression)?.getReferencedNameElementType()
-                val op2 = (rc2.getCall().getCalleeExpression() as? JetSimpleNameExpression)?.getReferencedNameElementType()
+                val op1 = (rc1.getCall().getCalleeExpression() as? KtSimpleNameExpression)?.getReferencedNameElementType()
+                val op2 = (rc2.getCall().getCalleeExpression() as? KtSimpleNameExpression)?.getReferencedNameElementType()
 
                 return when {
                     op1 == op2 ->
                         true
-                    op1 == JetTokens.NOT_IN, op2 == JetTokens.NOT_IN ->
+                    op1 == KtTokens.NOT_IN, op2 == KtTokens.NOT_IN ->
                         false
-                    op1 == JetTokens.EXCLEQ, op2 == JetTokens.EXCLEQ ->
+                    op1 == KtTokens.EXCLEQ, op2 == KtTokens.EXCLEQ ->
                         false
                     op1 in OperatorConventions.COMPARISON_OPERATIONS, op2 in OperatorConventions.COMPARISON_OPERATIONS ->
                         false
@@ -252,7 +252,7 @@ public class JetPsiUnifier(
                                 null to null
                         }
 
-                val thisExpression = explicitReceiver?.getExpression() as? JetThisExpression
+                val thisExpression = explicitReceiver?.getExpression() as? KtThisExpression
                 if (implicitReceiver == null || thisExpression == null) return false
 
                 return matchDescriptors(
@@ -303,17 +303,17 @@ public class JetPsiUnifier(
             }
         }
 
-        private val JetElement.bindingContext: BindingContext get() = if (this in originalPattern) patternContext else targetContext
+        private val KtElement.bindingContext: BindingContext get() = if (this in originalPattern) patternContext else targetContext
 
-        private fun JetElement.getAdjustedResolvedCall(): ResolvedCall<*>? {
-            val rc = if (this is JetArrayAccessExpression) {
+        private fun KtElement.getAdjustedResolvedCall(): ResolvedCall<*>? {
+            val rc = if (this is KtArrayAccessExpression) {
                 bindingContext[BindingContext.INDEXED_LVALUE_GET, this]
             }
             else {
                 getResolvedCall(bindingContext)?.let {
                     when {
                         it !is VariableAsFunctionResolvedCall -> it
-                        this is JetSimpleNameExpression -> it.variableCall
+                        this is KtSimpleNameExpression -> it.variableCall
                         else -> it.functionCall
                     }
                 }
@@ -325,7 +325,7 @@ public class JetPsiUnifier(
             }
         }
 
-        private fun matchCalls(e1: JetElement, e2: JetElement): Status? {
+        private fun matchCalls(e1: KtElement, e2: KtElement): Status? {
             if (e1.shouldIgnoreResolvedCall() || e2.shouldIgnoreResolvedCall()) return null
 
             val resolvedCall1 = e1.getAdjustedResolvedCall()
@@ -353,12 +353,12 @@ public class JetPsiUnifier(
             }
         }
 
-        private fun JetTypeReference.getType(): JetType? {
+        private fun KtTypeReference.getType(): KtType? {
             val t = bindingContext[BindingContext.TYPE, this]
             return if (t == null || t.isError()) null else t
         }
 
-        private fun matchTypes(type1: JetType?, type2: JetType?): Status? {
+        private fun matchTypes(type1: KtType?, type2: KtType?): Status? {
             if (type1 != null && type2 != null) {
                 if (type1.isError() || type2.isError()) return null
                 if (TypeUtils.equalTypes(type1, type2)) return MATCHED
@@ -381,45 +381,45 @@ public class JetPsiUnifier(
             return if (type1 == null && type2 == null) null else UNMATCHED
         }
 
-        private fun matchTypes(types1: Collection<JetType>, types2: Collection<JetType>): Boolean {
-            fun sortTypes(types: Collection<JetType>) = types.sortedBy { DescriptorRenderer.DEBUG_TEXT.renderType(it) }
+        private fun matchTypes(types1: Collection<KtType>, types2: Collection<KtType>): Boolean {
+            fun sortTypes(types: Collection<KtType>) = types.sortedBy { DescriptorRenderer.DEBUG_TEXT.renderType(it) }
 
             if (types1.size() != types2.size()) return false
             return (sortTypes(types1) zip sortTypes(types2)).all { matchTypes(it.first, it.second) == MATCHED }
         }
 
-        private fun JetElement.shouldIgnoreResolvedCall(): Boolean {
+        private fun KtElement.shouldIgnoreResolvedCall(): Boolean {
             return when {
-                this is JetConstantExpression -> true
-                this is JetOperationReferenceExpression -> getReferencedNameElementType() == JetTokens.EXCLEXCL
-                this is JetIfExpression -> true
-                this is JetUnaryExpression -> when (getOperationReference().getReferencedNameElementType()) {
-                    JetTokens.EXCLEXCL, JetTokens.PLUSPLUS, JetTokens.MINUSMINUS -> true
+                this is KtConstantExpression -> true
+                this is KtOperationReferenceExpression -> getReferencedNameElementType() == KtTokens.EXCLEXCL
+                this is KtIfExpression -> true
+                this is KtUnaryExpression -> when (getOperationReference().getReferencedNameElementType()) {
+                    KtTokens.EXCLEXCL, KtTokens.PLUSPLUS, KtTokens.MINUSMINUS -> true
                     else -> false
                 }
-                this is JetBinaryExpression -> getOperationReference().getReferencedNameElementType() == JetTokens.ELVIS
+                this is KtBinaryExpression -> getOperationReference().getReferencedNameElementType() == KtTokens.ELVIS
                 else -> false
             }
         }
 
-        private fun JetBinaryExpression.matchComplexAssignmentWithSimple(simple: JetBinaryExpression): Status? {
+        private fun KtBinaryExpression.matchComplexAssignmentWithSimple(simple: KtBinaryExpression): Status? {
             return when {
                 doUnify(getLeft(), simple.getLeft()) == UNMATCHED -> UNMATCHED
                 else -> simple.getRight()?.let { matchCalls(this, it) } ?: UNMATCHED
             }
         }
 
-        private fun JetBinaryExpression.matchAssignment(e: JetElement): Status? {
-            val operationType = getOperationReference().getReferencedNameElementType() as JetToken
-            if (operationType == JetTokens.EQ) {
+        private fun KtBinaryExpression.matchAssignment(e: KtElement): Status? {
+            val operationType = getOperationReference().getReferencedNameElementType() as KtToken
+            if (operationType == KtTokens.EQ) {
                 if (e.shouldIgnoreResolvedCall()) return UNMATCHED
 
-                if (JetPsiUtil.isAssignment(e) && !JetPsiUtil.isOrdinaryAssignment(e)) {
-                    return (e as JetBinaryExpression).matchComplexAssignmentWithSimple(this)
+                if (KtPsiUtil.isAssignment(e) && !KtPsiUtil.isOrdinaryAssignment(e)) {
+                    return (e as KtBinaryExpression).matchComplexAssignmentWithSimple(this)
                 }
 
                 val lhs = getLeft()?.unwrap()
-                if (lhs !is JetArrayAccessExpression) return null
+                if (lhs !is KtArrayAccessExpression) return null
 
                 val setResolvedCall = bindingContext[BindingContext.INDEXED_LVALUE_SET, lhs]
                 val resolvedCallToMatch = e.getAdjustedResolvedCall()
@@ -433,10 +433,10 @@ public class JetPsiUnifier(
             val operationName = OperatorConventions.getNameForOperationSymbol(operationType)
             if (assignResolvedCall.getResultingDescriptor()?.getName() == operationName) return matchCalls(this, e)
 
-            return if (JetPsiUtil.isAssignment(e)) null else UNMATCHED
+            return if (KtPsiUtil.isAssignment(e)) null else UNMATCHED
         }
 
-        private fun matchLabelTargets(e1: JetLabelReferenceExpression, e2: JetLabelReferenceExpression): Status {
+        private fun matchLabelTargets(e1: KtLabelReferenceExpression, e2: KtLabelReferenceExpression): Status {
             val target1 = e1.bindingContext[BindingContext.LABEL_TARGET, e1]
             val target2 = e2.bindingContext[BindingContext.LABEL_TARGET, e2]
 
@@ -445,18 +445,18 @@ public class JetPsiUnifier(
 
         private fun PsiElement.isIncrement(): Boolean {
             val parent = getParent()
-            return parent is JetUnaryExpression
+            return parent is KtUnaryExpression
                    && this == parent.getOperationReference()
-                   && ((parent.getOperationToken() as JetToken) in OperatorConventions.INCREMENT_OPERATIONS)
+                   && ((parent.getOperationToken() as KtToken) in OperatorConventions.INCREMENT_OPERATIONS)
         }
 
-        private fun matchCallableReferences(e1: JetCallableReferenceExpression, e2: JetCallableReferenceExpression): Boolean {
+        private fun matchCallableReferences(e1: KtCallableReferenceExpression, e2: KtCallableReferenceExpression): Boolean {
             val d1 = e1.bindingContext[BindingContext.REFERENCE_TARGET, e1.getCallableReference()]
             val d2 = e2.bindingContext[BindingContext.REFERENCE_TARGET, e2.getCallableReference()]
             return matchDescriptors(d1, d2)
         }
 
-        private fun matchMultiDeclarations(e1: JetMultiDeclaration, e2: JetMultiDeclaration): Boolean {
+        private fun matchMultiDeclarations(e1: KtMultiDeclaration, e2: KtMultiDeclaration): Boolean {
             val entries1 = e1.getEntries()
             val entries2 = e2.getEntries()
             if (entries1.size() != entries2.size()) return false
@@ -489,13 +489,13 @@ public class JetPsiUnifier(
         }
 
         private fun matchCallables(
-                decl1: JetDeclaration,
-                decl2: JetDeclaration,
+                decl1: KtDeclaration,
+                decl2: KtDeclaration,
                 desc1: CallableDescriptor,
                 desc2: CallableDescriptor): Status? {
             fun needToCompareReturnTypes(): Boolean {
-                if (decl1 !is JetCallableDeclaration) return true
-                return decl1.getTypeReference() != null || (decl2 as JetCallableDeclaration).getTypeReference() != null
+                if (decl1 !is KtCallableDeclaration) return true
+                return decl1.getTypeReference() != null || (decl2 as KtCallableDeclaration).getTypeReference() != null
             }
 
             if (desc1 is VariableDescriptor && desc1.isVar() != (desc2 as VariableDescriptor).isVar()) return UNMATCHED
@@ -525,31 +525,31 @@ public class JetPsiUnifier(
             zippedParams.forEach { declarationPatternsToTargets.putValue(it.first, it.second) }
 
             return doUnify(
-                    (decl1 as? JetTypeParameterListOwner)?.getTypeParameters()?.toRange() ?: Empty,
-                    (decl2 as? JetTypeParameterListOwner)?.getTypeParameters()?.toRange() ?: Empty
+                    (decl1 as? KtTypeParameterListOwner)?.getTypeParameters()?.toRange() ?: Empty,
+                    (decl2 as? KtTypeParameterListOwner)?.getTypeParameters()?.toRange() ?: Empty
             ) and when (decl1) {
-                is JetDeclarationWithBody ->
-                    doUnify(decl1.getBodyExpression(), (decl2 as JetDeclarationWithBody).getBodyExpression())
+                is KtDeclarationWithBody ->
+                    doUnify(decl1.getBodyExpression(), (decl2 as KtDeclarationWithBody).getBodyExpression())
 
-                is JetWithExpressionInitializer ->
-                    doUnify(decl1.getInitializer(), (decl2 as JetWithExpressionInitializer).getInitializer())
+                is KtWithExpressionInitializer ->
+                    doUnify(decl1.getInitializer(), (decl2 as KtWithExpressionInitializer).getInitializer())
 
-                is JetParameter ->
-                    doUnify(decl1.getDefaultValue(), (decl2 as JetParameter).getDefaultValue())
+                is KtParameter ->
+                    doUnify(decl1.getDefaultValue(), (decl2 as KtParameter).getDefaultValue())
 
                 else ->
                     UNMATCHED
             }
         }
 
-        private fun JetDeclaration.isNameRelevant(): Boolean {
-            if (this is JetParameter && hasValOrVar()) return true
+        private fun KtDeclaration.isNameRelevant(): Boolean {
+            if (this is KtParameter && hasValOrVar()) return true
 
             val parent = getParent()
-            return parent is JetClassBody || parent is JetFile
+            return parent is KtClassBody || parent is KtFile
         }
 
-        private fun matchNames(decl1: JetDeclaration, decl2: JetDeclaration, desc1: DeclarationDescriptor, desc2: DeclarationDescriptor): Boolean {
+        private fun matchNames(decl1: KtDeclaration, decl2: KtDeclaration, desc1: DeclarationDescriptor, desc2: DeclarationDescriptor): Boolean {
             return (!decl1.isNameRelevant() && !decl2.isNameRelevant()) || desc1.getName() == desc2.getName()
         }
 
@@ -566,8 +566,8 @@ public class JetPsiUnifier(
         }
 
         private fun matchClasses(
-                decl1: JetClassOrObject,
-                decl2: JetClassOrObject,
+                decl1: KtClassOrObject,
+                decl2: KtClassOrObject,
                 desc1: ClassDescriptor,
                 desc2: ClassDescriptor): Status? {
             class OrderInfo<T>(
@@ -575,26 +575,26 @@ public class JetPsiUnifier(
                     val orderInsensitive: List<T>
             )
 
-            fun getMemberOrderInfo(cls: JetClassOrObject): OrderInfo<JetDeclaration> {
+            fun getMemberOrderInfo(cls: KtClassOrObject): OrderInfo<KtDeclaration> {
                 val (orderInsensitive, orderSensitive) = (cls.getBody()?.getDeclarations() ?: Collections.emptyList()).partition {
-                    it is JetClassOrObject || it is JetFunction
+                    it is KtClassOrObject || it is KtFunction
                 }
 
                 return OrderInfo(orderSensitive, orderInsensitive)
             }
 
-            fun getDelegationOrderInfo(cls: JetClassOrObject): OrderInfo<JetDelegationSpecifier> {
-                val (orderInsensitive, orderSensitive) = cls.getDelegationSpecifiers().partition { it is JetDelegatorToSuperClass }
+            fun getDelegationOrderInfo(cls: KtClassOrObject): OrderInfo<KtDelegationSpecifier> {
+                val (orderInsensitive, orderSensitive) = cls.getDelegationSpecifiers().partition { it is KtDelegatorToSuperClass }
                 return OrderInfo(orderSensitive, orderInsensitive)
             }
 
-            fun resolveAndSortDeclarationsByDescriptor(declarations: List<JetDeclaration>): List<Pair<JetDeclaration, DeclarationDescriptor?>> {
+            fun resolveAndSortDeclarationsByDescriptor(declarations: List<KtDeclaration>): List<Pair<KtDeclaration, DeclarationDescriptor?>> {
                 return declarations
                         .map { it to it.bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, it] }
                         .sortedBy { it.second?.let { IdeDescriptorRenderers.SOURCE_CODE.render(it) } ?: "" }
             }
 
-            fun sortDeclarationsByElementType(declarations: List<JetDeclaration>): List<JetDeclaration> {
+            fun sortDeclarationsByElementType(declarations: List<KtDeclaration>): List<KtDeclaration> {
                 return declarations.sortedBy { it.getNode()?.getElementType()?.getIndex() ?: -1 }
             }
 
@@ -621,8 +621,8 @@ public class JetPsiUnifier(
                 return UNMATCHED
             }
 
-            val status = doUnify((decl1 as? JetClass)?.getPrimaryConstructorParameterList(), (decl2 as? JetClass)?.getPrimaryConstructorParameterList()) and
-                    doUnify((decl1 as? JetClass)?.getTypeParameterList(), (decl2 as? JetClass)?.getTypeParameterList()) and
+            val status = doUnify((decl1 as? KtClass)?.getPrimaryConstructorParameterList(), (decl2 as? KtClass)?.getPrimaryConstructorParameterList()) and
+                    doUnify((decl1 as? KtClass)?.getTypeParameterList(), (decl2 as? KtClass)?.getTypeParameterList()) and
                     doUnify(delegationInfo1.orderSensitive.toRange(), delegationInfo2.orderSensitive.toRange())
             if (status == UNMATCHED) return UNMATCHED
 
@@ -653,8 +653,8 @@ public class JetPsiUnifier(
             return MATCHED
         }
 
-        private fun JetDeclaration.matchDeclarations(e: PsiElement): Status? {
-            if (e !is JetDeclaration) return UNMATCHED
+        private fun KtDeclaration.matchDeclarations(e: PsiElement): Status? {
+            if (e !is KtDeclaration) return UNMATCHED
 
             val desc1 = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, this]
             val desc2 = e.bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, e]
@@ -662,8 +662,8 @@ public class JetPsiUnifier(
         }
 
         private fun matchDeclarations(
-                decl1: JetDeclaration,
-                decl2: JetDeclaration,
+                decl1: KtDeclaration,
+                decl2: KtDeclaration,
                 desc1: DeclarationDescriptor?,
                 desc2: DeclarationDescriptor?): Status? {
             if (decl1.javaClass != decl2.javaClass) return UNMATCHED
@@ -673,13 +673,13 @@ public class JetPsiUnifier(
 
             declarationPatternsToTargets.putValue(desc1, desc2)
             val status = when (decl1) {
-                is JetDeclarationWithBody, is JetWithExpressionInitializer, is JetParameter ->
+                is KtDeclarationWithBody, is KtWithExpressionInitializer, is KtParameter ->
                     matchCallables(decl1, decl2, desc1 as CallableDescriptor, desc2 as CallableDescriptor)
 
-                is JetClassOrObject ->
-                    matchClasses(decl1, decl2 as JetClassOrObject, desc1 as ClassDescriptor, desc2 as ClassDescriptor)
+                is KtClassOrObject ->
+                    matchClasses(decl1, decl2 as KtClassOrObject, desc1 as ClassDescriptor, desc2 as ClassDescriptor)
 
-                is JetTypeParameter ->
+                is KtTypeParameter ->
                     matchTypeParameters(desc1 as TypeParameterDescriptor, desc2 as TypeParameterDescriptor)
 
                 else ->
@@ -694,37 +694,37 @@ public class JetPsiUnifier(
 
         private fun matchResolvedInfo(e1: PsiElement, e2: PsiElement): Status? {
             return when {
-                e1 !is JetElement, e2 !is JetElement ->
+                e1 !is KtElement, e2 !is KtElement ->
                     null
 
-                e1 is JetMultiDeclaration && e2 is JetMultiDeclaration ->
+                e1 is KtMultiDeclaration && e2 is KtMultiDeclaration ->
                     if (matchMultiDeclarations(e1, e2)) null else UNMATCHED
 
-                e1 is JetClassInitializer && e2 is JetClassInitializer ->
+                e1 is KtClassInitializer && e2 is KtClassInitializer ->
                     null
 
-                e1 is JetDeclaration ->
+                e1 is KtDeclaration ->
                     e1.matchDeclarations(e2)
 
-                e2 is JetDeclaration ->
+                e2 is KtDeclaration ->
                     e2.matchDeclarations(e1)
 
-                e1 is JetTypeReference && e2 is JetTypeReference ->
+                e1 is KtTypeReference && e2 is KtTypeReference ->
                     matchTypes(e1.getType(), e2.getType())
 
-                JetPsiUtil.isAssignment(e1) ->
-                    (e1 as JetBinaryExpression).matchAssignment(e2)
+                KtPsiUtil.isAssignment(e1) ->
+                    (e1 as KtBinaryExpression).matchAssignment(e2)
 
-                JetPsiUtil.isAssignment(e2) ->
-                    (e2 as JetBinaryExpression).matchAssignment(e1)
+                KtPsiUtil.isAssignment(e2) ->
+                    (e2 as KtBinaryExpression).matchAssignment(e1)
 
-                e1 is JetLabelReferenceExpression && e2 is JetLabelReferenceExpression ->
+                e1 is KtLabelReferenceExpression && e2 is KtLabelReferenceExpression ->
                     matchLabelTargets(e1, e2)
 
                 e1.isIncrement() != e2.isIncrement() ->
                     UNMATCHED
 
-                e1 is JetCallableReferenceExpression && e2 is JetCallableReferenceExpression ->
+                e1 is KtCallableReferenceExpression && e2 is KtCallableReferenceExpression ->
                     if (matchCallableReferences(e1, e2)) MATCHED else UNMATCHED
 
                 else ->
@@ -733,8 +733,8 @@ public class JetPsiUnifier(
         }
 
         private fun PsiElement.checkType(parameter: UnifierParameter): Boolean {
-            val targetElementType = (this as? JetExpression)?.let { it.bindingContext.getType(it) }
-            return targetElementType != null && JetTypeChecker.DEFAULT.isSubtypeOf(targetElementType, parameter.expectedType)
+            val targetElementType = (this as? KtExpression)?.let { it.bindingContext.getType(it) }
+            return targetElementType != null && KotlinTypeChecker.DEFAULT.isSubtypeOf(targetElementType, parameter.expectedType)
         }
 
         fun doUnify(target: JetPsiRange, pattern: JetPsiRange): Status {
@@ -750,19 +750,19 @@ public class JetPsiUnifier(
         private fun ASTNode.getChildrenRange(): JetPsiRange =
                 getChildren(null).map { it.getPsi() }.filterNotNull().toRange()
 
-        private fun PsiElement.unwrapWeakly(): JetElement? {
+        private fun PsiElement.unwrapWeakly(): KtElement? {
             return when {
-                this is JetReturnExpression -> getReturnedExpression()
-                this is JetProperty -> getInitializer()
-                JetPsiUtil.isOrdinaryAssignment(this) -> (this as JetBinaryExpression).getRight()
-                this is JetExpression && this !is JetDeclaration -> this
+                this is KtReturnExpression -> getReturnedExpression()
+                this is KtProperty -> getInitializer()
+                KtPsiUtil.isOrdinaryAssignment(this) -> (this as KtBinaryExpression).getRight()
+                this is KtExpression && this !is KtDeclaration -> this
                 else -> null
             }
         }
 
         private fun doUnifyWeakly(
-                targetElement: JetElement,
-                patternElement: JetElement
+                targetElement: KtElement,
+                patternElement: KtElement
         ): Status {
             if (!allowWeakMatches) return UNMATCHED
 
@@ -790,12 +790,12 @@ public class JetPsiUnifier(
             if (targetElementUnwrapped == null || patternElementUnwrapped == null) return UNMATCHED
 
             if (!checkEquivalence) {
-                val referencedPatternDescriptor = (patternElementUnwrapped as? JetReferenceExpression)?.let {
+                val referencedPatternDescriptor = (patternElementUnwrapped as? KtReferenceExpression)?.let {
                     it.bindingContext[BindingContext.REFERENCE_TARGET, it]
                 }
                 val parameter = descriptorToParameter[referencedPatternDescriptor]
                 if (parameter != null) {
-                    if (targetElementUnwrapped !is JetExpression) return UNMATCHED
+                    if (targetElementUnwrapped !is KtExpression) return UNMATCHED
                     if (!targetElementUnwrapped.checkType(parameter)) return UNMATCHED
 
                     val existingArgument = substitution[parameter]
@@ -822,7 +822,7 @@ public class JetPsiUnifier(
             val resolvedStatus = matchResolvedInfo(targetElementUnwrapped, patternElementUnwrapped)
             if (resolvedStatus == MATCHED) return resolvedStatus
 
-            if (targetElementUnwrapped is JetElement && patternElementUnwrapped is JetElement) {
+            if (targetElementUnwrapped is KtElement && patternElementUnwrapped is KtElement) {
                 val weakStatus = doUnifyWeakly(targetElementUnwrapped, patternElementUnwrapped)
                 if (weakStatus != UNMATCHED) return weakStatus
             }
@@ -846,15 +846,15 @@ public class JetPsiUnifier(
 
     private fun PsiElement.unwrap(): PsiElement? {
         return when (this) {
-            is JetExpression -> JetPsiUtil.deparenthesize(this)
-            is JetStringTemplateEntryWithExpression -> JetPsiUtil.deparenthesize(getExpression())
+            is KtExpression -> KtPsiUtil.deparenthesize(this)
+            is KtStringTemplateEntryWithExpression -> KtPsiUtil.deparenthesize(getExpression())
             else -> this
         }
     }
 
     private fun PsiElement.unquotedText(): String {
         val text = getText() ?: ""
-        return if (this is LeafPsiElement) JetPsiUtil.unquoteIdentifier(text) else text
+        return if (this is LeafPsiElement) KtPsiUtil.unquoteIdentifier(text) else text
     }
 
     public fun unify(target: JetPsiRange, pattern: JetPsiRange): UnificationResult {
diff --git a/idea/src/org/jetbrains/kotlin/idea/versions/UnsupportedAbiVersionNotificationPanelProvider.java b/idea/src/org/jetbrains/kotlin/idea/versions/UnsupportedAbiVersionNotificationPanelProvider.java
index 6f66f7b132f..661f5bd5f6f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/versions/UnsupportedAbiVersionNotificationPanelProvider.java
+++ b/idea/src/org/jetbrains/kotlin/idea/versions/UnsupportedAbiVersionNotificationPanelProvider.java
@@ -48,7 +48,7 @@ import com.intellij.ui.EditorNotifications;
 import com.intellij.util.messages.MessageBusConnection;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.idea.configuration.ConfigureKotlinInProjectUtils;
 import org.jetbrains.kotlin.idea.framework.JSLibraryStdPresentationProvider;
 import org.jetbrains.kotlin.idea.framework.JavaRuntimePresentationProvider;
@@ -196,7 +196,7 @@ public class UnsupportedAbiVersionNotificationPanelProvider extends EditorNotifi
         try {
             if (DumbService.isDumb(project)) return null;
             if (ApplicationManager.getApplication().isUnitTestMode()) return null;
-            if (file.getFileType() != JetFileType.INSTANCE) return null;
+            if (file.getFileType() != KotlinFileType.INSTANCE) return null;
 
             if (CompilerManager.getInstance(project).isExcludedFromCompilation(file)) return null;
 
diff --git a/idea/testData/findUsages/kotlin/companionObject/inContainingClass.0.kt b/idea/testData/findUsages/kotlin/companionObject/inContainingClass.0.kt
index 377107f20f5..535afd74f3c 100644
--- a/idea/testData/findUsages/kotlin/companionObject/inContainingClass.0.kt
+++ b/idea/testData/findUsages/kotlin/companionObject/inContainingClass.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetObjectDeclaration
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtObjectDeclaration
 // OPTIONS: usages
 class A() {
     init {
diff --git a/idea/testData/findUsages/kotlin/companionObject/javaUsage.0.kt b/idea/testData/findUsages/kotlin/companionObject/javaUsage.0.kt
index 38ad239f716..51f5c27fda8 100644
--- a/idea/testData/findUsages/kotlin/companionObject/javaUsage.0.kt
+++ b/idea/testData/findUsages/kotlin/companionObject/javaUsage.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetObjectDeclaration
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtObjectDeclaration
 // OPTIONS: usages
 
 import kotlin.platform.platformStatic
diff --git a/idea/testData/findUsages/kotlin/companionObject/named.0.kt b/idea/testData/findUsages/kotlin/companionObject/named.0.kt
index fba6d2414c4..f33d970177c 100644
--- a/idea/testData/findUsages/kotlin/companionObject/named.0.kt
+++ b/idea/testData/findUsages/kotlin/companionObject/named.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetObjectDeclaration
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtObjectDeclaration
 // OPTIONS: usages
 class Foo {
     companion object <caret>Bar {
diff --git a/idea/testData/findUsages/kotlin/companionObject/simple.0.kt b/idea/testData/findUsages/kotlin/companionObject/simple.0.kt
index 90ed9db2aa4..782d1d15ddd 100644
--- a/idea/testData/findUsages/kotlin/companionObject/simple.0.kt
+++ b/idea/testData/findUsages/kotlin/companionObject/simple.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetObjectDeclaration
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtObjectDeclaration
 // OPTIONS: usages
 class Foo {
     companion <caret>object {
diff --git a/idea/testData/findUsages/kotlin/conventions/compareTo.0.kt b/idea/testData/findUsages/kotlin/conventions/compareTo.0.kt
index 42d6322e81d..839d6de11ab 100644
--- a/idea/testData/findUsages/kotlin/conventions/compareTo.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/compareTo.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 
 class A(val n: Int) {
diff --git a/idea/testData/findUsages/kotlin/conventions/componentFunctions.0.kt b/idea/testData/findUsages/kotlin/conventions/componentFunctions.0.kt
index 22a717c0991..094beb83f7e 100644
--- a/idea/testData/findUsages/kotlin/conventions/componentFunctions.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/componentFunctions.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
 // OPTIONS: usages
 
 data class A(val <caret>n: Int, val s: String, val o: Any)
diff --git a/idea/testData/findUsages/kotlin/conventions/componentFunctionsByRef.0.kt b/idea/testData/findUsages/kotlin/conventions/componentFunctionsByRef.0.kt
index 124efce90d8..dff3f0caf1c 100644
--- a/idea/testData/findUsages/kotlin/conventions/componentFunctionsByRef.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/componentFunctionsByRef.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
 // OPTIONS: usages
 // FIND_BY_REF
 
diff --git a/idea/testData/findUsages/kotlin/conventions/contains.0.kt b/idea/testData/findUsages/kotlin/conventions/contains.0.kt
index 2e096a4fc57..f4469661bb0 100644
--- a/idea/testData/findUsages/kotlin/conventions/contains.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/contains.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 
 class A(val n: Int) {
diff --git a/idea/testData/findUsages/kotlin/conventions/equals.0.kt b/idea/testData/findUsages/kotlin/conventions/equals.0.kt
index 2d7b28dbe2b..6c87232f107 100644
--- a/idea/testData/findUsages/kotlin/conventions/equals.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/equals.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 
 class A(val n: Int) {
diff --git a/idea/testData/findUsages/kotlin/conventions/forIteration.0.kt b/idea/testData/findUsages/kotlin/conventions/forIteration.0.kt
index f0cc5d8c97c..5a8ddb79709 100644
--- a/idea/testData/findUsages/kotlin/conventions/forIteration.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/forIteration.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 
 class A<T: Any> {
diff --git a/idea/testData/findUsages/kotlin/conventions/get.0.kt b/idea/testData/findUsages/kotlin/conventions/get.0.kt
index a6951044aac..24b87bb7a12 100644
--- a/idea/testData/findUsages/kotlin/conventions/get.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/get.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 
 class B(val n: Int) {
diff --git a/idea/testData/findUsages/kotlin/conventions/getAsPropertyDelegate.0.kt b/idea/testData/findUsages/kotlin/conventions/getAsPropertyDelegate.0.kt
index 8547f26295b..d9ecd2a717d 100644
--- a/idea/testData/findUsages/kotlin/conventions/getAsPropertyDelegate.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/getAsPropertyDelegate.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 
 import kotlin.reflect.KProperty
diff --git a/idea/testData/findUsages/kotlin/conventions/identityEquals.0.kt b/idea/testData/findUsages/kotlin/conventions/identityEquals.0.kt
index aaba71deaab..6ebb323389a 100644
--- a/idea/testData/findUsages/kotlin/conventions/identityEquals.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/identityEquals.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 // FIND_BY_REF
 
diff --git a/idea/testData/findUsages/kotlin/conventions/inc.0.kt b/idea/testData/findUsages/kotlin/conventions/inc.0.kt
index fef2a21074e..de8b9f1d35f 100644
--- a/idea/testData/findUsages/kotlin/conventions/inc.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/inc.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 
 class A(val n: Int) {
diff --git a/idea/testData/findUsages/kotlin/conventions/invoke.0.kt b/idea/testData/findUsages/kotlin/conventions/invoke.0.kt
index 9b9e9833e31..d307d7bf214 100644
--- a/idea/testData/findUsages/kotlin/conventions/invoke.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/invoke.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 
 class B(val n: Int) {
diff --git a/idea/testData/findUsages/kotlin/conventions/plus.0.kt b/idea/testData/findUsages/kotlin/conventions/plus.0.kt
index cbce075136a..78f3dfd1a48 100644
--- a/idea/testData/findUsages/kotlin/conventions/plus.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/plus.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 
 class A(val n: Int) {
diff --git a/idea/testData/findUsages/kotlin/conventions/plusAssign.0.kt b/idea/testData/findUsages/kotlin/conventions/plusAssign.0.kt
index f2177c629e5..15ccb0d1313 100644
--- a/idea/testData/findUsages/kotlin/conventions/plusAssign.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/plusAssign.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 
 class A(var n: Int) {
diff --git a/idea/testData/findUsages/kotlin/conventions/propertyDelegatedFunction.0.kt b/idea/testData/findUsages/kotlin/conventions/propertyDelegatedFunction.0.kt
index 55fd9f3c7bc..4ff0b2a1b35 100644
--- a/idea/testData/findUsages/kotlin/conventions/propertyDelegatedFunction.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/propertyDelegatedFunction.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 
 import kotlin.reflect.KProperty
diff --git a/idea/testData/findUsages/kotlin/conventions/set.0.kt b/idea/testData/findUsages/kotlin/conventions/set.0.kt
index 18067582d84..fcea8f04ed0 100644
--- a/idea/testData/findUsages/kotlin/conventions/set.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/set.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 
 class B(val n: Int) {
diff --git a/idea/testData/findUsages/kotlin/conventions/setAsPropertyDelegate.0.kt b/idea/testData/findUsages/kotlin/conventions/setAsPropertyDelegate.0.kt
index ac0544d3c44..4df21687b6f 100644
--- a/idea/testData/findUsages/kotlin/conventions/setAsPropertyDelegate.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/setAsPropertyDelegate.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 
 import kotlin.reflect.KProperty
diff --git a/idea/testData/findUsages/kotlin/conventions/unaryMinus.0.kt b/idea/testData/findUsages/kotlin/conventions/unaryMinus.0.kt
index bc75948d46c..c10d2b4e499 100644
--- a/idea/testData/findUsages/kotlin/conventions/unaryMinus.0.kt
+++ b/idea/testData/findUsages/kotlin/conventions/unaryMinus.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 
 class A(val n: Int) {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/classUsedInPlainText.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/classUsedInPlainText.0.kt
index b8d4c1ed34d..341ae2c0bc6 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/classUsedInPlainText.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/classUsedInPlainText.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: textOccurrences
 package test
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/classUsedInTextAsRef.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/classUsedInTextAsRef.0.kt
index 5520e055a0b..48c18e7742e 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/classUsedInTextAsRef.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/classUsedInTextAsRef.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/javaClassAllUsages.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/javaClassAllUsages.0.kt
index a3bf5539051..2f3f0d98cdc 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/javaClassAllUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/javaClassAllUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 package testing
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/javaClassConstructorUsages.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/javaClassConstructorUsages.0.kt
index 88d3235a00b..c85b5d872b4 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/javaClassConstructorUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/javaClassConstructorUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: constructorUsages
 package testing
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/javaClassFunctionUsages1.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/javaClassFunctionUsages1.0.kt
index 5d7853e4497..17a9cd7cc20 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/javaClassFunctionUsages1.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/javaClassFunctionUsages1.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: functionUsages
 interface <caret>X {
     val a: String
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/javaClassFunctionUsages2.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/javaClassFunctionUsages2.0.kt
index 0ff4e915370..873c0431a26 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/javaClassFunctionUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/javaClassFunctionUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: functionUsages
 interface X {
     val a: String
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/javaClassNonConstructorUsages.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/javaClassNonConstructorUsages.0.kt
index 52dd7fa4da1..41ed3ec36cc 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/javaClassNonConstructorUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/javaClassNonConstructorUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages
 package testing
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/javaClassPropertyUsages1.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/javaClassPropertyUsages1.0.kt
index 3e7d8bba585..263e25b2b1b 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/javaClassPropertyUsages1.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/javaClassPropertyUsages1.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: propertyUsages
 interface <caret>X {
     val a: String
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/javaClassPropertyUsages2.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/javaClassPropertyUsages2.0.kt
index 1d1e982d9b7..d1a52a0ebf4 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/javaClassPropertyUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/javaClassPropertyUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: propertyUsages
 interface X {
     val a: String
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/javaClassSecondaryCtrUsages.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/javaClassSecondaryCtrUsages.0.kt
index e7fc88cf08c..6bbcc6e8a43 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/javaClassSecondaryCtrUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/javaClassSecondaryCtrUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 open class <caret>A {
     constructor() {}
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedClassUsages1.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedClassUsages1.0.kt
index 16ef0bbc6e5..19d7eabeb08 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedClassUsages1.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedClassUsages1.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 interface X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedClassUsages2.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedClassUsages2.0.kt
index cf578df3dd3..00585d9352c 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedClassUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedClassUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 interface <caret>X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedInterfaceUsages1.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedInterfaceUsages1.0.kt
index 55c3375450b..46d317d8345 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedInterfaceUsages1.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedInterfaceUsages1.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedInterfaces
 interface X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedInterfaceUsages2.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedInterfaceUsages2.0.kt
index d011ec25f37..65c66b43c3a 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedInterfaceUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/javaDerivedInterfaceUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedInterfaces
 interface <caret>X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsages.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsages.0.kt
index 475e8e9089d..aacbd84159c 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsages2.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsages2.0.kt
index 8ef951d2566..3e38a0f16bf 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsages3.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsages3.0.kt
index 54bfefd2dca..c84f9bb1104 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsages3.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsages3.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsagesNoImport.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsagesNoImport.0.kt
index 5577ef4b058..9c6119d076d 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsagesNoImport.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassAllUsagesNoImport.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages, skipImports
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassConstructorUsages.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassConstructorUsages.0.kt
index 2430258d3a4..ee3dbc26df3 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassConstructorUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassConstructorUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: constructorUsages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedAnonymousObjects.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedAnonymousObjects.0.kt
index ef31908cb6f..44715ee1616 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedAnonymousObjects.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedAnonymousObjects.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 open class <caret>A {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedAnonymousObjects.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedAnonymousObjects.1.kt
index 73fe03c437f..3d539e5d94f 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedAnonymousObjects.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedAnonymousObjects.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 
 fun foo() {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedClasses.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedClasses.0.kt
index 3920973b60d..ce3dcde4298 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedClasses.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedClasses.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 interface X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedClasses.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedClasses.1.kt
index fb35870d282..ec7b78feed4 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedClasses.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedClasses.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 open class B: A() {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerClasses.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerClasses.0.kt
index 3920973b60d..ce3dcde4298 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerClasses.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerClasses.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 interface X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerClasses.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerClasses.1.kt
index 80b8974d41e..4b622cd3377 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerClasses.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerClasses.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 class Outer {
     open class B: A() {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerObjects.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerObjects.0.kt
index ef31908cb6f..44715ee1616 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerObjects.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerObjects.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 open class <caret>A {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerObjects.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerObjects.1.kt
index 8d0e2b209c1..c3218cd698e 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerObjects.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedInnerObjects.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 class Outer {
     interface Z: A {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalClasses.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalClasses.0.kt
index 3920973b60d..ce3dcde4298 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalClasses.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalClasses.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 interface X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalClasses.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalClasses.1.kt
index 06c5fa971da..8aa20c9c5a8 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalClasses.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalClasses.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 
 fun foo() {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalObjects.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalObjects.0.kt
index ef31908cb6f..44715ee1616 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalObjects.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalObjects.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 open class <caret>A {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalObjects.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalObjects.1.kt
index 286bef41020..8a8f61cd5c0 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalObjects.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalObjects.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 
 fun foo() {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalTraits.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalTraits.0.kt
index d5a620572c7..a9c34385c06 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalTraits.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalTraits.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedInterfaces
 interface X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalTraits.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalTraits.1.kt
index 31cef5ad423..dbe2eb0cb7d 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalTraits.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedLocalTraits.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedInterfaces
 
 fun foo() {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedObjects.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedObjects.0.kt
index ef31908cb6f..44715ee1616 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedObjects.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedObjects.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 open class <caret>A {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedObjects.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedObjects.1.kt
index b8196903dbd..2c2d13a848d 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedObjects.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedObjects.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 interface Z: A {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedTraits.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedTraits.0.kt
index d5a620572c7..a9c34385c06 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedTraits.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedTraits.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedInterfaces
 interface X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedTraits.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedTraits.1.kt
index de17d05a4c4..22d10f6a952 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedTraits.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassDerivedTraits.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedInterfaces
 open class B: A() {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassFunctionUsages1.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassFunctionUsages1.0.kt
index 5d7853e4497..17a9cd7cc20 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassFunctionUsages1.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassFunctionUsages1.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: functionUsages
 interface <caret>X {
     val a: String
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassFunctionUsages2.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassFunctionUsages2.0.kt
index 0ff4e915370..873c0431a26 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassFunctionUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassFunctionUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: functionUsages
 interface X {
     val a: String
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassNonConstructorUsages.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassNonConstructorUsages.0.kt
index 5520e055a0b..48c18e7742e 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassNonConstructorUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassNonConstructorUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassPropertyUsages1.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassPropertyUsages1.0.kt
index 3e7d8bba585..263e25b2b1b 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassPropertyUsages1.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassPropertyUsages1.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: propertyUsages
 interface <caret>X {
     val a: String
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassPropertyUsages2.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassPropertyUsages2.0.kt
index 589ee8fe753..730da298eb9 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassPropertyUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassPropertyUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: propertyUsages
 interface X {
     val a: String
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassSecondaryCtorUsages.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassSecondaryCtorUsages.0.kt
index 42595046a08..4e4f47a30a1 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassSecondaryCtorUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinClassSecondaryCtorUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 open class <caret>A {
     constructor() {}
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinDeeplyNestedClassAllUsages.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinDeeplyNestedClassAllUsages.0.kt
index eaf3c9f9af6..ef6b4d86d86 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinDeeplyNestedClassAllUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinDeeplyNestedClassAllUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 package a
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinInnerClassAllUsages.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinInnerClassAllUsages.0.kt
index 049c7988ff5..7b1d8d49519 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinInnerClassAllUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinInnerClassAllUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 package a
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedAnonymousObjects.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedAnonymousObjects.0.kt
index a4f6cffc80a..fd6a082d9c2 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedAnonymousObjects.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedAnonymousObjects.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 fun foo() {
     open class <caret>A
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedLocalClasses.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedLocalClasses.0.kt
index 1180de75594..cd0b6cad5f3 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedLocalClasses.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedLocalClasses.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 fun foo() {
     open class <caret>A
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedLocalObjects.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedLocalObjects.0.kt
index 132b0d44622..fe40cd43a8a 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedLocalObjects.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedLocalObjects.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 fun foo() {
     open class <caret>A
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedLocalTraits.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedLocalTraits.0.kt
index e3c8578657f..4ded0be28ad 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedLocalTraits.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassDerivedLocalTraits.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedInterfaces
 fun foo() {
     open class <caret>A
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassUsages1.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassUsages1.0.kt
index edbae25973a..db92bf049db 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassUsages1.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassUsages1.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 fun foo(): Any {
     class <caret>Bar
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassUsages2.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassUsages2.0.kt
index 5266f7f450b..26fc321206e 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinLocalClassUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 fun foo(): Any {
     if (false) {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinNestedClassAllUsages.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinNestedClassAllUsages.0.kt
index ca283738b90..aea41abc71f 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinNestedClassAllUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinNestedClassAllUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 package a
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinPrivateClassUsages.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinPrivateClassUsages.0.kt
index 4f1ee35448e..b407a59087e 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinPrivateClassUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinPrivateClassUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedAnonymousObjects.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedAnonymousObjects.0.kt
index 691ee8ca09b..6674ba27a37 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedAnonymousObjects.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedAnonymousObjects.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 interface <caret>X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedAnonymousObjects.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedAnonymousObjects.1.kt
index e64c76fc7d6..7dac6e308b5 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedAnonymousObjects.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedAnonymousObjects.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 
 fun foo() {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedClasses.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedClasses.0.kt
index a1bce719774..f500eafe97c 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedClasses.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedClasses.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 interface <caret>X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedClasses.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedClasses.1.kt
index fb35870d282..ec7b78feed4 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedClasses.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedClasses.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 open class B: A() {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerClasses.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerClasses.0.kt
index a1bce719774..f500eafe97c 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerClasses.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerClasses.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 interface <caret>X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerClasses.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerClasses.1.kt
index b1e9f596491..edcc221be6a 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerClasses.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerClasses.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 class Outer {
     open class B: A() {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerObjects.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerObjects.0.kt
index a1bce719774..f500eafe97c 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerObjects.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerObjects.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 interface <caret>X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerObjects.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerObjects.1.kt
index a83d521f267..44d921d3953 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerObjects.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedInnerObjects.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 class Outer {
     object O1: A() {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalClasses.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalClasses.0.kt
index a1bce719774..f500eafe97c 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalClasses.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalClasses.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 interface <caret>X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalClasses.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalClasses.1.kt
index 06c5fa971da..8aa20c9c5a8 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalClasses.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalClasses.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 
 fun foo() {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalObjects.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalObjects.0.kt
index 691ee8ca09b..6674ba27a37 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalObjects.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalObjects.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 interface <caret>X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalObjects.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalObjects.1.kt
index 9e10ac453b1..e12912c9d31 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalObjects.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalObjects.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 
 fun foo() {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalTraits.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalTraits.0.kt
index 0f8bb641b28..07d39824ef9 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalTraits.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalTraits.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedInterfaces
 interface <caret>X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalTraits.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalTraits.1.kt
index 825d436fb65..132c4dce4a6 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalTraits.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedLocalTraits.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedInterfaces
 
 fun foo() {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedObjects.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedObjects.0.kt
index a1bce719774..f500eafe97c 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedObjects.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedObjects.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 interface <caret>X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedObjects.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedObjects.1.kt
index b7b553c1857..cb31b54bc79 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedObjects.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedObjects.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedClasses
 object O1: A() {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedTraits.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedTraits.0.kt
index 82cdcdbdef9..96698320776 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedTraits.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedTraits.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedInterfaces
 interface <caret>X {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedTraits.1.kt b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedTraits.1.kt
index de17d05a4c4..22d10f6a952 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedTraits.1.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/kotlinTraitDerivedTraits.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: derivedInterfaces
 open class B: A() {
 
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/localAndNonLocalClass.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/localAndNonLocalClass.0.kt
index 34cd94d538e..31575b8bdc5 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/localAndNonLocalClass.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/localAndNonLocalClass.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 class <caret>C {
     init {
diff --git a/idea/testData/findUsages/kotlin/findClassUsages/primaryConstructorWithDefaultParams.0.kt b/idea/testData/findUsages/kotlin/findClassUsages/primaryConstructorWithDefaultParams.0.kt
index 4971773a259..8006041c1dd 100644
--- a/idea/testData/findUsages/kotlin/findClassUsages/primaryConstructorWithDefaultParams.0.kt
+++ b/idea/testData/findUsages/kotlin/findClassUsages/primaryConstructorWithDefaultParams.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 class <caret>A(a: Int = 1)
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/enumFunctionUsages.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/enumFunctionUsages.0.kt
index dd966f172a7..e59a4e1652f 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/enumFunctionUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/enumFunctionUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 enum class E {
     O
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/functionUsedInPlainText.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/functionUsedInPlainText.0.kt
index ef36fc25079..a9cf129750f 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/functionUsedInPlainText.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/functionUsedInPlainText.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: textOccurrences
 package test
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/javaAndKotlinOverrides.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/javaAndKotlinOverrides.0.kt
index 715ff1f9fa6..a65c0477320 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/javaAndKotlinOverrides.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/javaAndKotlinOverrides.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: overrides
 open class A<T> {
     open fun <caret>foo(t: T) {
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/javaMethodUsages.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/javaMethodUsages.0.kt
index e8944947831..036d845f641 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/javaMethodUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/javaMethodUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 package testing
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinInternalMethodUsages.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinInternalMethodUsages.0.kt
index 0aa36497805..9edf574eabb 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinInternalMethodUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinInternalMethodUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinLocalMethodUsages1.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinLocalMethodUsages1.0.kt
index 6800f75f480..bf38a8062c3 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinLocalMethodUsages1.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinLocalMethodUsages1.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 fun foo() {
     fun <caret>bar() {
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinLocalMethodUsages2.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinLocalMethodUsages2.0.kt
index 650bc2c5a85..7e3b437913a 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinLocalMethodUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinLocalMethodUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 fun foo() {
     if (true) {
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinMethodUsages.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinMethodUsages.0.kt
index 3cb5558648f..e9361394561 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinMethodUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinMethodUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinMultiRefInImport.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinMultiRefInImport.0.kt
index 739b05bcc55..53f32c47b6e 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinMultiRefInImport.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinMultiRefInImport.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinMultiRefInImport.1.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinMultiRefInImport.1.kt
index d07782176d5..5751e65ec54 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinMultiRefInImport.1.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinMultiRefInImport.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 package client
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinNestedClassMethodUsages.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinNestedClassMethodUsages.0.kt
index bfa26eb0928..f968bc3c2f4 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinNestedClassMethodUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinNestedClassMethodUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 package a
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinOverloadAndExtensionUsages.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinOverloadAndExtensionUsages.0.kt
index 74ce2fb0a99..5b3f948f010 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinOverloadAndExtensionUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinOverloadAndExtensionUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: overloadUsages
 interface X<T> {
 }
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinOverloadAndExtensionUsages2.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinOverloadAndExtensionUsages2.0.kt
index f3b91b71101..49589960700 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinOverloadAndExtensionUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinOverloadAndExtensionUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: overloadUsages
 interface X {
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinPrivateMethodUsages.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinPrivateMethodUsages.0.kt
index cecfabc3ec8..cd8880b5850 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinPrivateMethodUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinPrivateMethodUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsages.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsages.0.kt
index 880b017510c..54d91660179 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsagesMultifile.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsagesMultifile.0.kt
index cd5a23a8f4c..309d2b4c262 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsagesMultifile.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsagesMultifile.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 @file:[JvmName("RequestProcessor") JvmMultifileClass]
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsagesNoImport.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsagesNoImport.0.kt
index 18c490e51b2..ca8312dda85 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsagesNoImport.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsagesNoImport.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages, skipImports
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsagesWithRenamedFile.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsagesWithRenamedFile.0.kt
index da3423a7a0e..bda2ef20787 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsagesWithRenamedFile.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTopLevelMethodUsagesWithRenamedFile.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 @file:JvmName("RequestProcessor")
 package server
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTraitImplThroughDelegate.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTraitImplThroughDelegate.0.kt
index 2b08de2a0a6..cedd1a2e88b 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTraitImplThroughDelegate.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTraitImplThroughDelegate.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages, skipImports
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTraitNoImplThroughDelegate.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTraitNoImplThroughDelegate.0.kt
index 8451db06d0b..b69ac36b4f0 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTraitNoImplThroughDelegate.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/kotlinTraitNoImplThroughDelegate.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages, skipImports
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/localClassMember.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/localClassMember.0.kt
index e42f9973b0d..da88c77b032 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/localClassMember.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/localClassMember.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 package anonymousUnused
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionDeepMember.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionDeepMember.0.kt
index d73c6e80b94..328c450adb4 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionDeepMember.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionDeepMember.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 package anonymousUnused
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionMember.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionMember.0.kt
index 9e3ce698382..3a137a48d9f 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionMember.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionMember.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 package anonymousUnused
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionMember2.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionMember2.0.kt
index e55c4687fa0..d844354bd4d 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionMember2.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionMember2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 package anonymousUnused
 
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionMemberInClass.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionMemberInClass.0.kt
index 1d5ae207e0c..d675c8742b9 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionMemberInClass.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/objectExpressionMemberInClass.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 class Foo {
     private val localObject = object : Any() {
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/synthesizedFunction.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/synthesizedFunction.0.kt
index 052faf3abbe..6a302c48677 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/synthesizedFunction.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/synthesizedFunction.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages, skipImports
 
 open data class A(val a: Int)
diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/usagesOfBaseForFunction.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/usagesOfBaseForFunction.0.kt
index 07588e122d7..6b454b2fb68 100644
--- a/idea/testData/findUsages/kotlin/findFunctionUsages/usagesOfBaseForFunction.0.kt
+++ b/idea/testData/findUsages/kotlin/findFunctionUsages/usagesOfBaseForFunction.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages, skipImports
 
 interface A {
diff --git a/idea/testData/findUsages/kotlin/findObjectUsages/javaObjectUsages.0.kt b/idea/testData/findUsages/kotlin/findObjectUsages/javaObjectUsages.0.kt
index cb27103460c..b8bec636e17 100644
--- a/idea/testData/findUsages/kotlin/findObjectUsages/javaObjectUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findObjectUsages/javaObjectUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetObjectDeclaration
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtObjectDeclaration
 package server
 
 object <caret>O {
diff --git a/idea/testData/findUsages/kotlin/findObjectUsages/kotlinLocalObjectUsages1.0.kt b/idea/testData/findUsages/kotlin/findObjectUsages/kotlinLocalObjectUsages1.0.kt
index 0c9c9e6d354..d6d29907f4e 100644
--- a/idea/testData/findUsages/kotlin/findObjectUsages/kotlinLocalObjectUsages1.0.kt
+++ b/idea/testData/findUsages/kotlin/findObjectUsages/kotlinLocalObjectUsages1.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetObjectDeclaration
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtObjectDeclaration
 // OPTIONS: usages
 fun foo(): Any {
     object <caret>Bar
diff --git a/idea/testData/findUsages/kotlin/findObjectUsages/kotlinLocalObjectUsages2.0.kt b/idea/testData/findUsages/kotlin/findObjectUsages/kotlinLocalObjectUsages2.0.kt
index b945e44b13b..0eb0af88178 100644
--- a/idea/testData/findUsages/kotlin/findObjectUsages/kotlinLocalObjectUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findObjectUsages/kotlinLocalObjectUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetObjectDeclaration
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtObjectDeclaration
 // OPTIONS: usages
 fun foo(): Any {
     if (true) {
diff --git a/idea/testData/findUsages/kotlin/findObjectUsages/kotlinNestedObjectUsages.0.kt b/idea/testData/findUsages/kotlin/findObjectUsages/kotlinNestedObjectUsages.0.kt
index 05c05303726..0b80be5a931 100644
--- a/idea/testData/findUsages/kotlin/findObjectUsages/kotlinNestedObjectUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findObjectUsages/kotlinNestedObjectUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetObjectDeclaration
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtObjectDeclaration
 package a
 
 class A {
diff --git a/idea/testData/findUsages/kotlin/findObjectUsages/kotlinObjectUsages.0.kt b/idea/testData/findUsages/kotlin/findObjectUsages/kotlinObjectUsages.0.kt
index cb27103460c..b8bec636e17 100644
--- a/idea/testData/findUsages/kotlin/findObjectUsages/kotlinObjectUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findObjectUsages/kotlinObjectUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetObjectDeclaration
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtObjectDeclaration
 package server
 
 object <caret>O {
diff --git a/idea/testData/findUsages/kotlin/findObjectUsages/kotlinPrivateObjectUsages.0.kt b/idea/testData/findUsages/kotlin/findObjectUsages/kotlinPrivateObjectUsages.0.kt
index 3c07ced5e35..d72e986ea3c 100644
--- a/idea/testData/findUsages/kotlin/findObjectUsages/kotlinPrivateObjectUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findObjectUsages/kotlinPrivateObjectUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetObjectDeclaration
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtObjectDeclaration
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findParameterUsages/kotlinComponentFunctionParameterUsages.0.kt b/idea/testData/findUsages/kotlin/findParameterUsages/kotlinComponentFunctionParameterUsages.0.kt
index 599a94134d7..da0ed314338 100644
--- a/idea/testData/findUsages/kotlin/findParameterUsages/kotlinComponentFunctionParameterUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findParameterUsages/kotlinComponentFunctionParameterUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
 // OPTIONS: usages
 package test
 
diff --git a/idea/testData/findUsages/kotlin/findParameterUsages/kotlinConstructorParameterUsages.0.kt b/idea/testData/findUsages/kotlin/findParameterUsages/kotlinConstructorParameterUsages.0.kt
index 10a3916d8c7..df622db6271 100644
--- a/idea/testData/findUsages/kotlin/findParameterUsages/kotlinConstructorParameterUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findParameterUsages/kotlinConstructorParameterUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
 // OPTIONS: usages
 open class A<T>(<caret>foo: T) {
     init {
diff --git a/idea/testData/findUsages/kotlin/findParameterUsages/kotlinFunctionParameterUsages.0.kt b/idea/testData/findUsages/kotlin/findParameterUsages/kotlinFunctionParameterUsages.0.kt
index e64b7def8f8..d52013e5f85 100644
--- a/idea/testData/findUsages/kotlin/findParameterUsages/kotlinFunctionParameterUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findParameterUsages/kotlinFunctionParameterUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
 // OPTIONS: usages
 fun foo<T>(<caret>t: T): T {
     println(t)
diff --git a/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/missingName.0.kt b/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/missingName.0.kt
index b46ae97c372..950506dbc31 100644
--- a/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/missingName.0.kt
+++ b/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/missingName.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetPrimaryConstructor
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtPrimaryConstructor
 // OPTIONS: usages
 class <caret>() {
 
diff --git a/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/primaryConstructorByRef.0.kt b/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/primaryConstructorByRef.0.kt
index 3f0b1f6384f..a98739dfb0b 100644
--- a/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/primaryConstructorByRef.0.kt
+++ b/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/primaryConstructorByRef.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetPrimaryConstructor
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtPrimaryConstructor
 // OPTIONS: usages
 // FIND_BY_REF
 open class A (n: Int) {
diff --git a/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/primaryConstructorNoKeyword.0.kt b/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/primaryConstructorNoKeyword.0.kt
index 22fe97c3149..fb6836e9cc2 100644
--- a/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/primaryConstructorNoKeyword.0.kt
+++ b/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/primaryConstructorNoKeyword.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetPrimaryConstructor
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtPrimaryConstructor
 // OPTIONS: usages
 open class A <caret>(n: Int) {
     constructor(): this(1)
diff --git a/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/primaryConstructorWithKeyword.0.kt b/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/primaryConstructorWithKeyword.0.kt
index 67e00ac0e79..199c7660e7b 100644
--- a/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/primaryConstructorWithKeyword.0.kt
+++ b/idea/testData/findUsages/kotlin/findPrimaryConstructorUsages/primaryConstructorWithKeyword.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetPrimaryConstructor
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtPrimaryConstructor
 // OPTIONS: usages
 open class A <caret>constructor(n: Int) {
     constructor(): this(1)
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/javaAndKotlinOverrides.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/javaAndKotlinOverrides.0.kt
index 06a1140ff5d..22e9856c920 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/javaAndKotlinOverrides.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/javaAndKotlinOverrides.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: overrides
 open class A<T>(t: T) {
     open var <caret>foo: T = t
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/javaAndKotlinOverrides2.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/javaAndKotlinOverrides2.0.kt
index dec97ad4ea6..3f4a6455ff5 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/javaAndKotlinOverrides2.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/javaAndKotlinOverrides2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
 // OPTIONS: overrides
 open class A<T>(open var <caret>foo: T)
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/javaClassObjectPropertyUsages.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/javaClassObjectPropertyUsages.0.kt
index a94b31fed12..7f74195ea5a 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/javaClassObjectPropertyUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/javaClassObjectPropertyUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyReadUsages.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyReadUsages.0.kt
index 04f9241eccf..4b7f3a11fc2 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyReadUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyReadUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages, skipWrite
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyReadUsages2.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyReadUsages2.0.kt
index 73f04312213..edbb3a33722 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyReadUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyReadUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
 // OPTIONS: usages, skipWrite
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyUsages.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyUsages.0.kt
index c2ed613fcce..a722562f00e 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyUsages2.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyUsages2.0.kt
index 4e69d05e08d..54a8e62b431 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyWriteUsages.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyWriteUsages.0.kt
index b1d37e8d8c9..aac16f02920 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyWriteUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyWriteUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages, skipRead
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyWriteUsages2.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyWriteUsages2.0.kt
index 71df698ff11..35d9bd52f27 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyWriteUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/javaPropertyWriteUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
 // OPTIONS: usages, skipRead
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinClassObjectPropertyUsage.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinClassObjectPropertyUsage.0.kt
index 3b367f90916..00a2ce19eb4 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinClassObjectPropertyUsage.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinClassObjectPropertyUsage.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinLocalPropertyUsages1.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinLocalPropertyUsages1.0.kt
index 67dafb44b8a..fd8d54d5cd8 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinLocalPropertyUsages1.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinLocalPropertyUsages1.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 fun foo(): String {
     val <caret>bar = ""
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinLocalPropertyUsages2.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinLocalPropertyUsages2.0.kt
index ec7840dbcef..acb44125ed6 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinLocalPropertyUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinLocalPropertyUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 fun foo(): String {
     if (true) {
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinMultiRefInImport.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinMultiRefInImport.0.kt
index 873995dd978..4c33d830331 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinMultiRefInImport.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinMultiRefInImport.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinMultiRefInImport.1.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinMultiRefInImport.1.kt
index a7ff070cb68..c03d022751e 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinMultiRefInImport.1.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinMultiRefInImport.1.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 package client
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinNestedClassPropertyUsages.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinNestedClassPropertyUsages.0.kt
index 5c4e976a2cd..cfe3d95c4b6 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinNestedClassPropertyUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinNestedClassPropertyUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 package a
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyInClassObjectUsages.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyInClassObjectUsages.0.kt
index 9cbb8ae4021..b8a9f8a7ffd 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyInClassObjectUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyInClassObjectUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 class Outer {
     val x = Outer.t
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages.0.kt
index ababc1dbb3c..d843e421ecc 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.0.kt
index ad25821bdad..1a048ee0c96 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyReadUsages.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyReadUsages.0.kt
index 384ef238ce9..e785bd898e1 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyReadUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyReadUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages, skipWrite
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyReadUsages2.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyReadUsages2.0.kt
index 651ac62a989..c24fe77c808 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyReadUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyReadUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
 // OPTIONS: usages, skipWrite
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyUsages.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyUsages.0.kt
index b3660165749..71050231b1c 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyUsages2.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyUsages2.0.kt
index f2279f7e312..b29fa87bc49 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyWriteUsages.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyWriteUsages.0.kt
index 650e2abf5cc..cf7be06c41f 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyWriteUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyWriteUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages, skipRead
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyWriteUsages2.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyWriteUsages2.0.kt
index 4c476a2692d..b1bf6979c06 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyWriteUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPropertyWriteUsages2.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
 // OPTIONS: usages, skipRead
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinTopLevelPropertyUsages.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinTopLevelPropertyUsages.0.kt
index df5f9d28091..16dfefe7ed2 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinTopLevelPropertyUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinTopLevelPropertyUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 package server
 
diff --git a/idea/testData/findUsages/kotlin/findSecondaryConstructorUsages/defaultSecondaryConstructor.0.kt b/idea/testData/findUsages/kotlin/findSecondaryConstructorUsages/defaultSecondaryConstructor.0.kt
index 436b0530019..2db8c9d6e23 100644
--- a/idea/testData/findUsages/kotlin/findSecondaryConstructorUsages/defaultSecondaryConstructor.0.kt
+++ b/idea/testData/findUsages/kotlin/findSecondaryConstructorUsages/defaultSecondaryConstructor.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetSecondaryConstructor
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtSecondaryConstructor
 // OPTIONS: usages
 open class B {
     <caret>constructor() {
diff --git a/idea/testData/findUsages/kotlin/findSecondaryConstructorUsages/secondaryConstructor.0.kt b/idea/testData/findUsages/kotlin/findSecondaryConstructorUsages/secondaryConstructor.0.kt
index 657899f8751..d1c5ebf08ec 100644
--- a/idea/testData/findUsages/kotlin/findSecondaryConstructorUsages/secondaryConstructor.0.kt
+++ b/idea/testData/findUsages/kotlin/findSecondaryConstructorUsages/secondaryConstructor.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetSecondaryConstructor
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtSecondaryConstructor
 // OPTIONS: usages
 open class B {
     constructor(): this("") {
diff --git a/idea/testData/findUsages/kotlin/findTypeParameterUsages/kotlinClassTypeParameterUsages.0.kt b/idea/testData/findUsages/kotlin/findTypeParameterUsages/kotlinClassTypeParameterUsages.0.kt
index bffb0bd1cd1..b2008399212 100644
--- a/idea/testData/findUsages/kotlin/findTypeParameterUsages/kotlinClassTypeParameterUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findTypeParameterUsages/kotlinClassTypeParameterUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetTypeParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtTypeParameter
 // OPTIONS: usages
 open class A<<caret>T>(foo: T, list: List<T>) {
     init {
diff --git a/idea/testData/findUsages/kotlin/findTypeParameterUsages/kotlinFunctionTypeParameterUsages.0.kt b/idea/testData/findUsages/kotlin/findTypeParameterUsages/kotlinFunctionTypeParameterUsages.0.kt
index 2ed44f62270..1b50163c3b0 100644
--- a/idea/testData/findUsages/kotlin/findTypeParameterUsages/kotlinFunctionTypeParameterUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findTypeParameterUsages/kotlinFunctionTypeParameterUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetTypeParameter
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtTypeParameter
 // OPTIONS: usages
 fun <<caret>T> T.foo(t: T, list: List<T>): T {
     return t
diff --git a/idea/testData/findUsages/kotlin/findWithFilteringImports/findWithFilteringImports.0.kt b/idea/testData/findUsages/kotlin/findWithFilteringImports/findWithFilteringImports.0.kt
index 12bcd662319..a38ce981d61 100644
--- a/idea/testData/findUsages/kotlin/findWithFilteringImports/findWithFilteringImports.0.kt
+++ b/idea/testData/findUsages/kotlin/findWithFilteringImports/findWithFilteringImports.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // FILTERING_RULES: org.jetbrains.kotlin.idea.findUsages.JetImportFilteringRule
 // OPTIONS: usages, constructorUsages
 
diff --git a/idea/testData/findUsages/kotlin/findWithStructuralGrouping/kotlinClassAllUsages.0.kt b/idea/testData/findUsages/kotlin/findWithStructuralGrouping/kotlinClassAllUsages.0.kt
index b9dcb421722..0b865ac56ac 100644
--- a/idea/testData/findUsages/kotlin/findWithStructuralGrouping/kotlinClassAllUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findWithStructuralGrouping/kotlinClassAllUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // GROUPING_RULES: org.jetbrains.kotlin.idea.findUsages.KotlinDeclarationGroupRuleProvider$KotlinDeclarationGroupingRule
 // OPTIONS: usages, constructorUsages
 package server
diff --git a/idea/testData/findUsages/kotlin/findWithStructuralGrouping/kotlinMethodUsages.0.kt b/idea/testData/findUsages/kotlin/findWithStructuralGrouping/kotlinMethodUsages.0.kt
index b0171305122..b407a80b223 100644
--- a/idea/testData/findUsages/kotlin/findWithStructuralGrouping/kotlinMethodUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findWithStructuralGrouping/kotlinMethodUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // GROUPING_RULES: org.jetbrains.kotlin.idea.findUsages.KotlinDeclarationGroupRuleProvider$KotlinDeclarationGroupingRule
 // OPTIONS: usages
 package server
diff --git a/idea/testData/findUsages/kotlin/findWithStructuralGrouping/kotlinPropertyUsages.0.kt b/idea/testData/findUsages/kotlin/findWithStructuralGrouping/kotlinPropertyUsages.0.kt
index 96be0452c77..94779b5c4f3 100644
--- a/idea/testData/findUsages/kotlin/findWithStructuralGrouping/kotlinPropertyUsages.0.kt
+++ b/idea/testData/findUsages/kotlin/findWithStructuralGrouping/kotlinPropertyUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // GROUPING_RULES: org.jetbrains.kotlin.idea.findUsages.KotlinDeclarationGroupRuleProvider$KotlinDeclarationGroupingRule
 // OPTIONS: usages
 package server
diff --git a/idea/testData/findUsages/kotlin/unresolvedAnnotation/unresolvedAnnotation.0.kt b/idea/testData/findUsages/kotlin/unresolvedAnnotation/unresolvedAnnotation.0.kt
index ce90140c027..11e6d7ff85b 100644
--- a/idea/testData/findUsages/kotlin/unresolvedAnnotation/unresolvedAnnotation.0.kt
+++ b/idea/testData/findUsages/kotlin/unresolvedAnnotation/unresolvedAnnotation.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 open class <caret>Foo {
     vv open val foo = 1
diff --git a/idea/testData/findUsages/kotlin/variable/plusAssignFun.0.kt b/idea/testData/findUsages/kotlin/variable/plusAssignFun.0.kt
index 471e235d1d3..2758a8d1fe4 100644
--- a/idea/testData/findUsages/kotlin/variable/plusAssignFun.0.kt
+++ b/idea/testData/findUsages/kotlin/variable/plusAssignFun.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 class C
 
diff --git a/idea/testData/findUsages/kotlin/variable/readAccess.0.kt b/idea/testData/findUsages/kotlin/variable/readAccess.0.kt
index 0bae4236bdb..6b288d27bc2 100644
--- a/idea/testData/findUsages/kotlin/variable/readAccess.0.kt
+++ b/idea/testData/findUsages/kotlin/variable/readAccess.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 // OPTIONS: skipWrite
 fun foo() {
diff --git a/idea/testData/findUsages/kotlin/variable/writeAccess.0.kt b/idea/testData/findUsages/kotlin/variable/writeAccess.0.kt
index 41c8705f916..c8209819772 100644
--- a/idea/testData/findUsages/kotlin/variable/writeAccess.0.kt
+++ b/idea/testData/findUsages/kotlin/variable/writeAccess.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetProperty
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtProperty
 // OPTIONS: usages
 // OPTIONS: skipRead
 fun foo() {
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryClassUsages.0.kt b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryClassUsages.0.kt
index cb5d7d0d471..e5249f354ce 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryClassUsages.0.kt
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryClassUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 // FIND_BY_REF
 // WITH_FILE_NAME
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryCompanionObjectUsages.0.kt b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryCompanionObjectUsages.0.kt
index 48d7fa02181..3d34b7d70bc 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryCompanionObjectUsages.0.kt
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryCompanionObjectUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetObjectDeclaration
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtObjectDeclaration
 // OPTIONS: usages, constructorUsages
 // FIND_BY_REF
 // WITH_FILE_NAME
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryEnumEntryUsages.0.kt b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryEnumEntryUsages.0.kt
index 36d9a2e7111..d890bdc9b1f 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryEnumEntryUsages.0.kt
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryEnumEntryUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetEnumEntry
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtEnumEntry
 // FIND_BY_REF
 
 package usages
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryFunctionUsages.0.kt b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryFunctionUsages.0.kt
index a9a1e96d690..9d62a757072 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryFunctionUsages.0.kt
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryFunctionUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 // FIND_BY_REF
 // WITH_FILE_NAME
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryFunctionUsages.1.java b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryFunctionUsages.1.java
index ffa435b1e03..5c9ad5ace21 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryFunctionUsages.1.java
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryFunctionUsages.1.java
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 // FIND_BY_REF
 // WITH_FILE_NAME
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryMemberFunctionUsages.0.kt b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryMemberFunctionUsages.0.kt
index 6613af6318d..564ec443749 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryMemberFunctionUsages.0.kt
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryMemberFunctionUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 // FIND_BY_REF
 // WITH_FILE_NAME
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryMemberFunctionUsages.1.java b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryMemberFunctionUsages.1.java
index d487a039809..1aeaf8210c9 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryMemberFunctionUsages.1.java
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryMemberFunctionUsages.1.java
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 // FIND_BY_REF
 // WITH_FILE_NAME
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassMemberFunctionUsages.0.kt b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassMemberFunctionUsages.0.kt
index 85ef1fdc78e..875232dc41d 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassMemberFunctionUsages.0.kt
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassMemberFunctionUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 // FIND_BY_REF
 // WITH_FILE_NAME
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassMemberFunctionUsages.1.java b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassMemberFunctionUsages.1.java
index bc8264d8ded..64828857e6a 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassMemberFunctionUsages.1.java
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassMemberFunctionUsages.1.java
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetNamedFunction
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtNamedFunction
 // OPTIONS: usages
 // FIND_BY_REF
 // WITH_FILE_NAME
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassPrimaryConstructorUsages.0.kt b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassPrimaryConstructorUsages.0.kt
index 160505ea5e2..0a642631e98 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassPrimaryConstructorUsages.0.kt
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassPrimaryConstructorUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetPrimaryConstructor
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtPrimaryConstructor
 // OPTIONS: usages
 // FIND_BY_REF
 // WITH_FILE_NAME
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassSecondaryConstructorUsages.0.kt b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassSecondaryConstructorUsages.0.kt
index 947ce629765..8d0d3c4cde3 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassSecondaryConstructorUsages.0.kt
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassSecondaryConstructorUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetSecondaryConstructor
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtSecondaryConstructor
 // OPTIONS: usages
 // FIND_BY_REF
 // WITH_FILE_NAME
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassUsages.0.kt b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassUsages.0.kt
index bb9ccb1d2df..f819974e58c 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassUsages.0.kt
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryNestedClassUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetClass
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtClass
 // OPTIONS: usages, constructorUsages
 // FIND_BY_REF
 // WITH_FILE_NAME
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryObjectUsages.0.kt b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryObjectUsages.0.kt
index d0159b88a59..0ee0d1fa375 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryObjectUsages.0.kt
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryObjectUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetObjectDeclaration
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtObjectDeclaration
 // OPTIONS: usages
 // FIND_BY_REF
 // WITH_FILE_NAME
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryPrimaryConstructorUsages.0.kt b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryPrimaryConstructorUsages.0.kt
index ef12a6a72ea..f543f78d85b 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryPrimaryConstructorUsages.0.kt
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibraryPrimaryConstructorUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetPrimaryConstructor
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtPrimaryConstructor
 // OPTIONS: usages
 // FIND_BY_REF
 // WITH_FILE_NAME
diff --git a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibrarySecondaryConstructorUsages.0.kt b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibrarySecondaryConstructorUsages.0.kt
index 046d7939a6a..cd7f7ddd7a5 100644
--- a/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibrarySecondaryConstructorUsages.0.kt
+++ b/idea/testData/findUsages/libraryUsages/kotlinLibrary/LibrarySecondaryConstructorUsages.0.kt
@@ -1,4 +1,4 @@
-// PSI_ELEMENT: org.jetbrains.kotlin.psi.JetSecondaryConstructor
+// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtSecondaryConstructor
 // OPTIONS: usages
 // FIND_BY_REF
 // WITH_FILE_NAME
diff --git a/idea/tests/org/jetbrains/kotlin/AbstractImportsTest.kt b/idea/tests/org/jetbrains/kotlin/AbstractImportsTest.kt
index 25b4869c975..3c959db2221 100644
--- a/idea/tests/org/jetbrains/kotlin/AbstractImportsTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/AbstractImportsTest.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.idea.core.formatter.JetCodeStyleSettings
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.JetWithJdkAndRuntimeLightProjectDescriptor
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.io.File
@@ -51,7 +51,7 @@ public abstract class AbstractImportsTest : JetLightCodeInsightFixtureTestCase()
 
             fixture.configureByFile(testPath)
 
-            val file = fixture.getFile() as JetFile
+            val file = fixture.getFile() as KtFile
 
             val fileText = file.getText()
 
@@ -77,7 +77,7 @@ public abstract class AbstractImportsTest : JetLightCodeInsightFixtureTestCase()
         }
     }
 
-    protected abstract fun doTest(file: JetFile)
+    protected abstract fun doTest(file: KtFile)
 
     protected open val nameCountToUseStarImportDefault: Int
         get() = 1
diff --git a/idea/tests/org/jetbrains/kotlin/DataFlowValueRenderingTest.kt b/idea/tests/org/jetbrains/kotlin/DataFlowValueRenderingTest.kt
index d64b7198954..3c984d53899 100644
--- a/idea/tests/org/jetbrains/kotlin/DataFlowValueRenderingTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/DataFlowValueRenderingTest.kt
@@ -17,8 +17,8 @@
 package org.jetbrains.kotlin
 
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.idea.completion.renderDataFlowValue
 import org.jetbrains.kotlin.test.JetTestUtils
 import com.intellij.openapi.util.io.FileUtil
@@ -43,9 +43,9 @@ public abstract class AbstractDataFlowValueRenderingTest: JetLightCodeInsightFix
         val fixture = myFixture
         fixture.configureByFile(fileName)
 
-        val jetFile = fixture.getFile() as JetFile
+        val jetFile = fixture.getFile() as KtFile
         val element = jetFile.findElementAt(fixture.getCaretOffset())!!
-        val expression = element.getStrictParentOfType<JetExpression>()!!
+        val expression = element.getStrictParentOfType<KtExpression>()!!
         val info = expression.analyze().getDataFlowInfo(expression)
 
         val allValues = (info.getCompleteTypeInfo().keySet() + info.getCompleteNullabilityInfo().keySet()).toSet()
diff --git a/idea/tests/org/jetbrains/kotlin/addImport/AbstractAddImportTest.kt b/idea/tests/org/jetbrains/kotlin/addImport/AbstractAddImportTest.kt
index 1c9ac78d62f..f3c6cdba548 100644
--- a/idea/tests/org/jetbrains/kotlin/addImport/AbstractAddImportTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/addImport/AbstractAddImportTest.kt
@@ -23,12 +23,12 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveImportReference
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 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.test.InTextDirectivesUtils
 
 public abstract class AbstractAddImportTest : AbstractImportsTest() {
-    override fun doTest(file: JetFile) {
+    override fun doTest(file: KtFile) {
         var descriptorName = InTextDirectivesUtils.findStringWithPrefixes(file.getText(), "// IMPORT:")
                              ?: error("No IMPORT directive defined")
 
diff --git a/idea/tests/org/jetbrains/kotlin/asJava/KotlinLightClassInheritorTest.kt b/idea/tests/org/jetbrains/kotlin/asJava/KotlinLightClassInheritorTest.kt
index 5cb110d4226..489f202e742 100644
--- a/idea/tests/org/jetbrains/kotlin/asJava/KotlinLightClassInheritorTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/asJava/KotlinLightClassInheritorTest.kt
@@ -21,8 +21,8 @@ import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.testFramework.LightProjectDescriptor
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.JetLightProjectDescriptor
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtFile
 import org.junit.Assert
 
 public class KotlinLightClassInheritorTest : JetLightCodeInsightFixtureTestCase() {
@@ -47,8 +47,8 @@ public class KotlinLightClassInheritorTest : JetLightCodeInsightFixtureTestCase(
     }
 
     private fun doTestInheritorByText(text: String, superQName: String, checkDeep: Boolean) {
-        val file = myFixture.configureByText("A.kt", text) as JetFile
-        val jetClass = file.declarations.filterIsInstance<JetClass>().single()
+        val file = myFixture.configureByText("A.kt", text) as KtFile
+        val jetClass = file.declarations.filterIsInstance<KtClass>().single()
         val psiClass = LightClassGenerationSupport.getInstance(project).getPsiClass(jetClass)!!
         val baseClass = JavaPsiFacade.getInstance(project).findClass(superQName, GlobalSearchScope.allScope(project))!!
         Assert.assertTrue(psiClass.isInheritor(baseClass, checkDeep))
diff --git a/idea/tests/org/jetbrains/kotlin/findUsages/AbstractJetFindUsagesTest.java b/idea/tests/org/jetbrains/kotlin/findUsages/AbstractJetFindUsagesTest.java
index 0d485bb04b0..7f307d515dc 100644
--- a/idea/tests/org/jetbrains/kotlin/findUsages/AbstractJetFindUsagesTest.java
+++ b/idea/tests/org/jetbrains/kotlin/findUsages/AbstractJetFindUsagesTest.java
@@ -250,13 +250,13 @@ public abstract class AbstractJetFindUsagesTest extends JetLightCodeInsightFixtu
 
         @Nullable
         public static OptionsParser getParserByPsiElementClass(@NotNull Class<? extends PsiElement> klass) {
-            if (klass == JetNamedFunction.class) {
+            if (klass == KtNamedFunction.class) {
                 return FUNCTION;
             }
-            if (klass == JetProperty.class || klass == JetParameter.class) {
+            if (klass == KtProperty.class || klass == KtParameter.class) {
                 return PROPERTY;
             }
-            if (klass == JetClass.class) {
+            if (klass == KtClass.class) {
                 return CLASS;
             }
             if (klass == PsiMethod.class) {
@@ -271,7 +271,7 @@ public abstract class AbstractJetFindUsagesTest extends JetLightCodeInsightFixtu
             if (klass == PsiPackage.class) {
                 return JAVA_PACKAGE;
             }
-            if (klass == JetTypeParameter.class) {
+            if (klass == KtTypeParameter.class) {
                 return DEFAULT;
             }
 
diff --git a/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryCustomTest.kt b/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryCustomTest.kt
index ad4646e403c..81b77622d88 100644
--- a/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryCustomTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryCustomTest.kt
@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.findUsages
 
 import com.intellij.psi.search.FilenameIndex
-import org.jetbrains.kotlin.psi.JetParameter
+import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import kotlin.test.assertEquals
 
@@ -25,7 +25,7 @@ public class KotlinFindUsagesWithLibraryCustomTest : AbstractKotlinFindUsagesWit
     public fun testFindUsagesForLocalClassProperty() {
         val libraryFile = FilenameIndex.getFilesByName(getProject(), "library.kt", myFixture.getModule().getModuleWithLibrariesScope()).first()
         val indexOf = libraryFile.getText().indexOf("localClassProperty")
-        val jetParameter = libraryFile.findElementAt(indexOf)!!.getStrictParentOfType<JetParameter>()!!
+        val jetParameter = libraryFile.findElementAt(indexOf)!!.getStrictParentOfType<KtParameter>()!!
         val usages = findUsages(jetParameter.getOriginalElement(), null)
         assertEquals(2, usages.size())
     }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/AbstractCopyPasteTest.kt b/idea/tests/org/jetbrains/kotlin/idea/AbstractCopyPasteTest.kt
index 4d7f1adb31c..e1a8a10e7d7 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/AbstractCopyPasteTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/AbstractCopyPasteTest.kt
@@ -20,7 +20,7 @@ import com.intellij.codeInsight.CodeInsightSettings
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import java.io.File
 
 public abstract class AbstractCopyPasteTest : JetLightCodeInsightFixtureTestCase() {
@@ -50,12 +50,12 @@ public abstract class AbstractCopyPasteTest : JetLightCodeInsightFixtureTestCase
         }
     }
 
-    protected  fun configureTargetFile(fileName: String): JetFile {
+    protected  fun configureTargetFile(fileName: String): KtFile {
         if (File(getTestDataPath() + File.separator + fileName).exists()) {
-            return myFixture.configureByFile(fileName) as JetFile
+            return myFixture.configureByFile(fileName) as KtFile
         }
         else {
-            return myFixture.configureByText(fileName, DEFAULT_TO_FILE_TEXT) as JetFile
+            return myFixture.configureByText(fileName, DEFAULT_TO_FILE_TEXT) as KtFile
         }
     }
 }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/AbstractExpressionSelectionTest.java b/idea/tests/org/jetbrains/kotlin/idea/AbstractExpressionSelectionTest.java
index 44eaa9d0b1a..f7c0170383e 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/AbstractExpressionSelectionTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/AbstractExpressionSelectionTest.java
@@ -20,20 +20,20 @@ import com.intellij.testFramework.LightCodeInsightTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.JetTestUtils;
 
 public abstract class AbstractExpressionSelectionTest extends LightCodeInsightTestCase {
 
     public void doTestExpressionSelection(@NotNull String path) throws Exception {
         configureByFile(path);
-        final String expectedExpression = JetTestUtils.getLastCommentInFile((JetFile) getFile());
+        final String expectedExpression = JetTestUtils.getLastCommentInFile((KtFile) getFile());
 
         try {
             JetRefactoringUtil.selectExpression(getEditor(), getFile(), new JetRefactoringUtil.SelectExpressionCallback() {
                 @Override
-                public void run(@Nullable JetExpression expression) {
+                public void run(@Nullable KtExpression expression) {
                     assertNotNull("Selected expression mustn't be null", expression);
                     assertEquals(expectedExpression, expression.getText());
                 }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/AbstractSmartSelectionTest.java b/idea/tests/org/jetbrains/kotlin/idea/AbstractSmartSelectionTest.java
index 6382480d6a6..eda7bb3d017 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/AbstractSmartSelectionTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/AbstractSmartSelectionTest.java
@@ -20,8 +20,8 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.testFramework.LightCodeInsightTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.JetTestUtils;
 
 import java.util.ArrayList;
@@ -31,13 +31,13 @@ public abstract class AbstractSmartSelectionTest extends LightCodeInsightTestCas
 
     public void doTestSmartSelection(@NotNull String path) throws Exception {
         configureByFile(path);
-        String expectedResultText = JetTestUtils.getLastCommentInFile((JetFile) getFile());
+        String expectedResultText = JetTestUtils.getLastCommentInFile((KtFile) getFile());
 
-        List<JetExpression> expressions = JetRefactoringUtil.getSmartSelectSuggestions(
+        List<KtExpression> expressions = JetRefactoringUtil.getSmartSelectSuggestions(
                 getFile(), getEditor().getCaretModel().getOffset());
 
         List<String> textualExpressions = new ArrayList<String>();
-        for (JetExpression expression : expressions) {
+        for (KtExpression expression : expressions) {
             textualExpressions.add(expression.getText());
         }
         assertEquals(expectedResultText, StringUtil.join(textualExpressions, "\n"));
diff --git a/idea/tests/org/jetbrains/kotlin/idea/ResolveElementCacheTest.kt b/idea/tests/org/jetbrains/kotlin/idea/ResolveElementCacheTest.kt
index f710045a1fd..ae00a9c4a63 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/ResolveElementCacheTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/ResolveElementCacheTest.kt
@@ -48,25 +48,25 @@ class C(param1: String = "", param2: Int = 0) {
 """
 
     private data class Data(
-            val file: JetFile,
-            val klass: JetClass,
-            val members: List<JetDeclaration>,
-            val statements: List<JetExpression>,
-            val factory: JetPsiFactory
+            val file: KtFile,
+            val klass: KtClass,
+            val members: List<KtDeclaration>,
+            val statements: List<KtExpression>,
+            val factory: KtPsiFactory
     )
 
     private fun doTest(handler: Data.() -> Unit) {
-        val file = myFixture.configureByText("Test.kt", FILE_TEXT) as JetFile
+        val file = myFixture.configureByText("Test.kt", FILE_TEXT) as KtFile
         val data = extractData(file)
         myFixture.project.executeWriteCommand("") { data.handler() }
     }
 
-    private fun extractData(file: JetFile): Data {
-        val klass = file.declarations.single() as JetClass
+    private fun extractData(file: KtFile): Data {
+        val klass = file.declarations.single() as KtClass
         val members = klass.declarations
-        val function = members.first() as JetNamedFunction
-        val statements = (function.bodyExpression as JetBlockExpression).statements
-        return Data(file, klass, members, statements, JetPsiFactory(getProject()))
+        val function = members.first() as KtNamedFunction
+        val statements = (function.bodyExpression as KtBlockExpression).statements
+        return Data(file, klass, members, statements, KtPsiFactory(getProject()))
     }
 
     public fun testFullResolveCaching() {
@@ -84,8 +84,8 @@ class C(param1: String = "", param2: Int = 0) {
         val aFunBodyContext3 = statement1.analyze(BodyResolveMode.FULL)
         assert(aFunBodyContext3 === aFunBodyContext1)
 
-        val bFun = members[1] as JetNamedFunction
-        val bBody = bFun.bodyExpression as JetBlockExpression
+        val bFun = members[1] as KtNamedFunction
+        val bBody = bFun.bodyExpression as KtBlockExpression
         val bStatement = bBody.statements[0]
         val bFunBodyContext = bStatement.analyze(BodyResolveMode.FULL)
 
@@ -111,7 +111,7 @@ class C(param1: String = "", param2: Int = 0) {
 
     public fun testNonPhysicalFileFullResolveCaching() {
         doTest {
-            val nonPhysicalFile = JetPsiFactory(getProject()).createAnalyzableFile("NonPhysical.kt", FILE_TEXT, file)
+            val nonPhysicalFile = KtPsiFactory(getProject()).createAnalyzableFile("NonPhysical.kt", FILE_TEXT, file)
             val nonPhysicalData = extractData(nonPhysicalFile)
             nonPhysicalData.testResolveCaching()
 
@@ -150,8 +150,8 @@ class C(param1: String = "", param2: Int = 0) {
             documentManager.doPostponedOperationsAndUnblockDocument(document)
 
             // modify body of "b()" via document
-            val bFun = members[1] as JetNamedFunction
-            val bBody = bFun.bodyExpression as JetBlockExpression
+            val bFun = members[1] as KtNamedFunction
+            val bBody = bFun.bodyExpression as KtBlockExpression
             document.insertString(bBody.lBrace!!.startOffset + 1, "x()")
             documentManager.commitAllDocuments()
 
@@ -165,7 +165,7 @@ class C(param1: String = "", param2: Int = 0) {
             document.insertString(statement.startOffset, "x()\n")
             documentManager.commitAllDocuments()
 
-            val bindingContext5 = (members[0] as JetNamedFunction).bodyExpression!!.analyze(BodyResolveMode.FULL)
+            val bindingContext5 = (members[0] as KtNamedFunction).bodyExpression!!.analyze(BodyResolveMode.FULL)
             assert(bindingContext5 !== bindingContext1)
 
             val bindingContext6 = classConstructorParamTypeRef.analyze(BodyResolveMode.FULL)
@@ -216,7 +216,7 @@ class C(param1: String = "", param2: Int = 0) {
 
     public fun testNonPhysicalFilePartialResolveCaching() {
         doTest {
-            val nonPhysicalFile = JetPsiFactory(getProject()).createAnalyzableFile("NonPhysical.kt", FILE_TEXT, file)
+            val nonPhysicalFile = KtPsiFactory(getProject()).createAnalyzableFile("NonPhysical.kt", FILE_TEXT, file)
             val nonPhysicalData = extractData(nonPhysicalFile)
             nonPhysicalData.testPartialResolveCaching()
         }
@@ -224,7 +224,7 @@ class C(param1: String = "", param2: Int = 0) {
 
     public fun testPartialResolveCachedForWholeStatement() {
         doTest {
-            val statement = statements[0] as JetCallExpression
+            val statement = statements[0] as KtCallExpression
             val argument1 = statement.getValueArguments()[0]
             val argument2 = statement.getValueArguments()[1]
             val bindingContext1 = argument1.analyze(BodyResolveMode.PARTIAL)
@@ -236,7 +236,7 @@ class C(param1: String = "", param2: Int = 0) {
     public fun testPartialResolveCachedForAllStatementsResolved() {
         doTest {
             val bindingContext1 = statements[2].analyze(BodyResolveMode.PARTIAL) // resolve 'd(x)'
-            val bindingContext2 = (statements[1] as JetVariableDeclaration).getInitializer()!!.analyze(BodyResolveMode.PARTIAL) // resolve initializer in 'val x = c()' - it required for resolved 'd(x)' and should be already resolved
+            val bindingContext2 = (statements[1] as KtVariableDeclaration).getInitializer()!!.analyze(BodyResolveMode.PARTIAL) // resolve initializer in 'val x = c()' - it required for resolved 'd(x)' and should be already resolved
             assert(bindingContext1 === bindingContext2)
 
             val bindingContext3 = statements[0].analyze(BodyResolveMode.PARTIAL)
@@ -246,7 +246,7 @@ class C(param1: String = "", param2: Int = 0) {
 
     public fun testPartialResolveCachedForDefaultParameterValue() {
         doTest {
-            val defaultValue = (members[0] as JetNamedFunction).getValueParameters()[0].getDefaultValue()
+            val defaultValue = (members[0] as KtNamedFunction).getValueParameters()[0].getDefaultValue()
             val bindingContext1 = defaultValue!!.analyze(BodyResolveMode.PARTIAL)
             val bindingContext2 = defaultValue.analyze(BodyResolveMode.PARTIAL)
             assert(bindingContext1 === bindingContext2)
@@ -270,9 +270,9 @@ class C(param1: String = "", param2: Int = 0) {
         val file = myFixture.configureByText("Test.kt", """
         annotation class A
         @A class B {}
-        """) as JetFile
+        """) as KtFile
 
-        val klass = file.getDeclarations()[1] as JetClass
+        val klass = file.getDeclarations()[1] as KtClass
         val annotationEntry = klass.getAnnotationEntries().single()
 
         val context = annotationEntry.analyze(BodyResolveMode.PARTIAL)
diff --git a/idea/tests/org/jetbrains/kotlin/idea/actions/QualifiedNamesTest.kt b/idea/tests/org/jetbrains/kotlin/idea/actions/QualifiedNamesTest.kt
index f7acacaeeca..c87092232e9 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/actions/QualifiedNamesTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/actions/QualifiedNamesTest.kt
@@ -18,10 +18,10 @@ package org.jetbrains.kotlin.idea.actions
 
 import com.intellij.testFramework.LightCodeInsightTestCase
 import com.intellij.testFramework.LightPlatformCodeInsightTestCase
-import org.jetbrains.kotlin.psi.JetVisitorVoid
+import org.jetbrains.kotlin.psi.KtVisitorVoid
 import com.intellij.psi.PsiElement
 import com.intellij.ide.actions.CopyReferenceAction
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import java.util.ArrayList
 import kotlin.test.assertEquals
 
@@ -74,12 +74,12 @@ public class QualifiedNamesTest: LightCodeInsightTestCase() {
 
     private fun getQualifiedNamesForDeclarations(): List<String?> {
         val result = ArrayList<String?>()
-        LightPlatformCodeInsightTestCase.myFile.accept(object : JetVisitorVoid() {
+        LightPlatformCodeInsightTestCase.myFile.accept(object : KtVisitorVoid() {
             override fun visitElement(element: PsiElement) {
                 element.acceptChildren(this)
             }
 
-            override fun visitNamedDeclaration(declaration: JetNamedDeclaration) {
+            override fun visitNamedDeclaration(declaration: KtNamedDeclaration) {
                 result.add(CopyReferenceAction.elementToFqn(declaration))
                 super.visitNamedDeclaration(declaration)
             }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractInsertImportOnPasteTest.kt b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractInsertImportOnPasteTest.kt
index 2b0ea5abf3a..535fd67f71a 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractInsertImportOnPasteTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractInsertImportOnPasteTest.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.idea.AbstractCopyPasteTest
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import org.jetbrains.kotlin.idea.test.dumpTextWithErrors
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.io.File
@@ -71,7 +71,7 @@ public abstract class AbstractInsertImportOnPasteTest : AbstractCopyPasteTest()
         val namesToImportDump = KotlinCopyPasteReferenceProcessor.declarationsToImportSuggested.joinToString("\n")
         JetTestUtils.assertEqualsToFile(File(path.replace(".kt", ".expected.names")), namesToImportDump)
 
-        val resultFile = myFixture.getFile() as JetFile
+        val resultFile = myFixture.getFile() as KtFile
         val resultText = if (InTextDirectivesUtils.isDirectiveDefined(testFileText, NO_ERRORS_DUMP_DIRECTIVE))
             resultFile.getText()
         else
diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractLineMarkersTest.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractLineMarkersTest.java
index d20767d241f..c996ed8d876 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractLineMarkersTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractLineMarkersTest.java
@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.idea.test.JetWithJdkAndRuntimeLightProjectDescriptor
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase;
 import org.jetbrains.kotlin.idea.highlighter.markers.SuperDeclarationMarkerNavigationHandler;
 import org.jetbrains.kotlin.idea.navigation.NavigationTestUtils;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.ReferenceUtils;
 import org.jetbrains.kotlin.test.TagsTestDataUtil;
@@ -115,7 +115,7 @@ public abstract class AbstractLineMarkersTest extends JetLightCodeInsightFixture
 
     private void assertNavigationElements(List<LineMarkerInfo> markers) {
         List<String> navigationDataComments = JetTestUtils.getLastCommentsInFile(
-                (JetFile) myFixture.getFile(), JetTestUtils.CommentType.BLOCK_COMMENT, false);
+                (KtFile) myFixture.getFile(), JetTestUtils.CommentType.BLOCK_COMMENT, false);
         if (navigationDataComments.isEmpty()) return;
 
         for (String navigationComment : navigationDataComments) {
diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractOverrideImplementTest.kt b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractOverrideImplementTest.kt
index b80657b3a74..60d02c339d1 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractOverrideImplementTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractOverrideImplementTest.kt
@@ -37,8 +37,8 @@ import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.JetLightProjectDescriptor
 import org.jetbrains.kotlin.idea.test.dumpTextWithErrors
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.JetTestUtils
 import org.jetbrains.kotlin.test.TagsTestDataUtil
 import org.jetbrains.kotlin.utils.rethrow
@@ -122,7 +122,7 @@ public abstract class AbstractOverrideImplementTest : JetLightCodeInsightFixture
 
     private fun doOverrideImplement(handler: OverrideImplementMembersHandler, memberToOverride: String?) {
         val elementAtCaret = myFixture.file.findElementAt(myFixture.editor.caretModel.offset)
-        val classOrObject = PsiTreeUtil.getParentOfType(elementAtCaret, javaClass<JetClassOrObject>())
+        val classOrObject = PsiTreeUtil.getParentOfType(elementAtCaret, javaClass<KtClassOrObject>())
                             ?: error("Caret should be inside class or object")
 
         val chooserObjects = handler.collectMembersToGenerate(classOrObject)
@@ -157,7 +157,7 @@ public abstract class AbstractOverrideImplementTest : JetLightCodeInsightFixture
 
     private fun doMultiOverrideImplement(handler: OverrideImplementMembersHandler) {
         val elementAtCaret = myFixture.file.findElementAt(myFixture.editor.caretModel.offset)
-        val classOrObject = PsiTreeUtil.getParentOfType(elementAtCaret, javaClass<JetClassOrObject>())
+        val classOrObject = PsiTreeUtil.getParentOfType(elementAtCaret, javaClass<KtClassOrObject>())
                             ?: error("Caret should be inside class or object")
 
         val chooserObjects = handler.collectMembersToGenerate(classOrObject).sortedBy { it.descriptor.name.asString() + " in " + it.immediateSuper.containingDeclaration.name.asString() }
@@ -177,7 +177,7 @@ public abstract class AbstractOverrideImplementTest : JetLightCodeInsightFixture
     }
 
     private fun performGenerateCommand(
-            classOrObject: JetClassOrObject,
+            classOrObject: KtClassOrObject,
             selectedElements: List<OverrideMemberChooserObject>) {
         try {
             myFixture.project.executeWriteCommand("") {
@@ -194,7 +194,7 @@ public abstract class AbstractOverrideImplementTest : JetLightCodeInsightFixture
         val expectedFile = File(myFixture.testDataPath, fileName)
         try {
             Assert.assertTrue(expectedFile.exists())
-            val file = myFixture.file as JetFile
+            val file = myFixture.file as KtFile
             val document = myFixture.getDocument(file)
             myFixture.project.executeWriteCommand("") {
                 document.replaceString(0, document.textLength, file.dumpTextWithErrors())
diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/smartEnter/SmartEnterTest.kt b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/smartEnter/SmartEnterTest.kt
index a098615a025..6f4d263d85b 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/smartEnter/SmartEnterTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/smartEnter/SmartEnterTest.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.codeInsight.smartEnter
 import com.intellij.openapi.actionSystem.IdeActions
 import com.intellij.testFramework.LightProjectDescriptor
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
 
 class SmartEnterTest : JetLightCodeInsightFixtureTestCase() {
@@ -1032,7 +1032,7 @@ class SmartEnterTest : JetLightCodeInsightFixtureTestCase() {
     }
 
     fun doTest(before: String, after: String) {
-        myFixture.configureByText(JetFileType.INSTANCE, before)
+        myFixture.configureByText(KotlinFileType.INSTANCE, before)
         myFixture.performEditorAction(IdeActions.ACTION_EDITOR_COMPLETE_STATEMENT)
         myFixture.checkResult(after)
     }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/coverage/AbstractKotlinCoverageOutputFilesTest.kt b/idea/tests/org/jetbrains/kotlin/idea/coverage/AbstractKotlinCoverageOutputFilesTest.kt
index 9d7abb5713f..b39e33ff233 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/coverage/AbstractKotlinCoverageOutputFilesTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/coverage/AbstractKotlinCoverageOutputFilesTest.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.coverage
 
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.io.File
 import com.intellij.openapi.util.io.FileUtil
@@ -31,7 +31,7 @@ public abstract class AbstractKotlinCoverageOutputFilesTest(): JetLightCodeInsig
     override fun getTestDataPath(): String? = TEST_DATA_PATH
 
     public fun doTest(path: String) {
-        val kotlinFile = myFixture.configureByFile(path) as JetFile
+        val kotlinFile = myFixture.configureByFile(path) as KtFile
         val outDir = myFixture.getTempDirFixture().findOrCreateDir("coverageTestOut")
         try {
             FileUtil.loadLines(File(path.replace(".kt", ".classes.txt"))).forEach {
diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractJetPositionManagerTest.java b/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractJetPositionManagerTest.java
index 679e042609c..6af31edb4bf 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractJetPositionManagerTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractJetPositionManagerTest.java
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.idea.project.PluginJetFilesProvider;
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase;
 import org.jetbrains.kotlin.idea.test.JetWithJdkAndRuntimeLightProjectDescriptor;
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.utils.CollectionsKt;
 import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
 
@@ -85,13 +85,13 @@ public abstract class AbstractJetPositionManagerTest extends JetLightCodeInsight
     @NotNull
     private static JetPositionManager createPositionManager(
             @NotNull DebugProcess process,
-            @NotNull List<JetFile> files,
+            @NotNull List<KtFile> files,
             @NotNull GenerationState state
     ) {
         JetPositionManager positionManager = (JetPositionManager) new JetPositionManagerFactory().createPositionManager(process);
         assertNotNull(positionManager);
 
-        for (JetFile file : files) {
+        for (KtFile file : files) {
             positionManager.addTypeMapper(file, state.getTypeMapper());
         }
 
@@ -126,10 +126,10 @@ public abstract class AbstractJetPositionManagerTest extends JetLightCodeInsight
 
     private void performTest() {
         Project project = getProject();
-        List<JetFile> files = new ArrayList<JetFile>(PluginJetFilesProvider.allFilesInProject(project));
+        List<KtFile> files = new ArrayList<KtFile>(PluginJetFilesProvider.allFilesInProject(project));
 
         final List<Breakpoint> breakpoints = Lists.newArrayList();
-        for (JetFile file : files) {
+        for (KtFile file : files) {
             breakpoints.addAll(extractBreakpointsInfo(file, file.getText()));
         }
 
@@ -167,7 +167,7 @@ public abstract class AbstractJetPositionManagerTest extends JetLightCodeInsight
         super.tearDown();
     }
 
-    private static Collection<Breakpoint> extractBreakpointsInfo(JetFile file, String fileContent) {
+    private static Collection<Breakpoint> extractBreakpointsInfo(KtFile file, String fileContent) {
         Collection<Breakpoint> breakpoints = Lists.newArrayList();
         String[] lines = StringUtil.convertLineSeparators(fileContent).split("\n");
 
@@ -226,11 +226,11 @@ public abstract class AbstractJetPositionManagerTest extends JetLightCodeInsight
     }
 
     private static class Breakpoint {
-        private final JetFile file;
+        private final KtFile file;
         private final int lineNumber; // 0-based
         private final String classNameRegexp;
 
-        private Breakpoint(JetFile file, int lineNumber, String classNameRegexp) {
+        private Breakpoint(KtFile file, int lineNumber, String classNameRegexp) {
             this.file = file;
             this.lineNumber = lineNumber;
             this.classNameRegexp = classNameRegexp;
diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestCase.java b/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestCase.java
index b98e7055fb7..c402cbd9b27 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestCase.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestCase.java
@@ -42,10 +42,9 @@ import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil;
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase;
 import org.jetbrains.kotlin.idea.test.ProjectDescriptorWithStdlibSources;
-import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.MockLibraryUtil;
 import org.junit.ComparisonFailure;
@@ -202,8 +201,8 @@ public abstract class KotlinDebuggerTestCase extends DescriptorTestCase {
 
         for (PsiClass psiClass : psiClasses) {
             if (psiClass instanceof KotlinLightClassForFacade) {
-                Collection<JetFile> files = ((KotlinLightClassForFacade) psiClass).getFiles();
-                for (JetFile jetFile : files) {
+                Collection<KtFile> files = ((KotlinLightClassForFacade) psiClass).getFiles();
+                for (KtFile jetFile : files) {
                     createBreakpoints(jetFile);
                 }
             }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt
index 16d6b9c2c24..05f6116c70e 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt
@@ -49,7 +49,7 @@ public abstract class AbstractCodeFragmentHighlightingTest : AbstractJetPsiCheck
 
         runWriteAction {
             val fileText = FileUtil.loadFile(File(filePath), true)
-            val file = myFixture.getFile() as JetFile
+            val file = myFixture.getFile() as KtFile
             InTextDirectivesUtils.findListWithPrefixes(fileText, "// IMPORT: ").forEach {
                 val descriptor = file.resolveImportReference(FqName(it)).singleOrNull()
                                             ?: error("Could not resolve descriptor to import: $it")
@@ -74,7 +74,7 @@ public abstract class AbstractCodeFragmentCompletionHandlerTest : AbstractComple
 
     override fun doTest(testPath: String) {
         super.doTest(testPath)
-        val fragment = myFixture.getFile() as JetCodeFragment
+        val fragment = myFixture.getFile() as KtCodeFragment
 
         val importList = fragment.importsAsImportList()
         val fragmentAfterFile = File(testPath + ".after.imports")
@@ -96,10 +96,10 @@ private fun JavaCodeInsightTestFixture.configureByCodeFragment(filePath: String)
 
     val typeStr = InTextDirectivesUtils.findStringWithPrefixes(getFile().getText(), "// ${ExpectedCompletionUtils.RUNTIME_TYPE} ")
     if (typeStr != null) {
-        file.putCopyableUserData(JetCodeFragment.RUNTIME_TYPE_EVALUATOR, {
-            val codeFragment = JetPsiFactory(getProject()).createBlockCodeFragment("val xxx: $typeStr" , PsiTreeUtil.getParentOfType(elementAt, javaClass<JetElement>()))
+        file.putCopyableUserData(KtCodeFragment.RUNTIME_TYPE_EVALUATOR, {
+            val codeFragment = KtPsiFactory(getProject()).createBlockCodeFragment("val xxx: $typeStr" , PsiTreeUtil.getParentOfType(elementAt, javaClass<KtElement>()))
             val context = codeFragment.analyzeFully()
-            val typeReference: JetTypeReference = PsiTreeUtil.getChildOfType(codeFragment.getContentElement().getFirstChild(), javaClass())!!
+            val typeReference: KtTypeReference = PsiTreeUtil.getChildOfType(codeFragment.getContentElement().getFirstChild(), javaClass())!!
             context[BindingContext.TYPE, typeReference]
         })
     }
@@ -107,10 +107,10 @@ private fun JavaCodeInsightTestFixture.configureByCodeFragment(filePath: String)
     configureFromExistingVirtualFile(file.getVirtualFile()!!)
 }
 
-private fun createCodeFragment(filePath: String, contextElement: PsiElement): JetCodeFragment {
+private fun createCodeFragment(filePath: String, contextElement: PsiElement): KtCodeFragment {
     val fileForFragment = File(filePath + ".fragment")
     val codeFragmentText = FileUtil.loadFile(fileForFragment, true).trim()
-    val psiFactory = JetPsiFactory(contextElement.getProject())
+    val psiFactory = KtPsiFactory(contextElement.getProject())
     if (fileForFragment.readLines().size() == 1) {
         return psiFactory.createExpressionCodeFragment(
                 codeFragmentText,
diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractKotlinEvaluateExpressionTest.kt b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractKotlinEvaluateExpressionTest.kt
index e01560a518c..d056b7c62b8 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractKotlinEvaluateExpressionTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractKotlinEvaluateExpressionTest.kt
@@ -51,7 +51,7 @@ import org.apache.log4j.spi.LoggingEvent
 import org.jetbrains.eval4j.ObjectValue
 import org.jetbrains.eval4j.Value
 import org.jetbrains.eval4j.jdi.asValue
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.debugger.KotlinDebuggerTestBase
 import org.jetbrains.kotlin.idea.debugger.KotlinFrameExtraVariablesProvider
 import org.jetbrains.kotlin.idea.util.application.runReadAction
@@ -357,7 +357,7 @@ public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestB
             try {
 
                 val evaluator =
-                        EvaluatorBuilderImpl.build(TextWithImportsImpl(codeFragmentKind, text, "", JetFileType.INSTANCE),
+                        EvaluatorBuilderImpl.build(TextWithImportsImpl(codeFragmentKind, text, "", KotlinFileType.INSTANCE),
                                                    contextElement,
                                                    sourcePosition)
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionInLibraryTest.kt b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionInLibraryTest.kt
index 8e60ab1a0b4..f11529f53e9 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionInLibraryTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionInLibraryTest.kt
@@ -26,9 +26,9 @@ import com.intellij.psi.PsiManager
 import org.jetbrains.kotlin.idea.completion.test.AbstractJvmBasicCompletionTest
 import org.jetbrains.kotlin.idea.completion.test.testCompletion
 import org.jetbrains.kotlin.idea.test.JdkAndMockLibraryProjectDescriptor
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetFunction
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.io.File
@@ -75,9 +75,9 @@ public class CodeFragmentCompletionInLibraryTest : AbstractJvmBasicCompletionTes
 
     private fun setupFixtureByCodeFragment(fragmentText: String) {
         val sourceFile = findLibrarySourceDir().findChild("customLibrary.kt")!!
-        val jetFile = PsiManager.getInstance(getProject()).findFile(sourceFile) as JetFile
-        val fooFunctionFromLibrary = jetFile.getDeclarations().first() as JetFunction
-        val codeFragment = JetPsiFactory(fooFunctionFromLibrary).createExpressionCodeFragment(
+        val jetFile = PsiManager.getInstance(getProject()).findFile(sourceFile) as KtFile
+        val fooFunctionFromLibrary = jetFile.getDeclarations().first() as KtFunction
+        val codeFragment = KtPsiFactory(fooFunctionFromLibrary).createExpressionCodeFragment(
                 fragmentText,
                 KotlinCodeFragmentFactory.getContextElement(fooFunctionFromLibrary.getBodyExpression())
         )
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/AbstractNavigateToLibrarySourceTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/AbstractNavigateToLibrarySourceTest.kt
index 007a0c0f3b2..ae756772a88 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/AbstractNavigateToLibrarySourceTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/AbstractNavigateToLibrarySourceTest.kt
@@ -23,7 +23,7 @@ import com.intellij.testFramework.LightProjectDescriptor
 import com.intellij.testFramework.UsefulTestCase
 import junit.framework.TestCase
 import org.jetbrains.kotlin.idea.navigation.NavigationTestUtils
-import org.jetbrains.kotlin.idea.references.JetReference
+import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.idea.test.*
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.io.File
@@ -65,15 +65,15 @@ public abstract class AbstractNavigateToLibrarySourceTest : KotlinCodeInsightTes
         UsefulTestCase.assertSameLines(expectedCode, actualCode)
     }
 
-    private fun collectInterestingReferences(): Collection<JetReference> {
+    private fun collectInterestingReferences(): Collection<KtReference> {
         val psiFile = getFile()
-        val referenceContainersToReferences = LinkedHashMap<PsiElement, JetReference>()
+        val referenceContainersToReferences = LinkedHashMap<PsiElement, KtReference>()
         for (offset in 0..psiFile.getTextLength() - 1) {
             val ref = psiFile.findReferenceAt(offset)
             val refs = when (ref) {
-                is JetReference -> listOf(ref)
-                is PsiMultiReference -> ref.getReferences().filterIsInstance<JetReference>()
-                else -> emptyList<JetReference>()
+                is KtReference -> listOf(ref)
+                is PsiMultiReference -> ref.getReferences().filterIsInstance<KtReference>()
+                else -> emptyList<KtReference>()
             }
 
             refs.forEach { referenceContainersToReferences.addReference(it) }
@@ -81,7 +81,7 @@ public abstract class AbstractNavigateToLibrarySourceTest : KotlinCodeInsightTes
         return referenceContainersToReferences.values()
     }
 
-    private fun MutableMap<PsiElement, JetReference>.addReference(ref: JetReference) {
+    private fun MutableMap<PsiElement, KtReference>.addReference(ref: KtReference) {
         if (containsKey(ref.getElement())) return
         val target = ref.resolve() ?: return
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateFromLibrarySourcesTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateFromLibrarySourcesTest.kt
index b4b1d85e043..3a641ed99e0 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateFromLibrarySourcesTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateFromLibrarySourcesTest.kt
@@ -28,8 +28,8 @@ import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.idea.caches.resolve.KotlinLightClassForDecompiledDeclaration
 import org.jetbrains.kotlin.idea.test.JdkAndMockLibraryProjectDescriptor
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.utils.sure
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
@@ -51,8 +51,8 @@ public class NavigateFromLibrarySourcesTest: LightCodeInsightFixtureTestCase() {
     // This test is not exactly for navigation, but separating it to another class doesn't worth it.
     public fun testLightClassForLibrarySource() {
         val navigationElement = navigationElementForReferenceInLibrarySource("Foo")
-        assertTrue(navigationElement is JetClassOrObject, "Foo should navigate to JetClassOrObject")
-        val lightClass = LightClassUtil.getPsiClass(navigationElement as JetClassOrObject)
+        assertTrue(navigationElement is KtClassOrObject, "Foo should navigate to JetClassOrObject")
+        val lightClass = LightClassUtil.getPsiClass(navigationElement as KtClassOrObject)
         assertTrue(lightClass is KotlinLightClassForDecompiledDeclaration,
                    "Light classes for decompiled declaration should be provided for library source")
         assertEquals("Foo", lightClass!!.getName())
@@ -81,7 +81,7 @@ public class NavigateFromLibrarySourcesTest: LightCodeInsightFixtureTestCase() {
             is PsiClass -> {
                 assertEquals(expectedFqName, element.getQualifiedName())
             }
-            is JetClass -> {
+            is KtClass -> {
                 assertEquals(expectedFqName, element.getFqName()!!.asString())
             }
             else -> {
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToDecompiledLibraryTest.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToDecompiledLibraryTest.java
index 19dd7f92254..bcfb0d94fb6 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToDecompiledLibraryTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToDecompiledLibraryTest.java
@@ -37,8 +37,8 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.test.JdkAndMockLibraryProjectDescriptor;
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase;
 import org.jetbrains.kotlin.idea.decompiler.JetClsFile;
-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 java.util.Map;
 
@@ -101,21 +101,21 @@ public class NavigateToDecompiledLibraryTest extends LightCodeInsightFixtureTest
         PsiFile decompiledPsiFile = PsiManager.getInstance(getProject()).findFile(classFile);
         assertNotNull(decompiledPsiFile);
         assertTrue("Expecting kotlin class file, was: " + decompiledPsiFile.getClass(), decompiledPsiFile instanceof JetClsFile);
-        Map<String, JetDeclaration> map = getRenderedDescriptorToKotlinPsiMap(
-                (JetFile) decompiledPsiFile, ((JetClsFile) decompiledPsiFile).getRenderedDescriptorsToRange()
+        Map<String, KtDeclaration> map = getRenderedDescriptorToKotlinPsiMap(
+                (KtFile) decompiledPsiFile, ((JetClsFile) decompiledPsiFile).getRenderedDescriptorsToRange()
         );
         String decompiledTextWithMarks = getDecompiledTextWithMarks(map);
 
         assertSameLinesWithFile(TEST_DATA_PATH + "/decompiled/" + getTestName(false) + ".kt", decompiledTextWithMarks);
     }
 
-    private String getDecompiledTextWithMarks(Map<String, JetDeclaration> map) {
+    private String getDecompiledTextWithMarks(Map<String, KtDeclaration> map) {
         String decompiledText = getDecompiledText();
 
         int[] openings = new int[decompiledText.length() + 1];
         int[] closings = new int[decompiledText.length() + 1];
-        for (JetDeclaration jetDeclaration : map.values()) {
-            TextRange textRange = jetDeclaration.getTextRange();
+        for (KtDeclaration ktDeclaration : map.values()) {
+            TextRange textRange = ktDeclaration.getTextRange();
             openings[textRange.getStartOffset()]++;
             closings[textRange.getEndOffset()]++;
         }
@@ -138,18 +138,18 @@ public class NavigateToDecompiledLibraryTest extends LightCodeInsightFixtureTest
     }
 
     @NotNull
-    private static Map<String, JetDeclaration> getRenderedDescriptorToKotlinPsiMap(
-            @NotNull JetFile file, @NotNull Map<String, TextRange> renderedDescriptorsToRanges
+    private static Map<String, KtDeclaration> getRenderedDescriptorToKotlinPsiMap(
+            @NotNull KtFile file, @NotNull Map<String, TextRange> renderedDescriptorsToRanges
     ) {
-        Map<String, JetDeclaration> renderedDescriptorsToJetDeclarations = Maps.newHashMap();
+        Map<String, KtDeclaration> renderedDescriptorsToJetDeclarations = Maps.newHashMap();
         for (Map.Entry<String, TextRange> renderedDescriptorToRange : renderedDescriptorsToRanges.entrySet()) {
             String renderedDescriptor = renderedDescriptorToRange.getKey();
             TextRange range = renderedDescriptorToRange.getValue();
-            JetDeclaration jetDeclaration = PsiTreeUtil.findElementOfClassAtRange(file, range.getStartOffset(), range.getEndOffset(),
-                                                                                  JetDeclaration.class);
-            assert jetDeclaration != null : "Can't find declaration at " + range + ": "
-                                            + file.getText().substring(range.getStartOffset(), range.getEndOffset());
-            renderedDescriptorsToJetDeclarations.put(renderedDescriptor, jetDeclaration);
+            KtDeclaration ktDeclaration = PsiTreeUtil.findElementOfClassAtRange(file, range.getStartOffset(), range.getEndOffset(),
+                                                                                KtDeclaration.class);
+            assert ktDeclaration != null : "Can't find declaration at " + range + ": "
+                                           + file.getText().substring(range.getStartOffset(), range.getEndOffset());
+            renderedDescriptorsToJetDeclarations.put(renderedDescriptor, ktDeclaration);
         }
         return renderedDescriptorsToJetDeclarations;
     }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibraryRegressionTest.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibraryRegressionTest.java
index 293af8c2903..6d27258e134 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibraryRegressionTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibraryRegressionTest.java
@@ -24,7 +24,7 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.testFramework.LightProjectDescriptor;
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
 import org.jetbrains.kotlin.idea.test.JetWithJdkAndRuntimeLightProjectDescriptor;
 
@@ -67,7 +67,7 @@ public class NavigateToLibraryRegressionTest extends LightCodeInsightFixtureTest
     }
 
     protected PsiElement configureAndResolve(String text) {
-        myFixture.configureByText(JetFileType.INSTANCE, text);
+        myFixture.configureByText(KotlinFileType.INSTANCE, text);
         PsiReference ref = myFixture.getFile().findReferenceAt(myFixture.getCaretOffset());
         //noinspection ConstantConditions
         return ref.resolve().getNavigationElement();
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToStdlibSourceTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToStdlibSourceTest.kt
index 61e606a6d90..b6e84194e7e 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToStdlibSourceTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToStdlibSourceTest.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.decompiler.navigation
 
 import com.intellij.psi.PsiElement
 import junit.framework.TestCase
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.test.KotlinCodeInsightTestCase
 import org.jetbrains.kotlin.idea.test.ModuleKind
 import org.jetbrains.kotlin.idea.test.closeAndDeleteProject
@@ -62,7 +62,7 @@ public class NavigateToStdlibSourceTest : KotlinCodeInsightTestCase() {
             mainModuleKind: ModuleKind,
             additionalModuleKind: ModuleKind? = null
     ): PsiElement {
-        configureByText(JetFileType.INSTANCE, text)
+        configureByText(KotlinFileType.INSTANCE, text)
         getModule().configureAs(mainModuleKind)
 
         if (additionalModuleKind != null) {
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt
index 9ccc5425922..b42ed38eaae 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt
@@ -25,7 +25,7 @@ import com.intellij.psi.stubs.StubElement
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 import com.intellij.util.indexing.FileContentImpl
 import org.jetbrains.kotlin.idea.stubs.AbstractStubBuilderTest
-import org.jetbrains.kotlin.psi.stubs.elements.JetFileStubBuilder
+import org.jetbrains.kotlin.psi.stubs.elements.KtFileStubBuilder
 import org.jetbrains.kotlin.test.JetTestUtils
 import org.jetbrains.kotlin.test.MockLibraryUtil
 import org.jetbrains.kotlin.utils.addIfNotNull
@@ -44,7 +44,7 @@ public abstract class AbstractClsStubBuilderTest : LightCodeInsightFixtureTestCa
         val stubTreeFromCls = KotlinClsStubBuilder().buildFileStub(FileContentImpl.createByFile(classFile))!!
         myFixture.configureFromExistingVirtualFile(classFile)
         val psiFile = myFixture.getFile()
-        val stubTreeFromDecompiledText = JetFileStubBuilder().buildStubTree(psiFile)
+        val stubTreeFromDecompiledText = KtFileStubBuilder().buildStubTree(psiFile)
         val expectedText = stubTreeFromDecompiledText.serializeToString()
         Assert.assertEquals(expectedText, stubTreeFromCls.serializeToString())
         if (txtFile != null) {
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/StubConsistencyBaseTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/StubConsistencyBaseTest.kt
index 2259a6f6370..78812dabec9 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/StubConsistencyBaseTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/StubConsistencyBaseTest.kt
@@ -22,8 +22,8 @@ import com.intellij.util.indexing.FileContentImpl
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.stubs.elements.JetFileStubBuilder
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.stubs.elements.KtFileStubBuilder
 import org.junit.Assert
 
 public abstract class StubConsistencyBaseTest : JetLightCodeInsightFixtureTestCase() {
@@ -43,8 +43,8 @@ public abstract class StubConsistencyBaseTest : JetLightCodeInsightFixtureTestCa
         val project = getProject()
         val packageFile = getVirtualFileFinder().findVirtualFileWithHeader(id)!!
         val decompiledText = getDecompiledText(packageFile)
-        val fileWithDecompiledText = JetPsiFactory(project).createFile(decompiledText)
-        val stubTreeFromDecompiledText = JetFileStubBuilder().buildStubTree(fileWithDecompiledText)
+        val fileWithDecompiledText = KtPsiFactory(project).createFile(decompiledText)
+        val stubTreeFromDecompiledText = KtFileStubBuilder().buildStubTree(fileWithDecompiledText)
         val expectedText = stubTreeFromDecompiledText.serializeToString()
 
         val fileStub = createStubBuilder().buildFileStub(FileContentImpl.createByFile(packageFile))!!
diff --git a/idea/tests/org/jetbrains/kotlin/idea/editor/quickDoc/QuickDocInCompletionTest.kt b/idea/tests/org/jetbrains/kotlin/idea/editor/quickDoc/QuickDocInCompletionTest.kt
index 01a5a3f35f2..0133dd8619b 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/editor/quickDoc/QuickDocInCompletionTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/editor/quickDoc/QuickDocInCompletionTest.kt
@@ -17,10 +17,10 @@
 package org.jetbrains.kotlin.idea.editor.quickDoc
 
 import com.intellij.testFramework.fixtures.LightPlatformCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.KotlinQuickDocumentationProvider
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
-import org.jetbrains.kotlin.psi.JetClass
+import org.jetbrains.kotlin.psi.KtClass
 import org.junit.Assert
 
 public class QuickDocInCompletionTest(): LightPlatformCodeInsightFixtureTestCase() {
@@ -33,6 +33,6 @@ public class QuickDocInCompletionTest(): LightPlatformCodeInsightFixtureTestCase
         val lookupObject = lookupElements.first().getObject()
         val element = KotlinQuickDocumentationProvider().getDocumentationElementForLookupItem(
                 myFixture.getPsiManager(), lookupObject, null)
-        Assert.assertTrue(element is JetClass)
+        Assert.assertTrue(element is KtClass)
     }
 }
\ No newline at end of file
diff --git a/idea/tests/org/jetbrains/kotlin/idea/editor/quickDoc/QuickDocNavigationTest.kt b/idea/tests/org/jetbrains/kotlin/idea/editor/quickDoc/QuickDocNavigationTest.kt
index 7f443aff854..428d8fcf530 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/editor/quickDoc/QuickDocNavigationTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/editor/quickDoc/QuickDocNavigationTest.kt
@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.idea.editor.quickDoc
 import com.intellij.testFramework.fixtures.LightPlatformCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.KotlinQuickDocumentationProvider
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetFunction
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 import org.junit.Assert
 
@@ -31,10 +31,10 @@ public class QuickDocNavigationTest() : LightPlatformCodeInsightFixtureTestCase(
 
     public fun testSimple() {
         myFixture.configureByFile(getTestName(true) + ".kt")
-        val source = myFixture.getElementAtCaret().getParentOfType<JetFunction>(false)
+        val source = myFixture.getElementAtCaret().getParentOfType<KtFunction>(false)
         val target = KotlinQuickDocumentationProvider().getDocumentationElementForLink(
                 myFixture.getPsiManager(), "C", source);
-        Assert.assertTrue(target is JetClass)
-        Assert.assertEquals("C", (target as JetClass).getName())
+        Assert.assertTrue(target is KtClass)
+        Assert.assertEquals("C", (target as KtClass).getName())
     }
 }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageJsTest.java b/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageJsTest.java
index 671086ea1b6..ad50a96278b 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageJsTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageJsTest.java
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS;
 import org.jetbrains.kotlin.js.config.Config;
 import org.jetbrains.kotlin.js.config.LibrarySourcesConfig;
 import org.jetbrains.kotlin.js.resolve.diagnostics.ErrorsJs;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 
 import java.lang.reflect.Field;
 
@@ -42,7 +42,7 @@ public abstract class AbstractDiagnosticMessageJsTest extends AbstractDiagnostic
 
     @NotNull
     @Override
-    protected AnalysisResult analyze(@NotNull JetFile file) {
+    protected AnalysisResult analyze(@NotNull KtFile file) {
         return TopDownAnalyzerFacadeForJS.analyzeFiles(singletonList(file), getConfig());
     }
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java b/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java
index ed1d41f477b..19a8ed0099a 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages;
 import org.jetbrains.kotlin.idea.highlighter.formatHtml.FormatHtmlUtilKt;
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
@@ -74,7 +74,7 @@ public abstract class AbstractDiagnosticMessageTest extends JetLiteFixture {
     }
 
     @NotNull
-    protected AnalysisResult analyze(@NotNull JetFile file) {
+    protected AnalysisResult analyze(@NotNull KtFile file) {
         return JvmResolveUtil.analyzeOneFileWithJavaIntegration(file);
     }
 
@@ -88,7 +88,7 @@ public abstract class AbstractDiagnosticMessageTest extends JetLiteFixture {
         final Set<DiagnosticFactory<?>> diagnosticFactories = getDiagnosticFactories(directives);
         MessageType messageType = getMessageTypeDirective(directives);
 
-        JetFile psiFile = createPsiFile(null, fileName, loadFile(fileName));
+        KtFile psiFile = createPsiFile(null, fileName, loadFile(fileName));
         AnalysisResult analysisResult = analyze(psiFile);
         BindingContext bindingContext = analysisResult.getBindingContext();
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/NoErrorsInStdlibTest.kt b/idea/tests/org/jetbrains/kotlin/idea/highlighter/NoErrorsInStdlibTest.kt
index 751d2a6ceef..1e5d0e78fe0 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/highlighter/NoErrorsInStdlibTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/NoErrorsInStdlibTest.kt
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
 import org.jetbrains.kotlin.idea.test.JetJdkAndLibraryProjectDescriptor
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import java.io.File
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
@@ -43,7 +43,7 @@ public class NoErrorsInStdlibTest : JetLightCodeInsightFixtureTestCase() {
         VfsUtil.processFileRecursivelyWithoutIgnored(root) { file ->
             if (!file!!.isDirectory()) {
                 val psiFile = psiManager.findFile(file)
-                if (psiFile is JetFile) {
+                if (psiFile is KtFile) {
                     hasAtLeastOneFile = true
                     val bindingContext = psiFile.analyzeFully()
                     val errors = bindingContext.getDiagnostics().all().filter { it.getSeverity() == Severity.ERROR }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/imports/AbstractOptimizeImportsTest.kt b/idea/tests/org/jetbrains/kotlin/idea/imports/AbstractOptimizeImportsTest.kt
index 8213eacb902..4aa7419bf05 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/imports/AbstractOptimizeImportsTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/imports/AbstractOptimizeImportsTest.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.*
 import org.jetbrains.kotlin.psi.*
 
 public abstract class AbstractOptimizeImportsTest() : AbstractImportsTest() {
-    override fun doTest(file: JetFile) {
+    override fun doTest(file: KtFile) {
         KotlinImportOptimizer().processFile(file).run()
     }
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/intentions/AbstractIntentionTest.java b/idea/tests/org/jetbrains/kotlin/idea/intentions/AbstractIntentionTest.java
index d6bdeffee92..a4cee0afc8e 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/intentions/AbstractIntentionTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/intentions/AbstractIntentionTest.java
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.idea.test.DirectiveBasedActionUtils;
 import org.jetbrains.kotlin.idea.test.KotlinCodeInsightTestCase;
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase;
 import org.jetbrains.kotlin.idea.util.application.ApplicationUtilsKt;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.InTextDirectivesUtils;
 import org.junit.Assert;
 
@@ -120,12 +120,12 @@ public abstract class AbstractIntentionTest extends KotlinCodeInsightTestCase {
                 ConfigLibraryUtil.configureKotlinRuntimeAndSdk(getModule(), PluginTestCaseBase.mockJdk());
             }
 
-            DirectiveBasedActionUtils.INSTANCE$.checkForUnexpectedErrors((JetFile) getFile());
+            DirectiveBasedActionUtils.INSTANCE$.checkForUnexpectedErrors((KtFile) getFile());
 
             doTestFor(pathToFile, intentionAction, fileText);
 
             if (InTextDirectivesUtils.isDirectiveDefined(fileText, "// CHECK_ERRORS_AFTER")) {
-                DirectiveBasedActionUtils.INSTANCE$.checkForUnexpectedErrors((JetFile) getFile());
+                DirectiveBasedActionUtils.INSTANCE$.checkForUnexpectedErrors((KtFile) getFile());
             }
         }
         finally {
diff --git a/idea/tests/org/jetbrains/kotlin/idea/internal/AbstractBytecodeToolWindowTest.kt b/idea/tests/org/jetbrains/kotlin/idea/internal/AbstractBytecodeToolWindowTest.kt
index 2d20f259477..4e0a787748a 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/internal/AbstractBytecodeToolWindowTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/internal/AbstractBytecodeToolWindowTest.kt
@@ -16,10 +16,10 @@
 
 package org.jetbrains.kotlin.idea.internal
 
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.JetWithJdkAndRuntimeLightProjectDescriptor
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.io.File
@@ -34,9 +34,9 @@ public abstract class AbstractBytecodeToolWindowTest: JetLightCodeInsightFixture
         mainDir.listFiles { file, name -> name != mainFileName }.forEach { myFixture.configureByFile(testPath + "/" + it.getName()) }
 
         val mainFileText = File("$testPath/$mainFileName").readText()
-        myFixture.configureByText(JetFileType.INSTANCE, mainFileText)
+        myFixture.configureByText(KotlinFileType.INSTANCE, mainFileText)
 
-        val file = myFixture.getFile() as JetFile
+        val file = myFixture.getFile() as KtFile
 
         val enableInline = InTextDirectivesUtils.getPrefixedBoolean(mainFileText, "// INLINE:") ?: true
         val bytecodes = KotlinBytecodeToolWindow.getBytecodeForFile(file, enableInline, true, true)
diff --git a/idea/tests/org/jetbrains/kotlin/idea/javaFacade/JetJavaFacadeTest.java b/idea/tests/org/jetbrains/kotlin/idea/javaFacade/JetJavaFacadeTest.java
index d8232aa07d7..ef5a55d7160 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/javaFacade/JetJavaFacadeTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/javaFacade/JetJavaFacadeTest.java
@@ -209,15 +209,15 @@ public class JetJavaFacadeTest extends JetLightCodeInsightFixtureTestCase {
         PsiReference reference = myFixture.getFile().findReferenceAt(myFixture.getCaretOffset());
         assert reference != null;
         PsiElement element = reference.resolve();
-        assertInstanceOf(element, JetClass.class);
-        JetClass aClass = (JetClass) element;
+        assertInstanceOf(element, KtClass.class);
+        KtClass aClass = (KtClass) element;
 
         PsiClass createdByWrapDelegate = LightClassUtil.INSTANCE$.getPsiClass(aClass);
         assertNull(createdByWrapDelegate);
     }
 
     private void doTestWrapMethod(boolean shouldBeWrapped) {
-        JetNamedFunction jetFunction = getPreparedElement(JetNamedFunction.class);
+        KtNamedFunction jetFunction = getPreparedElement(KtNamedFunction.class);
 
         // Should not fail!
         PsiMethod psiMethod = LightClassUtil.INSTANCE$.getLightClassMethod(jetFunction);
@@ -226,7 +226,7 @@ public class JetJavaFacadeTest extends JetLightCodeInsightFixtureTestCase {
     }
 
     private void doTestWrapParameter(boolean shouldWrapGetter, boolean shouldWrapSetter) {
-        JetParameter jetParameter = getPreparedElement(JetParameter.class);
+        KtParameter jetParameter = getPreparedElement(KtParameter.class);
 
         // Should not fail!
         LightClassUtil.PropertyAccessorsPsiMethods propertyAccessors = LightClassUtil.INSTANCE$.getLightClassPropertyMethods(jetParameter);
@@ -236,7 +236,7 @@ public class JetJavaFacadeTest extends JetLightCodeInsightFixtureTestCase {
     }
 
     private void doTestWrapProperty(boolean shouldWrapGetter, boolean shouldWrapSetter) {
-        JetProperty jetProperty = getPreparedElement(JetProperty.class);
+        KtProperty jetProperty = getPreparedElement(KtProperty.class);
 
         // Should not fail!
         LightClassUtil.PropertyAccessorsPsiMethods propertyAccessors = LightClassUtil.INSTANCE$.getLightClassPropertyMethods(jetProperty);
@@ -246,17 +246,17 @@ public class JetJavaFacadeTest extends JetLightCodeInsightFixtureTestCase {
     }
 
     private void doTestWrapPropertyAccessor(boolean shouldWrapAccessor) {
-        JetPropertyAccessor jetPropertyAccessor = getPreparedElement(JetPropertyAccessor.class);
+        KtPropertyAccessor jetPropertyAccessor = getPreparedElement(KtPropertyAccessor.class);
 
         // Should not fail!
         PsiMethod propertyAccessors = LightClassUtil.INSTANCE$.getLightClassAccessorMethod(jetPropertyAccessor);
         checkDeclarationMethodWrapped(shouldWrapAccessor,
-                                      PsiTreeUtil.getParentOfType(jetPropertyAccessor, JetProperty.class),
+                                      PsiTreeUtil.getParentOfType(jetPropertyAccessor, KtProperty.class),
                                       propertyAccessors);
     }
 
     @NotNull
-    private <T extends JetElement> T getPreparedElement(Class<T> elementClass) {
+    private <T extends KtElement> T getPreparedElement(Class<T> elementClass) {
         myFixture.configureByFile(fileName());
 
         int offset = myFixture.getEditor().getCaretModel().getOffset();
@@ -273,7 +273,7 @@ public class JetJavaFacadeTest extends JetLightCodeInsightFixtureTestCase {
         return caretElement;
     }
 
-    private static void checkDeclarationMethodWrapped(boolean shouldBeWrapped, JetDeclaration declaration, PsiMethod psiMethod) {
+    private static void checkDeclarationMethodWrapped(boolean shouldBeWrapped, KtDeclaration declaration, PsiMethod psiMethod) {
         if (shouldBeWrapped) {
             assertNotNull(String.format("Failed to wrap declaration '%s' to method", declaration.getText()), psiMethod);
             assertInstanceOf(psiMethod, KotlinLightMethod.class);
@@ -292,13 +292,13 @@ public class JetJavaFacadeTest extends JetLightCodeInsightFixtureTestCase {
 
         assertNotNull("Caret should be set for tested file", elementAt);
 
-        JetClass jetClass = PsiTreeUtil.getParentOfType(elementAt, JetClass.class);
-        assertNotNull("Caret should be placed to class definition", jetClass);
+        KtClass ktClass = PsiTreeUtil.getParentOfType(elementAt, KtClass.class);
+        assertNotNull("Caret should be placed to class definition", ktClass);
 
         // Should not fail!
-        KotlinLightClass lightClass = (KotlinLightClass) LightClassUtil.INSTANCE$.getPsiClass(jetClass);
+        KotlinLightClass lightClass = (KotlinLightClass) LightClassUtil.INSTANCE$.getPsiClass(ktClass);
 
-        assertNotNull(String.format("Failed to wrap jetClass '%s' to class", jetClass.getText()), lightClass);
+        assertNotNull(String.format("Failed to wrap jetClass '%s' to class", ktClass.getText()), lightClass);
 
         // This invokes codegen with ClassBuilderMode = LIGHT_CLASSES
         // No exception/error should happen here
diff --git a/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocFinderTest.kt b/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocFinderTest.kt
index 93426e8eb56..ad4a83be57a 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocFinderTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocFinderTest.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.junit.Assert
 
 public class KDocFinderTest() : LightPlatformCodeInsightFixtureTestCase() {
@@ -32,7 +32,7 @@ public class KDocFinderTest() : LightPlatformCodeInsightFixtureTestCase() {
 
     public fun testConstructor() {
         myFixture.configureByFile(getTestName(false) + ".kt")
-        val declaration = (myFixture.getFile() as JetFile).getDeclarations()[0]
+        val declaration = (myFixture.getFile() as KtFile).getDeclarations()[0]
         val descriptor = declaration.resolveToDescriptor() as ClassDescriptor
         val constructorDescriptor = descriptor.getUnsubstitutedPrimaryConstructor()!!
         val doc = KDocFinder.findKDoc(constructorDescriptor)
@@ -41,7 +41,7 @@ public class KDocFinderTest() : LightPlatformCodeInsightFixtureTestCase() {
 
     public fun testOverridden() {
         myFixture.configureByFile(getTestName(false) + ".kt")
-        val declaration = (myFixture.getFile() as JetFile).getDeclarations().single { it.getName() == "Bar" }
+        val declaration = (myFixture.getFile() as KtFile).getDeclarations().single { it.getName() == "Bar" }
         val descriptor = declaration.resolveToDescriptor() as ClassDescriptor
         val overriddenFunctionDescriptor = descriptor.defaultType.memberScope.getFunctions(Name.identifier("xyzzy"), NoLookupLocation.FROM_TEST).single()
         val doc = KDocFinder.findKDoc(overriddenFunctionDescriptor)
@@ -50,7 +50,7 @@ public class KDocFinderTest() : LightPlatformCodeInsightFixtureTestCase() {
 
     public fun testOverriddenWithSubstitutedType() {
         myFixture.configureByFile(getTestName(false) + ".kt")
-        val declaration = (myFixture.getFile() as JetFile).getDeclarations().single { it.getName() == "Bar" }
+        val declaration = (myFixture.getFile() as KtFile).getDeclarations().single { it.getName() == "Bar" }
         val descriptor = declaration.resolveToDescriptor() as ClassDescriptor
         val overriddenFunctionDescriptor = descriptor.defaultType.memberScope.getFunctions(Name.identifier("xyzzy"), NoLookupLocation.FROM_TEST).single()
         val doc = KDocFinder.findKDoc(overriddenFunctionDescriptor)
@@ -59,7 +59,7 @@ public class KDocFinderTest() : LightPlatformCodeInsightFixtureTestCase() {
 
     public fun testProperty() {
         myFixture.configureByFile(getTestName(false) + ".kt")
-        val declaration = (myFixture.getFile() as JetFile).getDeclarations().single { it.getName() == "Foo" }
+        val declaration = (myFixture.getFile() as KtFile).getDeclarations().single { it.getName() == "Foo" }
         val descriptor = declaration.resolveToDescriptor() as ClassDescriptor
         val propertyDescriptor = descriptor.defaultType.memberScope.getProperties(Name.identifier("xyzzy"), NoLookupLocation.FROM_TEST).single()
         val doc = KDocFinder.findKDoc(propertyDescriptor)
diff --git a/idea/tests/org/jetbrains/kotlin/idea/lightClasses/LightClassEqualsTest.java b/idea/tests/org/jetbrains/kotlin/idea/lightClasses/LightClassEqualsTest.java
index 55ab84735d2..6ccc02f01ea 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/lightClasses/LightClassEqualsTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/lightClasses/LightClassEqualsTest.java
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.asJava.LightClassUtil;
 import org.jetbrains.kotlin.idea.caches.resolve.KotlinLightClassForDecompiledDeclaration;
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase;
 import org.jetbrains.kotlin.idea.test.JetWithJdkAndRuntimeLightProjectDescriptor;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
 
 public class LightClassEqualsTest extends JetLightCodeInsightFixtureTestCase {
     @NotNull
@@ -55,7 +55,7 @@ public class LightClassEqualsTest extends JetLightCodeInsightFixtureTestCase {
         doTestEquals(((KotlinLightClass) theClass).getOrigin());
     }
 
-    private static void doTestEquals(@Nullable JetClassOrObject origin) {
+    private static void doTestEquals(@Nullable KtClassOrObject origin) {
         assertNotNull(origin);
 
         PsiClass lightClass1 = LightClassUtil.INSTANCE$.getPsiClass(origin);
diff --git a/idea/tests/org/jetbrains/kotlin/idea/navigation/AbstractGotoSuperTest.java b/idea/tests/org/jetbrains/kotlin/idea/navigation/AbstractGotoSuperTest.java
index 456f8a96f2d..4920b49f5ea 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/navigation/AbstractGotoSuperTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/navigation/AbstractGotoSuperTest.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.navigation;
 import com.intellij.codeInsight.CodeInsightActionHandler;
 import com.intellij.openapi.actionSystem.ActionManager;
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.test.JetTestUtils;
 
 import java.util.List;
@@ -28,7 +28,7 @@ public abstract class AbstractGotoSuperTest extends LightCodeInsightFixtureTestC
     protected void doTest(String testPath) {
         List<String> parts = JetTestUtils.loadBeforeAfterText(testPath);
 
-        myFixture.configureByText(JetFileType.INSTANCE, parts.get(0));
+        myFixture.configureByText(KotlinFileType.INSTANCE, parts.get(0));
 
         CodeInsightActionHandler gotoSuperAction = (CodeInsightActionHandler) ActionManager.getInstance().getAction("GotoSuperMethod");
         gotoSuperAction.invoke(getProject(), myFixture.getEditor(), myFixture.getFile());
diff --git a/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/AbstractParameterInfoTest.kt b/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/AbstractParameterInfoTest.kt
index 77e1aeb143f..2663353fcc8 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/AbstractParameterInfoTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/AbstractParameterInfoTest.kt
@@ -26,8 +26,8 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import org.jetbrains.kotlin.idea.test.ProjectDescriptorWithStdlibSources
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.allChildren
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.junit.Assert
@@ -43,12 +43,12 @@ abstract class AbstractParameterInfoTest : LightCodeInsightFixtureTestCase() {
     protected fun doTest(fileName: String) {
         myFixture.configureByFile(fileName)
 
-        val file = myFixture.file as JetFile
+        val file = myFixture.file as KtFile
 
         val lastChild = file.allChildren.filter { it !is PsiWhiteSpace }.last()
         val expectedResultText = when (lastChild.node.elementType) {
-            JetTokens.BLOCK_COMMENT -> lastChild.text.substring(2, lastChild.text.length() - 2).trim()
-            JetTokens.EOL_COMMENT -> lastChild.text.substring(2).trim()
+            KtTokens.BLOCK_COMMENT -> lastChild.text.substring(2, lastChild.text.length() - 2).trim()
+            KtTokens.EOL_COMMENT -> lastChild.text.substring(2).trim()
             else -> error("Unexpected last file child")
         }
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiFileTest.java b/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiFileTest.java
index 652fc3b2f07..f14dd074120 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiFileTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiFileTest.java
@@ -39,13 +39,13 @@ import kotlin.ArraysKt;
 import kotlin.CollectionsKt;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.idea.KotlinDaemonAnalyzerTestCase;
 import org.jetbrains.kotlin.idea.quickfix.utils.QuickfixTestUtilsKt;
 import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil;
 import org.jetbrains.kotlin.idea.test.DirectiveBasedActionUtils;
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.InTextDirectivesUtils;
 import org.jetbrains.kotlin.test.JetTestUtils;
 
@@ -163,10 +163,10 @@ public abstract class AbstractQuickFixMultiFileTest extends KotlinDaemonAnalyzer
         subFiles.remove(beforeFile);
 
         for (TestFile file : subFiles) {
-            configureByText(JetFileType.INSTANCE, file.content);
+            configureByText(KotlinFileType.INSTANCE, file.content);
         }
 
-        configureByText(JetFileType.INSTANCE, beforeFile.content);
+        configureByText(KotlinFileType.INSTANCE, beforeFile.content);
 
         CommandProcessor.getInstance().executeCommand(getProject(), new Runnable() {
             @Override
@@ -179,8 +179,8 @@ public abstract class AbstractQuickFixMultiFileTest extends KotlinDaemonAnalyzer
 
                     boolean actionShouldBeAvailable = pair.getSecond();
 
-                    if (psiFile instanceof JetFile) {
-                        DirectiveBasedActionUtils.INSTANCE$.checkForUnexpectedErrors((JetFile) psiFile);
+                    if (psiFile instanceof KtFile) {
+                        DirectiveBasedActionUtils.INSTANCE$.checkForUnexpectedErrors((KtFile) psiFile);
                     }
 
                     doAction(text, actionShouldBeAvailable, getTestName(false));
@@ -269,8 +269,8 @@ public abstract class AbstractQuickFixMultiFileTest extends KotlinDaemonAnalyzer
 
                         boolean actionShouldBeAvailable = pair.getSecond();
 
-                        if (psiFile instanceof JetFile) {
-                            DirectiveBasedActionUtils.INSTANCE$.checkForUnexpectedErrors((JetFile) psiFile);
+                        if (psiFile instanceof KtFile) {
+                            DirectiveBasedActionUtils.INSTANCE$.checkForUnexpectedErrors((KtFile) psiFile);
                         }
 
                         doAction(text, actionShouldBeAvailable, beforeFileName);
diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixTest.java b/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixTest.java
index 8ff18fca1d1..b65f77d77e2 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixTest.java
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.idea.quickfix.utils.QuickfixTestUtilsKt;
 import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil;
 import org.jetbrains.kotlin.idea.test.DirectiveBasedActionUtils;
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.InTextDirectivesUtils;
 import org.jetbrains.kotlin.test.TestMetadata;
 import org.junit.Assert;
@@ -206,13 +206,13 @@ public abstract class AbstractQuickFixTest extends KotlinLightQuickFixTestCase {
             }
             else {
                 // Action shouldn't be found. Check that other actions are expected and thus tested action isn't there under another name.
-                DirectiveBasedActionUtils.INSTANCE$.checkAvailableActionsAreExpected((JetFile) getFile(), actions);
+                DirectiveBasedActionUtils.INSTANCE$.checkAvailableActionsAreExpected((KtFile) getFile(), actions);
             }
         }
     }
 
     public static void checkForUnexpectedErrors() {
-        DirectiveBasedActionUtils.INSTANCE$.checkForUnexpectedErrors((JetFile) getFile());
+        DirectiveBasedActionUtils.INSTANCE$.checkForUnexpectedErrors((KtFile) getFile());
     }
 
     @Override
diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageFixSpecialTest.kt b/idea/tests/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageFixSpecialTest.kt
index f7d2d13cb61..b99c0ab19ec 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageFixSpecialTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageFixSpecialTest.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.idea.quickfix.replaceWith.ReplaceWith
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.ProjectDescriptorWithStdlibSources
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.psiUtil.parents
 import org.jetbrains.kotlin.test.JUnit3RunnerWithInners
 import org.jetbrains.kotlin.test.JetTestUtils
@@ -53,7 +53,7 @@ public class DeprecatedSymbolUsageFixSpecialTest : JetLightCodeInsightFixtureTes
 
         val offset = getEditor().caretModel.offset
         val element = getFile().findElementAt(offset)
-        val nameExpression = element!!.parents.firstIsInstance<JetSimpleNameExpression>()
+        val nameExpression = element!!.parents.firstIsInstance<KtSimpleNameExpression>()
         getProject().executeWriteCommand("") {
             DeprecatedSymbolUsageFix(nameExpression, ReplaceWith(pattern, emptyList())).invoke(getProject(), getEditor(), getFile())
         }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureTest.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureTest.java
index 99eb03c0e84..189eb96b264 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureTest.java
@@ -120,7 +120,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
     public void testAddConstructorVisibility() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
         changeInfo.setNewVisibility(Visibilities.PROTECTED);
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                                              -1, "x", BUILT_INS.getAnyType(),
                                                              null, psiFactory.createExpression("12"), JetValVar.Val, null);
@@ -197,7 +197,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
         changeInfo.setNewVisibility(Visibilities.INTERNAL);
         changeInfo.setNewParameter(2, changeInfo.getNewParameters()[1]);
         changeInfo.setNewParameter(1, changeInfo.getNewParameters()[0]);
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         JetParameterInfo newParameter =
                 new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                      -1, "x0", BUILT_INS.getNullableAnyType(), null, psiFactory.createExpression("null"), JetValVar.None, null);
@@ -246,7 +246,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
     private void doTestUnmodifiableCheck() throws Exception {
         try {
             JetChangeInfo changeInfo = getChangeInfo();
-            JetElement method = (JetElement) changeInfo.getMethod();
+            KtElement method = (KtElement) changeInfo.getMethod();
             JetChangeSignatureConfiguration empty = new JetChangeSignatureConfiguration() {
                 @NotNull
                 @Override
@@ -321,7 +321,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
     public void testEnumEntriesWithoutSuperCalls() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         JetParameterInfo newParameter =
                 new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                      -1, "n", BUILT_INS.getIntType(), null, psiFactory.createExpression("1"), JetValVar.None, null);
@@ -339,7 +339,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
     public void testConstructorJavaUsages() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         JetParameterInfo newParameter =
                 new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                      -1, "s", BUILT_INS.getStringType(), null, psiFactory.createExpression("\"abc\""), JetValVar.None, null);
@@ -349,7 +349,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
     public void testFunctionJavaUsagesAndOverridesAddParam() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         changeInfo.addParameter(
                 new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                      -1, "s", BUILT_INS.getStringType(), null, psiFactory.createExpression("\"abc\""),
@@ -638,7 +638,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
     public void testAddNewReceiver() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         JetParameterInfo parameterInfo =
                 new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                      -1, "_", BUILT_INS.getAnyType(), null, psiFactory.createExpression("X(0)"), JetValVar.None, null);
@@ -649,7 +649,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
     public void testAddNewReceiverForMember() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         JetParameterInfo parameterInfo =
                 new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                      -1, "_", BUILT_INS.getAnyType(), null, psiFactory.createExpression("X(0)"), JetValVar.None, null);
@@ -660,7 +660,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
     public void testAddNewReceiverForMemberConflict() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         JetParameterInfo parameterInfo =
                 new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                      -1, "_", BUILT_INS.getAnyType(), null, psiFactory.createExpression("X(0)"), JetValVar.None, null);
@@ -671,7 +671,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
     public void testAddNewReceiverConflict() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         JetParameterInfo parameterInfo =
                 new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                      -1, "_", BUILT_INS.getAnyType(), null, psiFactory.createExpression("X(0)"), JetValVar.None, null);
@@ -785,7 +785,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
     public void testSecondaryConstructor() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         changeInfo.addParameter(
                 new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                      -1, "s", BUILT_INS.getStringType(), null, psiFactory.createExpression("\"foo\""),
@@ -813,7 +813,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
     public void testPrimaryConstructorByThisRef() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         changeInfo.addParameter(
                 new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                      -1, "s", BUILT_INS.getStringType(), null, psiFactory.createExpression("\"foo\""), JetValVar.None, null)
@@ -823,7 +823,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
     public void testPrimaryConstructorBySuperRef() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         changeInfo.addParameter(
                 new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                      -1, "s", BUILT_INS.getStringType(), null, psiFactory.createExpression("\"foo\""), JetValVar.None, null)
@@ -833,7 +833,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
     public void testSecondaryConstructorByThisRef() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         changeInfo.addParameter(
                 new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                      -1, "s", BUILT_INS.getStringType(), null, psiFactory.createExpression("\"foo\""), JetValVar.None, null)
@@ -843,7 +843,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
     public void testSecondaryConstructorBySuperRef() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         changeInfo.addParameter(
                 new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                      -1, "s", BUILT_INS.getStringType(), null, psiFactory.createExpression("\"foo\""), JetValVar.None, null)
@@ -871,7 +871,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
     public void testNoConflictWithReceiverName() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         changeInfo.addParameter(
                 new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                      -1, "i", BUILT_INS.getIntType(), null, psiFactory.createExpression("0"), JetValVar.None, null)
@@ -954,7 +954,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
     public void testPrimaryConstructorByRef() throws Exception {
         JetChangeInfo changeInfo = getChangeInfo();
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
         JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                                              -1, "n", BUILT_INS.getIntType(), null,
                                                              psiFactory.createExpression("1"), JetValVar.None, null);
@@ -1038,7 +1038,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
         JetChangeInfo changeInfo = getChangeInfo();
         JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                                              -1, "receiver", BUILT_INS.getStringType(), null,
-                                                             new JetPsiFactory(getProject()).createExpression("\"\""), JetValVar.None, null);
+                                                             new KtPsiFactory(getProject()).createExpression("\"\""), JetValVar.None, null);
         changeInfo.setReceiverParameterInfo(newParameter);
         doTestConflict(changeInfo);
     }
@@ -1047,7 +1047,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
         JetChangeInfo changeInfo = getChangeInfo();
         JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                                              -1, "receiver", BUILT_INS.getStringType(), null,
-                                                             new JetPsiFactory(getProject()).createExpression("\"\""), JetValVar.None, null);
+                                                             new KtPsiFactory(getProject()).createExpression("\"\""), JetValVar.None, null);
         changeInfo.setReceiverParameterInfo(newParameter);
         doTest(changeInfo);
     }
@@ -1069,7 +1069,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
         JetChangeInfo changeInfo = getChangeInfo();
         JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                                              -1, "receiver", null, null,
-                                                             new JetPsiFactory(getProject()).createExpression("A()"), JetValVar.None, null);
+                                                             new KtPsiFactory(getProject()).createExpression("A()"), JetValVar.None, null);
         newParameter.setCurrentTypeText("test.A");
         changeInfo.setReceiverParameterInfo(newParameter);
         doTest(changeInfo);
@@ -1099,30 +1099,30 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
         JetChangeInfo changeInfo = getChangeInfo();
 
         JetParameterInfo newParameter1 = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
-                                                             -1, "n", null, null,
-                                                             new JetPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
+                                                              -1, "n", null, null,
+                                                              new KtPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
         newParameter1.setCurrentTypeText("kotlin.Int");
         changeInfo.addParameter(newParameter1);
 
         JetParameterInfo newParameter2 = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                                               -1, "s", null, null,
-                                                              new JetPsiFactory(getProject()).createExpression("\"abc\""), JetValVar.None, null);
+                                                              new KtPsiFactory(getProject()).createExpression("\"abc\""), JetValVar.None, null);
         newParameter2.setCurrentTypeText("kotlin.String");
         changeInfo.addParameter(newParameter2);
 
-        JetClassOrObject classA =
+        KtClassOrObject classA =
                 JetFullClassNameIndex.getInstance().get("A", getProject(), GlobalSearchScope.allScope(getProject()))
                         .iterator().next();
-        JetDeclaration functionBar = CollectionsKt.first(
+        KtDeclaration functionBar = CollectionsKt.first(
                 classA.getDeclarations(),
-                new Function1<JetDeclaration, Boolean>() {
+                new Function1<KtDeclaration, Boolean>() {
                     @Override
-                    public Boolean invoke(JetDeclaration declaration) {
-                        return declaration instanceof JetNamedFunction && "bar".equals(declaration.getName());
+                    public Boolean invoke(KtDeclaration declaration) {
+                        return declaration instanceof KtNamedFunction && "bar".equals(declaration.getName());
                     }
                 }
         );
-        JetNamedFunction functionTest =
+        KtNamedFunction functionTest =
                 JetTopLevelFunctionFqnNameIndex.getInstance().get("test", getProject(), GlobalSearchScope.allScope(getProject()))
                         .iterator().next();
 
@@ -1168,7 +1168,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
                                     }
                                 }
                         );
-                        JetNamedFunction functionTest =
+                        KtNamedFunction functionTest =
                                 JetTopLevelFunctionFqnNameIndex.getInstance().get("test", getProject(), GlobalSearchScope.allScope(getProject()))
                                         .iterator().next();
 
@@ -1183,10 +1183,10 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
         JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                                              -1, "n", BUILT_INS.getIntType(), null,
-                                                             new JetPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
+                                                             new KtPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
         changeInfo.addParameter(newParameter);
 
-        JetNamedFunction functionBar =
+        KtNamedFunction functionBar =
                 JetTopLevelFunctionFqnNameIndex.getInstance().get("bar", getProject(), GlobalSearchScope.allScope(getProject()))
                         .iterator().next();
 
@@ -1200,10 +1200,10 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
         JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                                              -1, "n", BUILT_INS.getIntType(), null,
-                                                             new JetPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
+                                                             new KtPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
         changeInfo.addParameter(newParameter);
 
-        JetNamedFunction functionBar =
+        KtNamedFunction functionBar =
                 JetTopLevelFunctionFqnNameIndex.getInstance().get("bar", getProject(), GlobalSearchScope.allScope(getProject()))
                         .iterator().next();
 
@@ -1217,18 +1217,18 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
         JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                                              -1, "n", BUILT_INS.getIntType(), null,
-                                                             new JetPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
+                                                             new KtPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
         changeInfo.addParameter(newParameter);
 
-        JetClassOrObject classA =
+        KtClassOrObject classA =
                 JetFullClassNameIndex.getInstance().get("A", getProject(), GlobalSearchScope.allScope(getProject()))
                         .iterator().next();
-        JetDeclaration functionBar = CollectionsKt.first(
+        KtDeclaration functionBar = CollectionsKt.first(
                 classA.getDeclarations(),
-                new Function1<JetDeclaration, Boolean>() {
+                new Function1<KtDeclaration, Boolean>() {
                     @Override
-                    public Boolean invoke(JetDeclaration declaration) {
-                        return declaration instanceof JetNamedFunction && "bar".equals(declaration.getName());
+                    public Boolean invoke(KtDeclaration declaration) {
+                        return declaration instanceof KtNamedFunction && "bar".equals(declaration.getName());
                     }
                 }
         );
@@ -1242,10 +1242,10 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
         JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                                              -1, "n", BUILT_INS.getIntType(), null,
-                                                             new JetPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
+                                                             new KtPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
         changeInfo.addParameter(newParameter);
 
-        JetNamedFunction functionBar =
+        KtNamedFunction functionBar =
                 JetTopLevelFunctionFqnNameIndex.getInstance().get("bar", getProject(), GlobalSearchScope.allScope(getProject()))
                         .iterator().next();
 
@@ -1277,7 +1277,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
         JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                                              -1, "n", BUILT_INS.getIntType(), null,
-                                                             new JetPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
+                                                             new KtPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
         changeInfo.addParameter(newParameter);
 
         PsiMethod constructor = LightClassUtilsKt.getRepresentativeLightMethod(changeInfo.getMethod());
@@ -1292,7 +1292,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
 
         JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
                                                              -1, "n", BUILT_INS.getIntType(), null,
-                                                             new JetPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
+                                                             new KtPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
         changeInfo.addParameter(newParameter);
 
         PsiMethod constructor = LightClassUtilsKt.getRepresentativeLightMethod(changeInfo.getMethod());
@@ -1394,7 +1394,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
         PsiFile file = getFile();
         Project project = getProject();
 
-        JetElement element = (JetElement) new JetChangeSignatureHandler().findTargetMember(file, editor);
+        KtElement element = (KtElement) new JetChangeSignatureHandler().findTargetMember(file, editor);
         assertNotNull("Target element is null", element);
 
         BindingContext bindingContext = ResolutionUtils.analyze(element, BodyResolveMode.FULL);
@@ -1480,8 +1480,8 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
             setActiveEditor(editor);
             PsiFile currentFile = getFile();
             checkResultByFile(currentFile.getName().replace("Before.", "After."));
-            if (checkErrorsAfter && currentFile instanceof JetFile) {
-                DirectiveBasedActionUtils.INSTANCE$.checkForUnexpectedErrors((JetFile) currentFile);
+            if (checkErrorsAfter && currentFile instanceof KtFile) {
+                DirectiveBasedActionUtils.INSTANCE$.checkForUnexpectedErrors((KtFile) currentFile);
             }
         }
     }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractJetExtractionTest.kt b/idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractJetExtractionTest.kt
index c14de0d2a12..f378a315baf 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractJetExtractionTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractJetExtractionTest.kt
@@ -48,8 +48,8 @@ import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.JetTestUtils
@@ -66,7 +66,7 @@ public abstract class AbstractJetExtractionTest() : JetLightCodeInsightFixtureTe
 
     protected fun doIntroduceVariableTest(path: String) {
         doTest(path) { file ->
-            file as JetFile
+            file as KtFile
 
             KotlinIntroduceVariableHandler().invoke(
                     fixture.getProject(),
@@ -107,7 +107,7 @@ public abstract class AbstractJetExtractionTest() : JetLightCodeInsightFixtureTe
                 KotlinIntroduceParameterHandler(HelperImpl())
             }
             with (handler) {
-                val target = (file as JetFile).findElementByCommentPrefix("// TARGET:") as? JetNamedDeclaration
+                val target = (file as KtFile).findElementByCommentPrefix("// TARGET:") as? KtNamedDeclaration
                 if (target != null) {
                     JetRefactoringUtil.selectExpression(fixture.getEditor(), file, true) { expression ->
                         invoke(fixture.getProject(), fixture.getEditor(), expression!!, target)
@@ -204,7 +204,7 @@ public abstract class AbstractJetExtractionTest() : JetLightCodeInsightFixtureTe
 
     protected fun doIntroducePropertyTest(path: String) {
         doTest(path) { file ->
-            file as JetFile
+            file as KtFile
 
             val extractionTarget = propertyTargets.single {
                 it.targetName == InTextDirectivesUtils.findStringWithPrefixes(file.getText(), "// EXTRACTION_TARGET: ")
@@ -236,7 +236,7 @@ public abstract class AbstractJetExtractionTest() : JetLightCodeInsightFixtureTe
 
     protected fun doExtractFunctionTest(path: String) {
         doTest(path) { file ->
-            file as JetFile
+            file as KtFile
 
             val explicitPreviousSibling = file.findElementByCommentPrefix("// SIBLING:")
             val fileText = file.getText() ?: ""
diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/move/AbstractJetMoveTest.kt b/idea/tests/org/jetbrains/kotlin/idea/refactoring/move/AbstractJetMoveTest.kt
index a6316e66506..b5ea03e1fed 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/move/AbstractJetMoveTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/move/AbstractJetMoveTest.kt
@@ -51,8 +51,8 @@ import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil
 import org.jetbrains.kotlin.idea.test.KotlinMultiFileTestCase
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.io.File
@@ -246,7 +246,7 @@ enum class MoveAction {
     MOVE_KOTLIN_TOP_LEVEL_DECLARATIONS {
         override fun runRefactoring(rootDir: VirtualFile, mainFile: PsiFile, elementAtCaret: PsiElement?, config: JsonObject) {
             val project = mainFile.getProject()
-            val elementToMove = elementAtCaret!!.getNonStrictParentOfType<JetNamedDeclaration>()!!
+            val elementToMove = elementAtCaret!!.getNonStrictParentOfType<KtNamedDeclaration>()!!
 
             val moveTarget = config.getNullableString("targetPackage")?.let { packageName ->
                 DeferredJetFileKotlinMoveTarget(project, FqName(packageName)) {
@@ -254,7 +254,7 @@ enum class MoveAction {
                     createKotlinFile(guessNewFileName(listOf(elementToMove))!!, moveDestination.getTargetDirectory(mainFile))
                 }
             } ?: config.getString("targetFile").let { filePath ->
-                JetFileKotlinMoveTarget(PsiManager.getInstance(project).findFile(rootDir.findFileByRelativePath(filePath)!!) as JetFile)
+                JetFileKotlinMoveTarget(PsiManager.getInstance(project).findFile(rootDir.findFileByRelativePath(filePath)!!) as KtFile)
             }
 
             val options = MoveKotlinTopLevelDeclarationsOptions(listOf(elementToMove), moveTarget)
@@ -264,7 +264,7 @@ enum class MoveAction {
 
     CHANGE_PACKAGE_DIRECTIVE {
         override fun runRefactoring(rootDir: VirtualFile, mainFile: PsiFile, elementAtCaret: PsiElement?, config: JsonObject) {
-            KotlinChangePackageRefactoring(mainFile as JetFile).run(FqName(config.getString("newPackageName")))
+            KotlinChangePackageRefactoring(mainFile as KtFile).run(FqName(config.getString("newPackageName")))
         }
     },
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/nameSuggester/JetNameSuggesterTest.kt b/idea/tests/org/jetbrains/kotlin/idea/refactoring/nameSuggester/JetNameSuggesterTest.kt
index d051d1631b0..8b24c697e6f 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/nameSuggester/JetNameSuggesterTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/nameSuggester/JetNameSuggesterTest.kt
@@ -22,8 +22,8 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.test.JetTestUtils
 import kotlin.test.assertEquals
@@ -64,11 +64,11 @@ public class JetNameSuggesterTest : LightCodeInsightFixtureTestCase() {
 
     private fun doTest() {
         myFixture.configureByFile(getTestName(false) + ".kt")
-        val file = myFixture.getFile() as JetFile
+        val file = myFixture.getFile() as KtFile
         val expectedResultText = JetTestUtils.getLastCommentInFile(file)
         try {
             JetRefactoringUtil.selectExpression(myFixture.getEditor(), file, object : JetRefactoringUtil.SelectExpressionCallback {
-                override fun run(expression: JetExpression?) {
+                override fun run(expression: KtExpression?) {
                     val names = KotlinNameSuggester.suggestNamesByExpressionAndType(expression!!, expression.analyze(BodyResolveMode.PARTIAL), { true }, "value").sorted()
                     val result = StringUtil.join(names, "\n").trim()
                     assertEquals(expectedResultText, result)
diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/AbstractRenameTest.kt b/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/AbstractRenameTest.kt
index 4d1834c20da..925d36699c4 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/AbstractRenameTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/AbstractRenameTest.kt
@@ -52,10 +52,10 @@ import org.jetbrains.kotlin.idea.test.KotlinMultiFileTestCase
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.*
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.serialization.deserialization.findClassAcrossModuleDependencies
 import org.junit.Assert
 import java.io.File
@@ -116,7 +116,7 @@ public abstract class AbstractRenameTest : KotlinMultiFileTestCase() {
                 val psiManager = PsiManager.getInstance(myProject)
                 val visitor = object : VirtualFileVisitor<Any>() {
                     override fun visitFile(file: VirtualFile): Boolean {
-                        (psiManager.findFile(file) as? JetFile)?.let { DirectiveBasedActionUtils.checkForUnexpectedErrors(it) }
+                        (psiManager.findFile(file) as? KtFile)?.let { DirectiveBasedActionUtils.checkForUnexpectedErrors(it) }
                         return true
                     }
                 }
@@ -221,7 +221,7 @@ public abstract class AbstractRenameTest : KotlinMultiFileTestCase() {
         doTestCommittingDocuments { rootDir, rootAfter ->
             val mainFile = rootDir.findChild(mainFilePath)!!
             val document = FileDocumentManager.getInstance().getDocument(mainFile)!!
-            val jetFile = PsiDocumentManager.getInstance(context.project).getPsiFile(document) as JetFile
+            val jetFile = PsiDocumentManager.getInstance(context.project).getPsiFile(document) as KtFile
 
             val fileFqn = jetFile.getPackageFqName()
             Assert.assertTrue("File '${mainFilePath}' should have package containing ${fqn}", fileFqn.isSubpackageOf(fqn))
@@ -263,7 +263,7 @@ public abstract class AbstractRenameTest : KotlinMultiFileTestCase() {
     }
 
     private fun doRenameInKotlinClassOrPackage(
-            renameParamsObject: JsonObject, context: TestContext, findDescriptorToRename: (JetScope) -> DeclarationDescriptor
+            renameParamsObject: JsonObject, context: TestContext, findDescriptorToRename: (KtScope) -> DeclarationDescriptor
     ) {
         val classIdStr = renameParamsObject.getNullableString("classId")
         val packageFqnStr = renameParamsObject.getNullableString("packageFqn")
@@ -280,7 +280,7 @@ public abstract class AbstractRenameTest : KotlinMultiFileTestCase() {
         doTestCommittingDocuments { rootDir, rootAfter ->
             val mainFile = rootDir.findChild(mainFilePath)!!
             val document = FileDocumentManager.getInstance().getDocument(mainFile)!!
-            val jetFile = PsiDocumentManager.getInstance(context.project).getPsiFile(document) as JetFile
+            val jetFile = PsiDocumentManager.getInstance(context.project).getPsiFile(document) as KtFile
 
             val module = jetFile.analyzeFullyAndGetResult().moduleDescriptor
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractAdditionalResolveDescriptorRendererTest.kt b/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractAdditionalResolveDescriptorRendererTest.kt
index c7485b32ac7..c49d608457a 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractAdditionalResolveDescriptorRendererTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractAdditionalResolveDescriptorRendererTest.kt
@@ -21,9 +21,9 @@ import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.project.IdeaEnvironment
 import org.jetbrains.kotlin.idea.project.ResolveElementCache
-import org.jetbrains.kotlin.psi.JetClassInitializer
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetPsiUtil
+import org.jetbrains.kotlin.psi.KtClassInitializer
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtPsiUtil
 import org.jetbrains.kotlin.renderer.AbstractDescriptorRendererTest
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.TargetEnvironment
@@ -31,8 +31,8 @@ import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 
 public abstract class AbstractAdditionalResolveDescriptorRendererTest : AbstractDescriptorRendererTest() {
-    override fun getDescriptor(declaration: JetDeclaration, container: ComponentProvider): DeclarationDescriptor {
-        if (declaration is JetClassInitializer || JetPsiUtil.isLocal(declaration)) {
+    override fun getDescriptor(declaration: KtDeclaration, container: ComponentProvider): DeclarationDescriptor {
+        if (declaration is KtClassInitializer || KtPsiUtil.isLocal(declaration)) {
             return container.get<ResolveElementCache>()
                     .resolveToElement(declaration, BodyResolveMode.FULL)
                     .get(BindingContext.DECLARATION_TO_DESCRIPTOR, declaration)!!
diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractPartialBodyResolveTest.kt b/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractPartialBodyResolveTest.kt
index bc6f1dd963a..2df7caf6cb1 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractPartialBodyResolveTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractPartialBodyResolveTest.kt
@@ -17,31 +17,31 @@
 package org.jetbrains.kotlin.idea.resolve
 
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.idea.test.JetWithJdkAndRuntimeLightProjectDescriptor
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import java.util.HashSet
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.io.File
-import org.jetbrains.kotlin.psi.JetBlockExpression
+import org.jetbrains.kotlin.psi.KtBlockExpression
 import org.junit.Assert
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.psi.psiUtil.parents
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.command.CommandProcessor
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.psi.JetReferenceExpression
+import org.jetbrains.kotlin.psi.KtReferenceExpression
 import org.jetbrains.kotlin.psi.psiUtil.getReceiverExpression
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.KotlinFileType
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 
@@ -66,19 +66,19 @@ public abstract class AbstractPartialBodyResolveTest : JetLightCodeInsightFixtur
     }
 
     private fun dump(testPath: String, resolveMode: BodyResolveMode): String {
-        myFixture.configureByText(JetFileType.INSTANCE, File(testPath).readText())
+        myFixture.configureByText(KotlinFileType.INSTANCE, File(testPath).readText())
 
-        val file = myFixture.getFile() as JetFile
+        val file = myFixture.getFile() as KtFile
         val editor = myFixture.getEditor()
         val selectionModel = editor.getSelectionModel()
         val expression = if (selectionModel.hasSelection()) {
-            PsiTreeUtil.findElementOfClassAtRange(file, selectionModel.getSelectionStart(), selectionModel.getSelectionEnd(), javaClass<JetExpression>())
+            PsiTreeUtil.findElementOfClassAtRange(file, selectionModel.getSelectionStart(), selectionModel.getSelectionEnd(), javaClass<KtExpression>())
                 ?: error("No JetExpression at selection range")
         }
         else {
             val offset = editor.getCaretModel().getOffset()
             val element = file.findElementAt(offset)!!
-            element.getNonStrictParentOfType<JetSimpleNameExpression>() ?: error("No JetSimpleNameExpression at caret")
+            element.getNonStrictParentOfType<KtSimpleNameExpression>() ?: error("No JetSimpleNameExpression at caret")
         }
 
         val resolutionFacade = file.getResolutionFacade()
@@ -95,7 +95,7 @@ public abstract class AbstractPartialBodyResolveTest : JetLightCodeInsightFixtur
 
         val builder = StringBuilder()
 
-        if (expression is JetReferenceExpression) {
+        if (expression is KtReferenceExpression) {
             builder.append("Resolve target: ${target2.presentation(type2)}\n")
         }
         else {
@@ -109,7 +109,7 @@ public abstract class AbstractPartialBodyResolveTest : JetLightCodeInsightFixtur
 
         myFixture.getProject().executeWriteCommand("") {
             for (statement in skippedStatements) {
-                statement.replace(JetPsiFactory(getProject()).createComment("/* STATEMENT DELETED: ${statement.compactPresentation()} */"))
+                statement.replace(KtPsiFactory(getProject()).createComment("/* STATEMENT DELETED: ${statement.compactPresentation()} */"))
             }
         }
 
@@ -138,21 +138,21 @@ public abstract class AbstractPartialBodyResolveTest : JetLightCodeInsightFixtur
 
     private data class ResolveData(
             val target: DeclarationDescriptor?,
-            val type: JetType?,
-            val processedStatements: Collection<JetExpression>
+            val type: KtType?,
+            val processedStatements: Collection<KtExpression>
     )
 
-    private fun doResolve(expression: JetExpression, bindingContext: BindingContext): ResolveData {
-        val target = if (expression is JetReferenceExpression) bindingContext[BindingContext.REFERENCE_TARGET, expression] else null
+    private fun doResolve(expression: KtExpression, bindingContext: BindingContext): ResolveData {
+        val target = if (expression is KtReferenceExpression) bindingContext[BindingContext.REFERENCE_TARGET, expression] else null
 
         val processedStatements = bindingContext.getSliceContents(BindingContext.PROCESSED)
                 .filter { it.value }
                 .map { it.key }
-                .filter { it.getParent() is JetBlockExpression }
+                .filter { it.getParent() is KtBlockExpression }
 
-        val receiver = (expression as? JetSimpleNameExpression)?.getReceiverExpression()
+        val receiver = (expression as? KtSimpleNameExpression)?.getReceiverExpression()
         val expressionWithType = if (receiver != null) {
-            expression.getParent() as? JetExpression ?: expression
+            expression.getParent() as? KtExpression ?: expression
         }
         else {
             expression
@@ -162,7 +162,7 @@ public abstract class AbstractPartialBodyResolveTest : JetLightCodeInsightFixtur
         return ResolveData(target, type, processedStatements)
     }
 
-    private fun DeclarationDescriptor?.presentation(type: JetType?): String {
+    private fun DeclarationDescriptor?.presentation(type: KtType?): String {
         if (this == null) return "null"
 
         val s = DescriptorRenderer.COMPACT.render(this)
@@ -172,10 +172,10 @@ public abstract class AbstractPartialBodyResolveTest : JetLightCodeInsightFixtur
         return "$s smart-cast to ${type.presentation()}"
     }
 
-    private fun JetType?.presentation()
+    private fun KtType?.presentation()
             = if (this != null) DescriptorRenderer.COMPACT.renderType(this) else "unknown type"
 
-    private fun JetExpression.compactPresentation(): String {
+    private fun KtExpression.compactPresentation(): String {
         val text = getText()
         val builder = StringBuilder()
         var dropSpace = false
diff --git a/idea/tests/org/jetbrains/kotlin/idea/run/RunConfigurationTest.kt b/idea/tests/org/jetbrains/kotlin/idea/run/RunConfigurationTest.kt
index 75535c672bf..35eeec442e8 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/run/RunConfigurationTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/run/RunConfigurationTest.kt
@@ -72,7 +72,7 @@ class RunConfigurationTest: KotlinCodeInsightTestCase() {
         Assert.assertTrue(javaParameters.getClassPath().getRootDirs().contains(createResult.srcOutputDir))
         Assert.assertTrue(javaParameters.getClassPath().getRootDirs().contains(createResult.testOutputDir))
 
-        fun functionVisitor(function: JetNamedFunction) {
+        fun functionVisitor(function: KtNamedFunction) {
             val options = function.bodyExpression?.allChildren?.filterIsInstance<PsiComment>()?.map { it.text.trim().replace("//", "").trim() }?.filter { it.isNotBlank() }?.toList() ?: emptyList()
             if (options.isNotEmpty()) {
                 val assertIsMain = "yes" in options
@@ -108,9 +108,9 @@ class RunConfigurationTest: KotlinCodeInsightTestCase() {
 
         createResult.srcDir.children.filter { it.extension == "kt" }.forEach {
             val psiFile = PsiManager.getInstance(createResult.module.project).findFile(it)
-            if (psiFile is JetFile) {
-                psiFile.acceptChildren(object : JetVisitorVoid() {
-                    override fun visitNamedFunction(function: JetNamedFunction) {
+            if (psiFile is KtFile) {
+                psiFile.acceptChildren(object : KtVisitorVoid() {
+                    override fun visitNamedFunction(function: KtNamedFunction) {
                         functionVisitor(function)
                     }
                 })
@@ -187,9 +187,9 @@ class RunConfigurationTest: KotlinCodeInsightTestCase() {
 
             val testFile = PsiManager.getInstance(getTestProject()).findFile(srcDir.findFileByRelativePath("test.kt")!!)!!
             testFile.accept(
-                    object : JetTreeVisitorVoid() {
+                    object : KtTreeVisitorVoid() {
                         override fun visitComment(comment: PsiComment) {
-                            val declaration = comment.getStrictParentOfType<JetNamedDeclaration>()!!
+                            val declaration = comment.getStrictParentOfType<KtNamedDeclaration>()!!
                             val text = comment.getText() ?: return
                             if (!text.startsWith(RUN_PREFIX)) return
 
@@ -221,7 +221,7 @@ class RunConfigurationTest: KotlinCodeInsightTestCase() {
 
     private fun createConfigurationFromObject(objectFqn: String, save: Boolean = false): JetRunConfiguration {
         val obj = JetFullClassNameIndex.getInstance().get(objectFqn, getTestProject(), getTestProject().allScope()).single()
-        val mainFunction = obj.getDeclarations().single { it is JetFunction && it.getName() == "main" }
+        val mainFunction = obj.getDeclarations().single { it is KtFunction && it.getName() == "main" }
         return createConfigurationFromElement(mainFunction, save)
     }
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractResolveByStubTest.java b/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractResolveByStubTest.java
index 1e5b3e8c3ad..8f5d029a396 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractResolveByStubTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractResolveByStubTest.java
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
 import org.jetbrains.kotlin.idea.test.*;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator;
 import org.junit.Assert;
 
@@ -56,7 +56,7 @@ public abstract class AbstractResolveByStubTest extends KotlinCodeInsightTestCas
     }
 
     private void performTest(@NotNull String path, boolean checkPrimaryConstructors, boolean checkPropertyAccessors) {
-        JetFile file = (JetFile) getFile();
+        KtFile file = (KtFile) getFile();
         ModuleDescriptor module = ResolutionUtils.findModuleDescriptor(file);
         PackageViewDescriptor packageViewDescriptor = module.getPackage(new FqName("test"));
         Assert.assertFalse(packageViewDescriptor.isEmpty());
diff --git a/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractStubBuilderTest.java b/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractStubBuilderTest.java
index 32d1f0de488..adc7d580ac7 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractStubBuilderTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractStubBuilderTest.java
@@ -21,16 +21,16 @@ import com.intellij.psi.stubs.StubElement;
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.name.SpecialNames;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.stubs.elements.JetFileStubBuilder;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.stubs.elements.KtFileStubBuilder;
 import org.jetbrains.kotlin.test.JetTestUtils;
 
 import java.io.File;
 
 public abstract class AbstractStubBuilderTest extends LightCodeInsightFixtureTestCase {
     protected void doTest(@NotNull String sourcePath) {
-        JetFile file = (JetFile) myFixture.configureByFile(sourcePath);
-        JetFileStubBuilder jetStubBuilder = new JetFileStubBuilder();
+        KtFile file = (KtFile) myFixture.configureByFile(sourcePath);
+        KtFileStubBuilder jetStubBuilder = new KtFileStubBuilder();
         StubElement lighterTree = jetStubBuilder.buildStubTree(file);
         String stubTree = serializeStubToString(lighterTree);
         String expectedFile = sourcePath.replace(".kt", ".expected");
diff --git a/idea/tests/org/jetbrains/kotlin/idea/stubs/DebugTextByStubTest.kt b/idea/tests/org/jetbrains/kotlin/idea/stubs/DebugTextByStubTest.kt
index d90a79bd9f7..9257f6c86dc 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/stubs/DebugTextByStubTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/stubs/DebugTextByStubTest.kt
@@ -17,32 +17,32 @@
 package org.jetbrains.kotlin.idea.stubs
 
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.stubs.elements.JetFileStubBuilder
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.stubs.elements.KtFileStubBuilder
 import com.intellij.psi.stubs.StubElement
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import org.junit.Assert
-import org.jetbrains.kotlin.psi.JetPackageDirective
+import org.jetbrains.kotlin.psi.KtPackageDirective
 import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub
-import org.jetbrains.kotlin.psi.JetImportList
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtImportList
+import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.stubs.KotlinFunctionStub
-import org.jetbrains.kotlin.psi.JetTypeReference
+import org.jetbrains.kotlin.psi.KtTypeReference
 import org.jetbrains.kotlin.psi.stubs.KotlinClassStub
-import org.jetbrains.kotlin.psi.JetClass
+import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.stubs.KotlinObjectStub
-import org.jetbrains.kotlin.psi.JetObjectDeclaration
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.stubs.KotlinPropertyStub
 import kotlin.test.assertEquals
-import org.jetbrains.kotlin.psi.JetClassBody
-import org.jetbrains.kotlin.psi.JetClassInitializer
+import org.jetbrains.kotlin.psi.KtClassBody
+import org.jetbrains.kotlin.psi.KtClassInitializer
 import org.jetbrains.kotlin.psi.debugText.getDebugText
 
 public class DebugTextByStubTest : LightCodeInsightFixtureTestCase() {
-    private fun createFileAndStubTree(text: String): Pair<JetFile, StubElement<*>> {
-        val file = myFixture.configureByText("test.kt", text) as JetFile
-        val stub = JetFileStubBuilder().buildStubTree(file)!!
+    private fun createFileAndStubTree(text: String): Pair<KtFile, StubElement<*>> {
+        val file = myFixture.configureByText("test.kt", text) as KtFile
+        val stub = KtFileStubBuilder().buildStubTree(file)!!
         return Pair(file, stub)
     }
 
@@ -50,34 +50,34 @@ public class DebugTextByStubTest : LightCodeInsightFixtureTestCase() {
 
     fun packageDirective(text: String) {
         val (file, tree) = createFileAndStubTree(text)
-        val packageDirective = tree.findChildStubByType(JetStubElementTypes.PACKAGE_DIRECTIVE)
-        val psi = JetPackageDirective(packageDirective as KotlinPlaceHolderStub)
+        val packageDirective = tree.findChildStubByType(KtStubElementTypes.PACKAGE_DIRECTIVE)
+        val psi = KtPackageDirective(packageDirective as KotlinPlaceHolderStub)
         Assert.assertEquals(file.getPackageDirective()!!.getText(), psi.getDebugText())
     }
 
     fun function(text: String) {
         val (file, tree) = createFileAndStubTree(text)
-        val function = tree.findChildStubByType(JetStubElementTypes.FUNCTION)
-        val psi = JetNamedFunction(function as KotlinFunctionStub)
-        Assert.assertEquals("STUB: " + file.findChildByClass(javaClass<JetNamedFunction>())!!.getText(), psi.getDebugText())
+        val function = tree.findChildStubByType(KtStubElementTypes.FUNCTION)
+        val psi = KtNamedFunction(function as KotlinFunctionStub)
+        Assert.assertEquals("STUB: " + file.findChildByClass(javaClass<KtNamedFunction>())!!.getText(), psi.getDebugText())
     }
 
     fun typeReference(text: String) {
         val (file, tree) = createFileAndStubTree("fun foo(i: $text)")
-        val function = tree.findChildStubByType(JetStubElementTypes.FUNCTION)!!
-        val parameterList = function.findChildStubByType(JetStubElementTypes.VALUE_PARAMETER_LIST)!!
-        val valueParameter = parameterList.findChildStubByType(JetStubElementTypes.VALUE_PARAMETER)!!
-        val typeReferenceStub = valueParameter.findChildStubByType(JetStubElementTypes.TYPE_REFERENCE)
-        val psiFromStub = JetTypeReference(typeReferenceStub as KotlinPlaceHolderStub)
-        val typeReferenceByPsi = file.findChildByClass(javaClass<JetNamedFunction>())!!.getValueParameters()[0].getTypeReference()
+        val function = tree.findChildStubByType(KtStubElementTypes.FUNCTION)!!
+        val parameterList = function.findChildStubByType(KtStubElementTypes.VALUE_PARAMETER_LIST)!!
+        val valueParameter = parameterList.findChildStubByType(KtStubElementTypes.VALUE_PARAMETER)!!
+        val typeReferenceStub = valueParameter.findChildStubByType(KtStubElementTypes.TYPE_REFERENCE)
+        val psiFromStub = KtTypeReference(typeReferenceStub as KotlinPlaceHolderStub)
+        val typeReferenceByPsi = file.findChildByClass(javaClass<KtNamedFunction>())!!.getValueParameters()[0].getTypeReference()
         Assert.assertEquals(typeReferenceByPsi!!.getText(), psiFromStub.getDebugText())
     }
 
     fun clazz(text: String, expectedText: String? = null) {
         val (file, tree) = createFileAndStubTree(text)
-        val clazz = tree.findChildStubByType(JetStubElementTypes.CLASS)!!
-        val psiFromStub = JetClass(clazz as KotlinClassStub)
-        val classByPsi = file.findChildByClass(javaClass<JetClass>())
+        val clazz = tree.findChildStubByType(KtStubElementTypes.CLASS)!!
+        val psiFromStub = KtClass(clazz as KotlinClassStub)
+        val classByPsi = file.findChildByClass(javaClass<KtClass>())
         val toCheckAgainst = "STUB: " + (expectedText ?: classByPsi!!.getText())
         Assert.assertEquals(toCheckAgainst, psiFromStub.getDebugText())
         if (expectedText != null) {
@@ -87,26 +87,26 @@ public class DebugTextByStubTest : LightCodeInsightFixtureTestCase() {
 
     fun obj(text: String, expectedText: String? = null) {
         val (file, tree) = createFileAndStubTree(text)
-        val obj = tree.findChildStubByType(JetStubElementTypes.OBJECT_DECLARATION)!!
-        val psiFromStub = JetObjectDeclaration(obj as KotlinObjectStub)
-        val objectByPsi = file.findChildByClass(javaClass<JetObjectDeclaration>())
+        val obj = tree.findChildStubByType(KtStubElementTypes.OBJECT_DECLARATION)!!
+        val psiFromStub = KtObjectDeclaration(obj as KotlinObjectStub)
+        val objectByPsi = file.findChildByClass(javaClass<KtObjectDeclaration>())
         val toCheckAgainst = "STUB: " + (expectedText ?: objectByPsi!!.getText())
         Assert.assertEquals(toCheckAgainst, psiFromStub.getDebugText())
     }
 
     fun property(text: String, expectedText: String? = null) {
         val (file, tree) = createFileAndStubTree(text)
-        val property = tree.findChildStubByType(JetStubElementTypes.PROPERTY)!!
-        val psiFromStub = JetProperty(property as KotlinPropertyStub)
-        val propertyByPsi = file.findChildByClass(javaClass<JetProperty>())
+        val property = tree.findChildStubByType(KtStubElementTypes.PROPERTY)!!
+        val psiFromStub = KtProperty(property as KotlinPropertyStub)
+        val propertyByPsi = file.findChildByClass(javaClass<KtProperty>())
         val toCheckAgainst = "STUB: " + (expectedText ?: propertyByPsi!!.getText())
         Assert.assertEquals(toCheckAgainst, psiFromStub.getDebugText())
     }
 
     fun importList(text: String) {
         val (file, tree) = createFileAndStubTree(text)
-        val importList = tree.findChildStubByType(JetStubElementTypes.IMPORT_LIST)
-        val psi = JetImportList(importList as KotlinPlaceHolderStub)
+        val importList = tree.findChildStubByType(KtStubElementTypes.IMPORT_LIST)
+        val psi = KtImportList(importList as KotlinPlaceHolderStub)
         Assert.assertEquals(file.getImportList()!!.getText(), psi.getDebugText())
     }
 
@@ -187,36 +187,36 @@ public class DebugTextByStubTest : LightCodeInsightFixtureTestCase() {
 
     fun testClassBody() {
         val tree = createStubTree("class A {\n {} fun f(): Int val c: Int}")
-        val classBody = tree.findChildStubByType(JetStubElementTypes.CLASS)!!.findChildStubByType(JetStubElementTypes.CLASS_BODY)
-        assertEquals("class body for STUB: class A", JetClassBody(classBody as KotlinPlaceHolderStub).getDebugText())
+        val classBody = tree.findChildStubByType(KtStubElementTypes.CLASS)!!.findChildStubByType(KtStubElementTypes.CLASS_BODY)
+        assertEquals("class body for STUB: class A", KtClassBody(classBody as KotlinPlaceHolderStub).getDebugText())
     }
 
     fun testClassInitializer() {
         val tree = createStubTree("class A {\n init {} }")
-        val initializer = tree.findChildStubByType(JetStubElementTypes.CLASS)!!.findChildStubByType(JetStubElementTypes.CLASS_BODY)!!
-                .findChildStubByType(JetStubElementTypes.ANONYMOUS_INITIALIZER)
-        assertEquals("initializer in STUB: class A", JetClassInitializer(initializer as KotlinPlaceHolderStub).getDebugText())
+        val initializer = tree.findChildStubByType(KtStubElementTypes.CLASS)!!.findChildStubByType(KtStubElementTypes.CLASS_BODY)!!
+                .findChildStubByType(KtStubElementTypes.ANONYMOUS_INITIALIZER)
+        assertEquals("initializer in STUB: class A", KtClassInitializer(initializer as KotlinPlaceHolderStub).getDebugText())
     }
 
     fun testClassObject() {
         val tree = createStubTree("class A { companion object Def {} }")
-        val companionObject = tree.findChildStubByType(JetStubElementTypes.CLASS)!!.findChildStubByType(JetStubElementTypes.CLASS_BODY)!!
-                .findChildStubByType(JetStubElementTypes.OBJECT_DECLARATION)
-        assertEquals("STUB: companion object Def", JetObjectDeclaration(companionObject as KotlinObjectStub).getDebugText())
+        val companionObject = tree.findChildStubByType(KtStubElementTypes.CLASS)!!.findChildStubByType(KtStubElementTypes.CLASS_BODY)!!
+                .findChildStubByType(KtStubElementTypes.OBJECT_DECLARATION)
+        assertEquals("STUB: companion object Def", KtObjectDeclaration(companionObject as KotlinObjectStub).getDebugText())
     }
 
     fun testPropertyAccessors() {
         val tree = createStubTree("var c: Int\nget() = 3\nset(i: Int) {}")
-        val propertyStub = tree.findChildStubByType(JetStubElementTypes.PROPERTY)!!
-        val accessors = propertyStub.getChildrenByType(JetStubElementTypes.PROPERTY_ACCESSOR, JetStubElementTypes.PROPERTY_ACCESSOR.getArrayFactory())!!
+        val propertyStub = tree.findChildStubByType(KtStubElementTypes.PROPERTY)!!
+        val accessors = propertyStub.getChildrenByType(KtStubElementTypes.PROPERTY_ACCESSOR, KtStubElementTypes.PROPERTY_ACCESSOR.getArrayFactory())!!
         assertEquals("getter for STUB: var c: Int", accessors[0].getDebugText())
         assertEquals("setter for STUB: var c: Int", accessors[1].getDebugText())
     }
 
     fun testEnumEntry() {
         val tree = createStubTree("enum class Enum { E1, E2(), E3(1, 2)}")
-        val enumClass = tree.findChildStubByType(JetStubElementTypes.CLASS)!!.findChildStubByType(JetStubElementTypes.CLASS_BODY)!!
-        val entries = enumClass.getChildrenByType(JetStubElementTypes.ENUM_ENTRY, JetStubElementTypes.ENUM_ENTRY.getArrayFactory())!!
+        val enumClass = tree.findChildStubByType(KtStubElementTypes.CLASS)!!.findChildStubByType(KtStubElementTypes.CLASS_BODY)!!
+        val entries = enumClass.getChildrenByType(KtStubElementTypes.ENUM_ENTRY, KtStubElementTypes.ENUM_ENTRY.getArrayFactory())!!
         assertEquals("STUB: enum entry E1", entries[0].getDebugText())
         assertEquals("STUB: enum entry E2 : Enum", entries[1].getDebugText())
         assertEquals("STUB: enum entry E3 : Enum", entries[2].getDebugText())
diff --git a/idea/tests/org/jetbrains/kotlin/idea/stubs/JetStubsTest.java b/idea/tests/org/jetbrains/kotlin/idea/stubs/JetStubsTest.java
index d6d6a43d78d..7c9d7a1e8d9 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/stubs/JetStubsTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/stubs/JetStubsTest.java
@@ -21,11 +21,11 @@ import com.intellij.testFramework.LightProjectDescriptor;
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.test.JetLightProjectDescriptor;
-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.psi.stubs.KotlinClassStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
 
 import java.util.List;
 
@@ -38,18 +38,18 @@ public class JetStubsTest extends LightCodeInsightFixtureTestCase {
 
     public void testSuperclassNames() {
         PsiFile psiFile = myFixture.configureByText("foo.kt", "import java.util.ArrayList as alist\nclass C(): alist() { }");
-        List<JetDeclaration> declarations = ((JetFile) psiFile).getDeclarations();
-        JetClass jetClass = (JetClass) declarations.get(0);
-        KotlinClassStub stub = JetStubElementTypes.CLASS.createStub(jetClass, null);
+        List<KtDeclaration> declarations = ((KtFile) psiFile).getDeclarations();
+        KtClass ktClass = (KtClass) declarations.get(0);
+        KotlinClassStub stub = KtStubElementTypes.CLASS.createStub(ktClass, null);
         List<String> names = stub.getSuperNames();
         assertSameElements(names, "ArrayList", "alist");
     }
 
     public void testClassIsTrait() {
         PsiFile psiFile = myFixture.configureByText("foo.kt", "interface Test { }");
-        List<JetDeclaration> declarations = ((JetFile) psiFile).getDeclarations();
-        JetClass jetClass = (JetClass) declarations.get(0);
-        KotlinClassStub stub = JetStubElementTypes.CLASS.createStub(jetClass, null);
+        List<KtDeclaration> declarations = ((KtFile) psiFile).getDeclarations();
+        KtClass ktClass = (KtClass) declarations.get(0);
+        KotlinClassStub stub = KtStubElementTypes.CLASS.createStub(ktClass, null);
         assertEquals(true, stub.isInterface());
     }
 }
diff --git a/idea/tests/org/jetbrains/kotlin/psi/StringTemplateExpressionManipulatorTest.kt b/idea/tests/org/jetbrains/kotlin/psi/StringTemplateExpressionManipulatorTest.kt
index dd011b92c9d..24f1565dc52 100644
--- a/idea/tests/org/jetbrains/kotlin/psi/StringTemplateExpressionManipulatorTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/psi/StringTemplateExpressionManipulatorTest.kt
@@ -61,7 +61,7 @@ public class StringTemplateExpressionManipulatorTest : JetLightCodeInsightFixtur
     }
 
     private fun doTestContentChange(original: String, newContent: String, expected: String, range: TextRange? = null) {
-        val expression = JetPsiFactory(getProject()).createExpression(original) as JetStringTemplateExpression
+        val expression = KtPsiFactory(getProject()).createExpression(original) as KtStringTemplateExpression
         val manipulator = ElementManipulators.getNotNullManipulator(expression)
         val newExpression = if (range == null) manipulator.handleContentChange(expression, newContent) else manipulator.handleContentChange(expression, range, newContent)
         assertEquals(expected, newExpression.getText())
diff --git a/idea/tests/org/jetbrains/kotlin/psi/injection/StringInjectionHostTest.kt b/idea/tests/org/jetbrains/kotlin/psi/injection/StringInjectionHostTest.kt
index 803b6063cfd..fdc510e723f 100644
--- a/idea/tests/org/jetbrains/kotlin/psi/injection/StringInjectionHostTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/psi/injection/StringInjectionHostTest.kt
@@ -16,8 +16,8 @@
 
 package org.jetbrains.kotlin.psi.injection
 
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetStringTemplateExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtStringTemplateExpression
 import org.junit.Assert.*
 import com.intellij.openapi.util.TextRange
 import java.util.HashMap
@@ -99,34 +99,34 @@ public class StringInjectionHostTest: JetLiteFixture() {
         }
     }
 
-    private fun quoted(s: String): JetStringTemplateExpression {
+    private fun quoted(s: String): KtStringTemplateExpression {
         return stringExpression("\"$s\"")
     }
 
-    private fun tripleQuoted(s: String): JetStringTemplateExpression {
+    private fun tripleQuoted(s: String): KtStringTemplateExpression {
         return stringExpression("\"\"\"$s\"\"\"")
     }
 
-    private fun stringExpression(s: String): JetStringTemplateExpression {
-        return JetPsiFactory(getProject()).createExpression(s) as JetStringTemplateExpression
+    private fun stringExpression(s: String): KtStringTemplateExpression {
+        return KtPsiFactory(getProject()).createExpression(s) as KtStringTemplateExpression
     }
 
-    private fun JetStringTemplateExpression.assertNoInjection(range: TextRange): JetStringTemplateExpression {
+    private fun KtStringTemplateExpression.assertNoInjection(range: TextRange): KtStringTemplateExpression {
         assertTrue(isValidHost())
         assertFalse(createLiteralTextEscaper().decode(range, StringBuilder()))
         return this
     }
 
-    private fun JetStringTemplateExpression.assertOneLine() {
+    private fun KtStringTemplateExpression.assertOneLine() {
         assertTrue(createLiteralTextEscaper().isOneLine())
     }
 
-    private fun JetStringTemplateExpression.assertMultiLine() {
+    private fun KtStringTemplateExpression.assertMultiLine() {
         assertFalse(createLiteralTextEscaper().isOneLine())
     }
 
     //todo[nik] make private when KT-6382 is fixed
-    fun JetStringTemplateExpression.checkInjection(decoded: String, targetToSourceOffsets: Map<Int,Int>, rangeInHost: TextRange? = null) {
+    fun KtStringTemplateExpression.checkInjection(decoded: String, targetToSourceOffsets: Map<Int,Int>, rangeInHost: TextRange? = null) {
         assertTrue(isValidHost())
         for (prefix in listOf("", "prefix")) {
             val escaper = createLiteralTextEscaper()
diff --git a/idea/tests/org/jetbrains/kotlin/psi/patternMatching/AbstractJetPsiUnifierTest.kt b/idea/tests/org/jetbrains/kotlin/psi/patternMatching/AbstractJetPsiUnifierTest.kt
index 10644ce6e7c..968b3899b38 100644
--- a/idea/tests/org/jetbrains/kotlin/psi/patternMatching/AbstractJetPsiUnifierTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/psi/patternMatching/AbstractJetPsiUnifierTest.kt
@@ -18,35 +18,35 @@ package org.jetbrains.kotlin.psi.patternMatching
 
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
 import com.intellij.testFramework.LightProjectDescriptor
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.parents
 import com.intellij.openapi.util.TextRange
-import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.JetPsiUnifier
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.toRange
 import java.io.File
 import org.jetbrains.kotlin.test.JetTestUtils
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetTypeReference
-import org.jetbrains.kotlin.psi.JetWhenCondition
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtTypeReference
+import org.jetbrains.kotlin.psi.KtWhenCondition
 import org.jetbrains.kotlin.idea.test.DirectiveBasedActionUtils
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 
 public abstract class AbstractJetPsiUnifierTest: JetLightCodeInsightFixtureTestCase() {
     public fun doTest(filePath: String) {
-        fun findPattern(file: JetFile): JetElement {
+        fun findPattern(file: KtFile): KtElement {
             val selectionModel = myFixture.getEditor().getSelectionModel()
             val start = selectionModel.getSelectionStart()
             val end = selectionModel.getSelectionEnd()
             val selectionRange = TextRange(start, end)
             return file.findElementAt(start)?.parentsWithSelf?.last {
-                (it is JetExpression || it is JetTypeReference || it is JetWhenCondition)
+                (it is KtExpression || it is KtTypeReference || it is KtWhenCondition)
                         && selectionRange.contains(it.getTextRange() ?: TextRange.EMPTY_RANGE)
-            } as JetElement
+            } as KtElement
         }
 
         myFixture.configureByFile(filePath)
-        val file = myFixture.getFile() as JetFile
+        val file = myFixture.getFile() as KtFile
 
         DirectiveBasedActionUtils.checkForUnexpectedErrors(file)
 
diff --git a/idea/tests/org/jetbrains/kotlin/safeDelete/AbstractJetSafeDeleteTest.java b/idea/tests/org/jetbrains/kotlin/safeDelete/AbstractJetSafeDeleteTest.java
index 4a68ed9db52..491be9dca8b 100644
--- a/idea/tests/org/jetbrains/kotlin/safeDelete/AbstractJetSafeDeleteTest.java
+++ b/idea/tests/org/jetbrains/kotlin/safeDelete/AbstractJetSafeDeleteTest.java
@@ -51,23 +51,23 @@ public abstract class AbstractJetSafeDeleteTest extends JetLightCodeInsightFixtu
     }
 
     public void doClassTest(@NotNull String path) throws Exception {
-        doTest(path, JetClass.class, false);
+        doTest(path, KtClass.class, false);
     }
 
     public void doClassTestWithJava(@NotNull String path) throws Exception {
-        doTest(path, JetClass.class, true);
+        doTest(path, KtClass.class, true);
     }
 
     public void doObjectTest(@NotNull String path) throws Exception {
-        doTest(path, JetObjectDeclaration.class, false);
+        doTest(path, KtObjectDeclaration.class, false);
     }
 
     public void doFunctionTest(@NotNull String path) throws Exception {
-        doTest(path, JetFunction.class, false);
+        doTest(path, KtFunction.class, false);
     }
 
     public void doFunctionTestWithJava(@NotNull String path) throws Exception {
-        doTest(path, JetFunction.class, true);
+        doTest(path, KtFunction.class, true);
     }
 
     public void doJavaMethodTest(@NotNull String path) throws Exception {
@@ -75,11 +75,11 @@ public abstract class AbstractJetSafeDeleteTest extends JetLightCodeInsightFixtu
     }
 
     public void doPropertyTest(@NotNull String path) throws Exception {
-        doTest(path, JetProperty.class, false);
+        doTest(path, KtProperty.class, false);
     }
 
     public void doPropertyTestWithJava(@NotNull String path) throws Exception {
-        doTest(path, JetProperty.class, true);
+        doTest(path, KtProperty.class, true);
     }
 
     public void doJavaPropertyTest(@NotNull String path) throws Exception {
@@ -87,19 +87,19 @@ public abstract class AbstractJetSafeDeleteTest extends JetLightCodeInsightFixtu
     }
 
     public void doTypeParameterTest(@NotNull String path) throws Exception {
-        doTest(path, JetTypeParameter.class, false);
+        doTest(path, KtTypeParameter.class, false);
     }
 
     public void doTypeParameterTestWithJava(@NotNull String path) throws Exception {
-        doTest(path, JetTypeParameter.class, true);
+        doTest(path, KtTypeParameter.class, true);
     }
 
     public void doValueParameterTest(@NotNull String path) throws Exception {
-        doTest(path, JetParameter.class, false);
+        doTest(path, KtParameter.class, false);
     }
 
     public void doValueParameterTestWithJava(@NotNull String path) throws Exception {
-        doTest(path, JetParameter.class, true);
+        doTest(path, KtParameter.class, true);
     }
 
     private <T extends PsiElement> void doTest(
diff --git a/idea/tests/org/jetbrains/kotlin/search/KotlinReferencesSearchTest.kt b/idea/tests/org/jetbrains/kotlin/search/KotlinReferencesSearchTest.kt
index 4822edd2af1..902d2235249 100644
--- a/idea/tests/org/jetbrains/kotlin/search/KotlinReferencesSearchTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/search/KotlinReferencesSearchTest.kt
@@ -19,10 +19,10 @@ package org.jetbrains.kotlin.search
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiReference
 import com.intellij.psi.search.searches.ReferencesSearch
-import org.jetbrains.kotlin.idea.references.JetMultiDeclarationReference
+import org.jetbrains.kotlin.idea.references.KtMultiDeclarationReference
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
-import org.jetbrains.kotlin.psi.JetFunction
-import org.jetbrains.kotlin.psi.JetParameter
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 import org.junit.Assert
 import java.io.File
@@ -33,7 +33,7 @@ public class KotlinReferencesSearchTest(): AbstractSearcherTest() {
     }
 
     public fun testPlus() {
-        val refs = doTest<JetFunction>()
+        val refs = doTest<KtFunction>()
         Assert.assertEquals(3, refs.size())
         Assert.assertEquals("+", refs[0].getCanonicalText())
         Assert.assertEquals("plus", refs[1].getCanonicalText())
@@ -41,11 +41,11 @@ public class KotlinReferencesSearchTest(): AbstractSearcherTest() {
     }
 
     public fun testParam() {
-        val refs = doTest<JetParameter>()
+        val refs = doTest<KtParameter>()
         Assert.assertEquals(3, refs.size())
         Assert.assertEquals("n", refs[0].getCanonicalText())
         Assert.assertEquals("component1", refs[1].getCanonicalText())
-        Assert.assertTrue(refs[2] is JetMultiDeclarationReference)
+        Assert.assertTrue(refs[2] is KtMultiDeclarationReference)
     }
 
     private inline fun doTest<reified T: PsiElement>(): List<PsiReference> {
diff --git a/idea/tests/org/jetbrains/kotlin/shortenRefs/AbstractShortenRefsTest.kt b/idea/tests/org/jetbrains/kotlin/shortenRefs/AbstractShortenRefsTest.kt
index 560c5add695..69c8b7fb202 100644
--- a/idea/tests/org/jetbrains/kotlin/shortenRefs/AbstractShortenRefsTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/shortenRefs/AbstractShortenRefsTest.kt
@@ -16,12 +16,12 @@
 
 package org.jetbrains.kotlin.shortenRefs
 
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.idea.util.ShortenReferences
 import org.jetbrains.kotlin.AbstractImportsTest
 
 public abstract class AbstractShortenRefsTest : AbstractImportsTest() {
-    override fun doTest(file: JetFile) {
+    override fun doTest(file: KtFile) {
         val selectionModel = myFixture.getEditor().getSelectionModel()
         if (!selectionModel.hasSelection()) error("No selection in input file")
         ShortenReferences { ShortenReferences.Options(removeThis = true, removeThisLabels = true) }
diff --git a/idea/tests/org/jetbrains/kotlin/test/ReferenceUtils.java b/idea/tests/org/jetbrains/kotlin/test/ReferenceUtils.java
index 26da6f6f29d..2897119d3c8 100644
--- a/idea/tests/org/jetbrains/kotlin/test/ReferenceUtils.java
+++ b/idea/tests/org/jetbrains/kotlin/test/ReferenceUtils.java
@@ -23,8 +23,8 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiPackage;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.psi.JetClass;
-import org.jetbrains.kotlin.psi.JetObjectDeclaration;
+import org.jetbrains.kotlin.psi.KtClass;
+import org.jetbrains.kotlin.psi.KtObjectDeclaration;
 import org.junit.Assert;
 
 public final class ReferenceUtils {
@@ -34,9 +34,9 @@ public final class ReferenceUtils {
     public static String renderAsGotoImplementation(@NotNull PsiElement element) {
         PsiElement navigationElement = element.getNavigationElement();
 
-        if (navigationElement instanceof JetObjectDeclaration && ((JetObjectDeclaration) navigationElement).isCompanion()) {
+        if (navigationElement instanceof KtObjectDeclaration && ((KtObjectDeclaration) navigationElement).isCompanion()) {
             //default presenter return null for companion object
-            JetClass containingClass = PsiTreeUtil.getParentOfType(navigationElement, JetClass.class);
+            KtClass containingClass = PsiTreeUtil.getParentOfType(navigationElement, KtClass.class);
             assert containingClass != null;
             return "companion object of " + renderAsGotoImplementation(containingClass);
         }
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/AfterConversionPass.kt b/j2k/src/org/jetbrains/kotlin/j2k/AfterConversionPass.kt
index 45a1a77192d..7cfd9b6ee4e 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/AfterConversionPass.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/AfterConversionPass.kt
@@ -18,10 +18,10 @@ package org.jetbrains.kotlin.j2k
 
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.TextRange
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
 public class AfterConversionPass(val project: Project, val postProcessor: PostProcessor) {
-    public fun run(kotlinFile: JetFile, range: TextRange?) {
+    public fun run(kotlinFile: KtFile, range: TextRange?) {
         val rangeMarker = if (range != null) {
             val document = kotlinFile.viewProvider.document!!
             val marker = document.createRangeMarker(range.startOffset, range.endOffset)
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ExpressionConverter.kt b/j2k/src/org/jetbrains/kotlin/j2k/ExpressionConverter.kt
index cc1387dfa1a..59540ff52b7 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ExpressionConverter.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ExpressionConverter.kt
@@ -255,12 +255,12 @@ class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter {
 
         if (target is KotlinLightMethod) {
             val origin = target.getOrigin()
-            val isTopLevel = origin?.getStrictParentOfType<JetClassOrObject>() == null
-            if (origin is JetProperty || origin is JetPropertyAccessor || origin is JetParameter) {
-                val property = if (origin is JetPropertyAccessor)
-                    origin.getParent() as JetProperty
+            val isTopLevel = origin?.getStrictParentOfType<KtClassOrObject>() == null
+            if (origin is KtProperty || origin is KtPropertyAccessor || origin is KtParameter) {
+                val property = if (origin is KtPropertyAccessor)
+                    origin.getParent() as KtProperty
                 else
-                    origin as JetNamedDeclaration
+                    origin as KtNamedDeclaration
                 val parameterCount = target.getParameterList().getParameters().size()
                 if (parameterCount == arguments.size()) {
                     val propertyName = Identifier(property.getName()!!, isNullable).assignNoPrototype()
@@ -289,7 +289,7 @@ class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter {
                     }
                 }
             }
-            else if (origin is JetFunction) {
+            else if (origin is KtFunction) {
                 if (isTopLevel) {
                     result = if (origin.isExtensionDeclaration()) {
                         val qualifier = codeConverter.convertExpression(arguments.firstOrNull())
@@ -422,7 +422,7 @@ class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter {
             identifier = Identifier("size()", isNullable).assignNoPrototype()
         }
         else if (qualifier != null) {
-            if (target is KotlinLightField<*, *> && target.getOrigin() is JetObjectDeclaration) {
+            if (target is KotlinLightField<*, *> && target.getOrigin() is KtObjectDeclaration) {
                 result = codeConverter.convertExpression(qualifier)
                 return
             }
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/JavaToKotlinConverter.kt b/j2k/src/org/jetbrains/kotlin/j2k/JavaToKotlinConverter.kt
index feb69aaa583..29809a487fd 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/JavaToKotlinConverter.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/JavaToKotlinConverter.kt
@@ -28,16 +28,16 @@ import org.jetbrains.kotlin.j2k.ast.Element
 import org.jetbrains.kotlin.j2k.usageProcessing.ExternalCodeProcessor
 import org.jetbrains.kotlin.j2k.usageProcessing.UsageProcessing
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 import java.util.*
 
 public interface PostProcessor {
-    public fun insertImport(file: JetFile, fqName: FqName)
+    public fun insertImport(file: KtFile, fqName: FqName)
 
-    public fun doAdditionalProcessing(file: JetFile, rangeMarker: RangeMarker?)
+    public fun doAdditionalProcessing(file: KtFile, rangeMarker: RangeMarker?)
 }
 
 public enum class ParseContext {
@@ -70,7 +70,7 @@ public class JavaToKotlinConverter(
         val texts = withProgressProcessor.processItems(0.5, results.withIndex()) { pair ->
             val (i, result) = pair
             try {
-                val kotlinFile = JetPsiFactory(project).createAnalyzableFile("dummy.kt", result!!.text, files[i])
+                val kotlinFile = KtPsiFactory(project).createAnalyzableFile("dummy.kt", result!!.text, files[i])
 
                 result.importsToAdd.forEach { postProcessor.insertImport(kotlinFile, it) }
 
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ResolverForConverter.kt b/j2k/src/org/jetbrains/kotlin/j2k/ResolverForConverter.kt
index 4124857ee64..efded955dd2 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ResolverForConverter.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ResolverForConverter.kt
@@ -16,13 +16,13 @@
 
 package org.jetbrains.kotlin.j2k
 
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 
 public interface ResolverForConverter {
-    public fun resolveToDescriptor(declaration: JetDeclaration): DeclarationDescriptor?
+    public fun resolveToDescriptor(declaration: KtDeclaration): DeclarationDescriptor?
 }
 
 object EmptyResolverForConverter : ResolverForConverter {
-    override fun resolveToDescriptor(declaration: JetDeclaration) = null
+    override fun resolveToDescriptor(declaration: KtDeclaration) = null
 }
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/TypeConverter.kt b/j2k/src/org/jetbrains/kotlin/j2k/TypeConverter.kt
index cd738d9a6d3..09b8b427fcd 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/TypeConverter.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/TypeConverter.kt
@@ -22,7 +22,7 @@ import com.intellij.psi.CommonClassNames.JAVA_LANG_OBJECT
 import org.jetbrains.kotlin.asJava.KotlinLightElement
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.j2k.ast.*
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.types.TypeUtils
 import java.util.HashMap
@@ -374,7 +374,7 @@ class TypeConverter(val converter: Converter) {
 
         override fun fromAnnotations(owner: PsiModifierListOwner): Mutability {
             if (owner is KotlinLightElement<*, *>) {
-                val jetDeclaration = owner.getOrigin() as? JetCallableDeclaration ?: return Mutability.Default
+                val jetDeclaration = owner.getOrigin() as? KtCallableDeclaration ?: return Mutability.Default
                 val descriptor = converter.services.resolverForConverter.resolveToDescriptor(jetDeclaration) as? CallableDescriptor ?: return Mutability.Default
                 val type = descriptor.getReturnType() ?: return Mutability.Default
                 val classDescriptor = TypeUtils.getClassDescriptor(type) ?: return Mutability.Default
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ast/Identifier.kt b/j2k/src/org/jetbrains/kotlin/j2k/ast/Identifier.kt
index 64b38099036..0e29b4203be 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ast/Identifier.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ast/Identifier.kt
@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.j2k.ast
 
 import com.intellij.psi.PsiNameIdentifierOwner
 import org.jetbrains.kotlin.j2k.CodeBuilder
-import org.jetbrains.kotlin.lexer.JetKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.FqName
 
 fun PsiNameIdentifierOwner.declarationIdentifier(): Identifier {
@@ -58,7 +58,7 @@ class Identifier(
     companion object {
         val Empty = Identifier("")
 
-        private val KEYWORDS = JetTokens.KEYWORDS.getTypes().map { (it as JetKeywordToken).getValue() }.toSet()
+        private val KEYWORDS = KtTokens.KEYWORDS.getTypes().map { (it as KtKeywordToken).getValue() }.toSet()
 
         fun toKotlin(name: String): String = Identifier(name).toKotlin()
     }
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/propertyDetection.kt b/j2k/src/org/jetbrains/kotlin/j2k/propertyDetection.kt
index af502047abe..4cc5cf88b62 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/propertyDetection.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/propertyDetection.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.asJava.KotlinLightMethod
 import org.jetbrains.kotlin.j2k.ast.*
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.addToStdlib.check
@@ -370,7 +370,7 @@ private class PropertyDetector(
         }
         else if (superMethod is KotlinLightMethod) {
             val origin = superMethod.getOrigin()
-            return if (origin is JetProperty) SuperInfo.Property(origin.isVar, origin.name ?: "") else SuperInfo.Function
+            return if (origin is KtProperty) SuperInfo.Property(origin.isVar, origin.name ?: "") else SuperInfo.Function
         }
         else {
             return SuperInfo.Function
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/AccessorToPropertyProcessing.kt b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/AccessorToPropertyProcessing.kt
index ec00ac68016..2960f89fb7d 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/AccessorToPropertyProcessing.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/AccessorToPropertyProcessing.kt
@@ -55,33 +55,33 @@ class AccessorToPropertyProcessing(val accessorMethod: PsiMethod, val accessorKi
     else
         object : ExternalCodeProcessor {
             override fun processUsage(reference: PsiReference): Array<PsiReference>? {
-                val nameExpr = reference.getElement() as? JetSimpleNameExpression ?: return null
-                val callExpr = nameExpr.getParent() as? JetCallExpression ?: return null
+                val nameExpr = reference.getElement() as? KtSimpleNameExpression ?: return null
+                val callExpr = nameExpr.getParent() as? KtCallExpression ?: return null
 
                 val arguments = callExpr.getValueArguments()
 
-                val factory = JetPsiFactory(nameExpr.getProject())
+                val factory = KtPsiFactory(nameExpr.getProject())
                 var propertyNameExpr = factory.createSimpleName(propertyName)
                 if (accessorKind == AccessorKind.GETTER) {
                     if (arguments.size() != 0) return null // incorrect call
-                    propertyNameExpr = callExpr.replace(propertyNameExpr) as JetSimpleNameExpression
+                    propertyNameExpr = callExpr.replace(propertyNameExpr) as KtSimpleNameExpression
                     return propertyNameExpr.getReferences()
                 }
                 else {
                     val value = arguments.singleOrNull()?.getArgumentExpression() ?: return null
-                    var assignment = factory.createExpression("a = b") as JetBinaryExpression
+                    var assignment = factory.createExpression("a = b") as KtBinaryExpression
                     assignment.getRight()!!.replace(value)
 
-                    val qualifiedExpression = callExpr.getParent() as? JetQualifiedExpression
+                    val qualifiedExpression = callExpr.getParent() as? KtQualifiedExpression
                     if (qualifiedExpression != null && qualifiedExpression.getSelectorExpression() == callExpr) {
                         callExpr.replace(propertyNameExpr)
                         assignment.getLeft()!!.replace(qualifiedExpression)
-                        assignment = qualifiedExpression.replace(assignment) as JetBinaryExpression
-                        return (assignment.getLeft() as JetQualifiedExpression).getSelectorExpression()!!.getReferences()
+                        assignment = qualifiedExpression.replace(assignment) as KtBinaryExpression
+                        return (assignment.getLeft() as KtQualifiedExpression).getSelectorExpression()!!.getReferences()
                     }
                     else {
                         assignment.getLeft()!!.replace(propertyNameExpr)
-                        assignment = callExpr.replace(assignment) as JetBinaryExpression
+                        assignment = callExpr.replace(assignment) as KtBinaryExpression
                         return assignment.getLeft()!!.getReferences()
                     }
                 }
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/FieldToPropertyProcessing.kt b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/FieldToPropertyProcessing.kt
index c2f7f413993..7aa93ea4f24 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/FieldToPropertyProcessing.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/FieldToPropertyProcessing.kt
@@ -21,8 +21,8 @@ import com.intellij.util.IncorrectOperationException
 import org.jetbrains.kotlin.j2k.AccessorKind
 import org.jetbrains.kotlin.j2k.CodeConverter
 import org.jetbrains.kotlin.j2k.ast.*
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 
 class FieldToPropertyProcessing(val field: PsiField, val propertyName: String, val isNullable: Boolean) : UsageProcessing {
     override val targetElement: PsiElement get() = this.field
diff --git a/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterMultiFileTest.kt b/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterMultiFileTest.kt
index aba8f9f7a99..ff94be745dd 100644
--- a/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterMultiFileTest.kt
+++ b/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterMultiFileTest.kt
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.idea.j2k.J2kPostProcessor
 import org.jetbrains.kotlin.idea.test.dumpTextWithErrors
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.io.File
 import java.util.ArrayList
@@ -52,7 +52,7 @@ public abstract class AbstractJavaToKotlinConverterMultiFileTest : AbstractJavaT
             val virtualFile = addFile(file, "test")
             val psiFile = psiManager.findFile(virtualFile)!!
             externalPsiFiles.add(psiFile)
-            assert(psiFile is PsiJavaFile || psiFile is JetFile)
+            assert(psiFile is PsiJavaFile || psiFile is KtFile)
         }
 
         val converter = JavaToKotlinConverter(project, ConverterSettings.defaultSettings, IdeaJavaToKotlinServices)
@@ -63,11 +63,11 @@ public abstract class AbstractJavaToKotlinConverterMultiFileTest : AbstractJavaT
 
         fun expectedResultFile(i: Int) = File(filesToConvert[i].getPath().replace(".java", ".kt"))
 
-        val resultFiles = ArrayList<JetFile>()
+        val resultFiles = ArrayList<KtFile>()
         for ((i, javaFile) in psiFilesToConvert.withIndex()) {
             deleteFile(javaFile.getVirtualFile())
             val virtualFile = addFile(results[i], expectedResultFile(i).getName(), "test")
-            resultFiles.add(psiManager.findFile(virtualFile) as JetFile)
+            resultFiles.add(psiManager.findFile(virtualFile) as KtFile)
         }
 
         for ((i, kotlinFile) in resultFiles.withIndex()) {
@@ -76,7 +76,7 @@ public abstract class AbstractJavaToKotlinConverterMultiFileTest : AbstractJavaT
 
         for ((externalFile, externalPsiFile) in externalFiles.zip(externalPsiFiles)) {
             val expectedFile = File(externalFile.getPath() + ".expected")
-            var resultText = if (externalPsiFile is JetFile) {
+            var resultText = if (externalPsiFile is KtFile) {
                 externalPsiFile.dumpTextWithErrors()
             }
             else {
diff --git a/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterSingleFileTest.kt b/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterSingleFileTest.kt
index 970a788efa6..07f38903398 100644
--- a/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterSingleFileTest.kt
+++ b/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterSingleFileTest.kt
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.idea.j2k.IdeaJavaToKotlinServices
 import org.jetbrains.kotlin.idea.j2k.J2kPostProcessor
 import org.jetbrains.kotlin.idea.test.JetWithJdkAndRuntimeLightProjectDescriptor
 import org.jetbrains.kotlin.idea.test.dumpTextWithErrors
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.io.File
 import java.util.regex.Pattern
@@ -136,7 +136,7 @@ public abstract class AbstractJavaToKotlinConverterSingleFileTest : AbstractJava
         return myFixture.configureByText("converterTestFile.java", text) as PsiJavaFile
     }
 
-    private fun createKotlinFile(text: String): JetFile {
-        return myFixture.configureByText("converterTestFile.kt", text) as JetFile
+    private fun createKotlinFile(text: String): KtFile {
+        return myFixture.configureByText("converterTestFile.kt", text) as KtFile
     }
 }
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java b/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java
index 68f3974bb7b..ff13e7059f5 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult;
 import org.jetbrains.kotlin.js.config.Config;
 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.*;
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 
@@ -42,7 +42,7 @@ public final class TopDownAnalyzerFacadeForJS {
 
     @NotNull
     public static JsAnalysisResult analyzeFiles(
-            @NotNull Collection<JetFile> files,
+            @NotNull Collection<KtFile> files,
             @NotNull Config config
     ) {
         BindingTrace trace = new BindingTraceContext();
@@ -65,12 +65,12 @@ public final class TopDownAnalyzerFacadeForJS {
 
     @NotNull
     public static JsAnalysisResult analyzeFilesWithGivenTrace(
-            @NotNull Collection<JetFile> files,
+            @NotNull Collection<KtFile> files,
             @NotNull BindingTrace trace,
             @NotNull ModuleContext moduleContext,
             @NotNull Config config
     ) {
-        Collection<JetFile> allFiles = Config.withJsLibAdded(files, config);
+        Collection<KtFile> allFiles = Config.withJsLibAdded(files, config);
 
         LazyTopDownAnalyzerForTopLevel analyzerForJs = InjectionKt.createTopDownAnalyzerForJs(
                 moduleContext, trace,
@@ -80,9 +80,9 @@ public final class TopDownAnalyzerFacadeForJS {
         return JsAnalysisResult.success(trace, moduleContext.getModule());
     }
 
-    public static void checkForErrors(@NotNull Collection<JetFile> allFiles, @NotNull BindingContext bindingContext) {
+    public static void checkForErrors(@NotNull Collection<KtFile> allFiles, @NotNull BindingContext bindingContext) {
         AnalyzingUtils.throwExceptionOnErrors(bindingContext);
-        for (JetFile file : allFiles) {
+        for (KtFile file : allFiles) {
             AnalyzingUtils.checkForSyntacticErrors(file);
         }
     }
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/suppressWarnings.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/suppressWarnings.kt
index d8e66416652..c9ecf96d1ad 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/suppressWarnings.kt
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/suppressWarnings.kt
@@ -20,9 +20,9 @@ import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.js.PredefinedAnnotation.*
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.Severity
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.js.config.LibrarySourcesConfig
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters1
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils
@@ -42,7 +42,7 @@ public class SuppressUninitializedErrorsForNativeDeclarations : DiagnosticsWithS
         if (diagnostic.getFactory() != Errors.UNINITIALIZED_VARIABLE) return false
 
         @Suppress("UNCHECKED_CAST")
-        val diagnosticWithParameters = diagnostic as DiagnosticWithParameters1<JetSimpleNameExpression, VariableDescriptor>
+        val diagnosticWithParameters = diagnostic as DiagnosticWithParameters1<KtSimpleNameExpression, VariableDescriptor>
 
         val variableDescriptor = diagnosticWithParameters.getA()
 
@@ -54,6 +54,6 @@ public class SuppressWarningsFromExternalModules : DiagnosticsWithSuppression.Di
     override fun isSuppressed(diagnostic: Diagnostic): Boolean {
         val file = diagnostic.getPsiFile()
         return diagnostic.getSeverity() == Severity.WARNING &&
-               file is JetFile && file.getUserData(LibrarySourcesConfig.EXTERNAL_MODULE_NAME) != null
+               file is KtFile && file.getUserData(LibrarySourcesConfig.EXTERNAL_MODULE_NAME) != null
     }
 }
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java b/js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java
index e42fb3b23f4..5a8e3b873a2 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 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.TargetPlatformKt;
 import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
@@ -48,7 +48,7 @@ public abstract class Config {
     @NotNull
     private final LockBasedStorageManager storageManager = new LockBasedStorageManager();
     @NotNull
-    private final List<JetFile> sourceFilesFromLibraries = new SmartList<JetFile>();
+    private final List<KtFile> sourceFilesFromLibraries = new SmartList<KtFile>();
     @NotNull
     private final EcmaVersion target;
 
@@ -111,7 +111,7 @@ public abstract class Config {
 
     public abstract boolean checkLibFilesAndReportErrors(@NotNull Function1<String, Unit> report);
 
-    protected abstract void init(@NotNull List<JetFile> sourceFilesInLibraries, @NotNull List<KotlinJavascriptMetadata> metadata);
+    protected abstract void init(@NotNull List<KtFile> sourceFilesInLibraries, @NotNull List<KotlinJavascriptMetadata> metadata);
 
     @NotNull
     public List<ModuleDescriptorImpl> getModuleDescriptors() {
@@ -130,7 +130,7 @@ public abstract class Config {
     }
 
     @NotNull
-    public List<JetFile> getSourceFilesFromLibraries() {
+    public List<KtFile> getSourceFilesFromLibraries() {
         init();
         return sourceFilesFromLibraries;
     }
@@ -169,8 +169,8 @@ public abstract class Config {
     }
 
     @NotNull
-    public static Collection<JetFile> withJsLibAdded(@NotNull Collection<JetFile> files, @NotNull Config config) {
-        Collection<JetFile> allFiles = Lists.newArrayList();
+    public static Collection<KtFile> withJsLibAdded(@NotNull Collection<KtFile> files, @NotNull Config config) {
+        Collection<KtFile> allFiles = Lists.newArrayList();
         allFiles.addAll(files);
         allFiles.addAll(config.getSourceFilesFromLibraries());
         return allFiles;
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfig.java b/js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfig.java
index a6aa854e009..59a8f45eb44 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfig.java
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfig.java
@@ -29,9 +29,9 @@ import kotlin.jvm.functions.Function1;
 import kotlin.jvm.functions.Function2;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.js.JavaScript;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadata;
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils;
 import org.jetbrains.kotlin.utils.LibraryUtils;
@@ -88,7 +88,7 @@ public class LibrarySourcesConfig extends Config {
     }
 
     @Override
-    protected void init(@NotNull final List<JetFile> sourceFilesInLibraries, @NotNull final List<KotlinJavascriptMetadata> metadata) {
+    protected void init(@NotNull final List<KtFile> sourceFilesInLibraries, @NotNull final List<KotlinJavascriptMetadata> metadata) {
         if (files.isEmpty()) return;
 
         final PsiManager psiManager = PsiManager.getInstance(getProject());
@@ -234,12 +234,12 @@ public class LibrarySourcesConfig extends Config {
         }
     }
 
-    protected static JetFile getJetFileByVirtualFile(VirtualFile file, String moduleName, PsiManager psiManager) {
+    protected static KtFile getJetFileByVirtualFile(VirtualFile file, String moduleName, PsiManager psiManager) {
         PsiFile psiFile = psiManager.findFile(file);
         assert psiFile != null;
 
         setupPsiFile(psiFile, moduleName);
-        return (JetFile) psiFile;
+        return (KtFile) psiFile;
     }
 
     protected static void setupPsiFile(PsiFile psiFile, String moduleName) {
@@ -247,11 +247,11 @@ public class LibrarySourcesConfig extends Config {
     }
 
     private static class JetFileCollector extends VirtualFileVisitor {
-        private final List<JetFile> jetFiles;
+        private final List<KtFile> jetFiles;
         private final String moduleName;
         private final PsiManager psiManager;
 
-        private JetFileCollector(List<JetFile> files, String name, PsiManager manager) {
+        private JetFileCollector(List<KtFile> files, String name, PsiManager manager) {
             moduleName = name;
             psiManager = manager;
             jetFiles = files;
@@ -259,7 +259,7 @@ public class LibrarySourcesConfig extends Config {
 
         @Override
         public boolean visitFile(@NotNull VirtualFile file) {
-            if (!file.isDirectory() && StringUtil.notNullize(file.getExtension()).equalsIgnoreCase(JetFileType.EXTENSION)) {
+            if (!file.isDirectory() && StringUtil.notNullize(file.getExtension()).equalsIgnoreCase(KotlinFileType.EXTENSION)) {
                 jetFiles.add(getJetFileByVirtualFile(file, moduleName, psiManager));
             }
             return true;
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/descriptorUtils/descriptorUtils.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/descriptorUtils/descriptorUtils.kt
index ef3a4e7a305..d0292ab0eb8 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/descriptorUtils/descriptorUtils.kt
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/descriptorUtils/descriptorUtils.kt
@@ -22,9 +22,9 @@ import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
-public val JetType.nameIfStandardType: Name?
+public val KtType.nameIfStandardType: Name?
     get() {
         val descriptor = getConstructor().getDeclarationDescriptor()
 
@@ -35,7 +35,7 @@ public val JetType.nameIfStandardType: Name?
         return null
     }
 
-public fun JetType.getJetTypeFqName(printTypeArguments: Boolean): String {
+public fun KtType.getJetTypeFqName(printTypeArguments: Boolean): String {
     val declaration = requireNotNull(getConstructor().getDeclarationDescriptor())
     if (declaration is TypeParameterDescriptor) {
         return StringUtil.join(declaration.getUpperBounds(), { type -> type.getJetTypeFqName(printTypeArguments) }, "&")
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/ErrorsJs.java b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/ErrorsJs.java
index d18bf343c9b..f1856e7e433 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/ErrorsJs.java
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/ErrorsJs.java
@@ -20,30 +20,30 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticFactory0;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory2;
 import org.jetbrains.kotlin.diagnostics.Errors;
-import org.jetbrains.kotlin.psi.JetDeclaration;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetNamedDeclaration;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtElement;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtNamedDeclaration;
+import org.jetbrains.kotlin.types.KtType;
 
 import static org.jetbrains.kotlin.diagnostics.PositioningStrategies.*;
 import static org.jetbrains.kotlin.diagnostics.Severity.ERROR;
 import static org.jetbrains.kotlin.diagnostics.Severity.WARNING;
 
 public interface ErrorsJs {
-    DiagnosticFactory1<JetElement, JetType> NATIVE_ANNOTATIONS_ALLOWED_ONLY_ON_MEMBER_OR_EXTENSION_FUN = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
-    DiagnosticFactory1<JetElement, String> NATIVE_INDEXER_KEY_SHOULD_BE_STRING_OR_NUMBER = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
-    DiagnosticFactory1<JetElement, String> NATIVE_INDEXER_CAN_NOT_HAVE_DEFAULT_ARGUMENTS = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
-    DiagnosticFactory0<JetDeclaration> NATIVE_GETTER_RETURN_TYPE_SHOULD_BE_NULLABLE = DiagnosticFactory0.create(ERROR, DECLARATION_RETURN_TYPE);
-    DiagnosticFactory0<JetDeclaration> NATIVE_SETTER_WRONG_RETURN_TYPE = DiagnosticFactory0.create(ERROR, DECLARATION_RETURN_TYPE);
-    DiagnosticFactory2<JetElement, Integer, String> NATIVE_INDEXER_WRONG_PARAMETER_COUNT = DiagnosticFactory2.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
-    DiagnosticFactory1<JetExpression, JsCallData> JSCODE_ERROR = DiagnosticFactory1.create(ERROR, JsCodePositioningStrategy.INSTANCE$);
-    DiagnosticFactory1<JetExpression, JsCallData> JSCODE_WARNING = DiagnosticFactory1.create(WARNING, JsCodePositioningStrategy.INSTANCE$);
-    DiagnosticFactory0<JetExpression> JSCODE_ARGUMENT_SHOULD_BE_CONSTANT = DiagnosticFactory0.create(ERROR, DEFAULT);
-    DiagnosticFactory1<JetElement, JetElement> NOT_SUPPORTED = DiagnosticFactory1.create(ERROR, DEFAULT);
-    DiagnosticFactory1<JetElement, JetElement> REFERENCE_TO_BUILTIN_MEMBERS_NOT_SUPPORTED = DiagnosticFactory1.create(ERROR, DEFAULT);
-    DiagnosticFactory1<JetNamedDeclaration, String> NON_TOPLEVEL_CLASS_DECLARATION = DiagnosticFactory1.create(ERROR, DECLARATION_NAME);
-    DiagnosticFactory0<JetExpression> JSCODE_NO_JAVASCRIPT_PRODUCED = DiagnosticFactory0.create(ERROR, DEFAULT);
+    DiagnosticFactory1<KtElement, KtType> NATIVE_ANNOTATIONS_ALLOWED_ONLY_ON_MEMBER_OR_EXTENSION_FUN = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
+    DiagnosticFactory1<KtElement, String> NATIVE_INDEXER_KEY_SHOULD_BE_STRING_OR_NUMBER = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
+    DiagnosticFactory1<KtElement, String> NATIVE_INDEXER_CAN_NOT_HAVE_DEFAULT_ARGUMENTS = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
+    DiagnosticFactory0<KtDeclaration> NATIVE_GETTER_RETURN_TYPE_SHOULD_BE_NULLABLE = DiagnosticFactory0.create(ERROR, DECLARATION_RETURN_TYPE);
+    DiagnosticFactory0<KtDeclaration> NATIVE_SETTER_WRONG_RETURN_TYPE = DiagnosticFactory0.create(ERROR, DECLARATION_RETURN_TYPE);
+    DiagnosticFactory2<KtElement, Integer, String> NATIVE_INDEXER_WRONG_PARAMETER_COUNT = DiagnosticFactory2.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
+    DiagnosticFactory1<KtExpression, JsCallData> JSCODE_ERROR = DiagnosticFactory1.create(ERROR, JsCodePositioningStrategy.INSTANCE$);
+    DiagnosticFactory1<KtExpression, JsCallData> JSCODE_WARNING = DiagnosticFactory1.create(WARNING, JsCodePositioningStrategy.INSTANCE$);
+    DiagnosticFactory0<KtExpression> JSCODE_ARGUMENT_SHOULD_BE_CONSTANT = DiagnosticFactory0.create(ERROR, DEFAULT);
+    DiagnosticFactory1<KtElement, KtElement> NOT_SUPPORTED = DiagnosticFactory1.create(ERROR, DEFAULT);
+    DiagnosticFactory1<KtElement, KtElement> REFERENCE_TO_BUILTIN_MEMBERS_NOT_SUPPORTED = DiagnosticFactory1.create(ERROR, DEFAULT);
+    DiagnosticFactory1<KtNamedDeclaration, String> NON_TOPLEVEL_CLASS_DECLARATION = DiagnosticFactory1.create(ERROR, DECLARATION_NAME);
+    DiagnosticFactory0<KtExpression> JSCODE_NO_JAVASCRIPT_PRODUCED = DiagnosticFactory0.create(ERROR, DEFAULT);
 
     @SuppressWarnings("UnusedDeclaration")
     Object _initializer = new Object() {
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCallChecker.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCallChecker.kt
index e235a739a2f..2c00a2414e6 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCallChecker.kt
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCallChecker.kt
@@ -31,10 +31,10 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1
 import org.jetbrains.kotlin.js.parser.parse
 import org.jetbrains.kotlin.js.patterns.DescriptorPredicate
 import org.jetbrains.kotlin.js.patterns.PatternBuilder
-import org.jetbrains.kotlin.psi.JetCallExpression
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetLiteralStringTemplateEntry
-import org.jetbrains.kotlin.psi.JetStringTemplateExpression
+import org.jetbrains.kotlin.psi.KtCallExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtLiteralStringTemplateEntry
+import org.jetbrains.kotlin.psi.KtStringTemplateExpression
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.TemporaryBindingTrace
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
@@ -69,7 +69,7 @@ public class JsCallChecker(
         if (context.isAnnotationContext || !resolvedCall.isJsCall()) return
 
         val expression = resolvedCall.getCall().getCallElement()
-        if (expression !is JetCallExpression) return
+        if (expression !is KtCallExpression) return
 
         val arguments = expression.getValueArgumentList()?.getArguments()
         val argument = arguments?.firstOrNull()?.getArgumentExpression() ?: return
@@ -102,7 +102,7 @@ public class JsCallChecker(
 }
 
 class JsCodeErrorReporter(
-        private val nodeToReport: JetExpression,
+        private val nodeToReport: KtExpression,
         private val code: String,
         private val trace: BindingTrace
 ) : ErrorReporter {
@@ -116,7 +116,7 @@ class JsCodeErrorReporter(
     }
 
     private fun report(
-            diagnosticFactory: DiagnosticFactory1<JetExpression, JsCallData>,
+            diagnosticFactory: DiagnosticFactory1<KtExpression, JsCallData>,
             message: String,
             startPosition: CodePosition,
             endPosition: CodePosition
@@ -173,8 +173,8 @@ private fun String.offsetOf(position: CodePosition): Int {
     return length()
 }
 
-private val JetExpression.isConstantStringLiteral: Boolean
-    get() = this is JetStringTemplateExpression && getEntries().all { it is JetLiteralStringTemplateEntry }
+private val KtExpression.isConstantStringLiteral: Boolean
+    get() = this is KtStringTemplateExpression && getEntries().all { it is KtLiteralStringTemplateEntry }
 
 open class JsCallData(val reportRange: TextRange, val message: String)
 
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCodePositioningStrategy.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCodePositioningStrategy.kt
index 9b4f7e64391..015fd2c7083 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCodePositioningStrategy.kt
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCodePositioningStrategy.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.js.resolve.diagnostics
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.diagnostics.PositioningStrategy
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters3
 import org.jetbrains.kotlin.diagnostics.ParametrizedDiagnostic
 import org.jetbrains.kotlin.js.resolve.diagnostics.JsCallData
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters1
 public object JsCodePositioningStrategy : PositioningStrategy<PsiElement>() {
     override fun markDiagnostic(diagnostic: ParametrizedDiagnostic<out PsiElement>): List<TextRange> {
         @Suppress("UNCHECKED_CAST")
-        val diagnosticWithParameters = diagnostic as DiagnosticWithParameters1<JetExpression, JsCallData>
+        val diagnosticWithParameters = diagnostic as DiagnosticWithParameters1<KtExpression, JsCallData>
         val textRange = diagnosticWithParameters.getA().reportRange
         return listOf(textRange)
     }
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/nativeAnnotationCheckers.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/nativeAnnotationCheckers.kt
index dcdfb6163e9..4ea3f2ddb4b 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/nativeAnnotationCheckers.kt
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/nativeAnnotationCheckers.kt
@@ -25,8 +25,8 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.js.PredefinedAnnotation
 import org.jetbrains.kotlin.js.resolve.diagnostics.ErrorsJs
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DeclarationChecker
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -36,17 +36,17 @@ import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
 
 private abstract class AbstractNativeAnnotationsChecker(private val requiredAnnotation: PredefinedAnnotation) : DeclarationChecker {
 
-    open fun additionalCheck(declaration: JetNamedFunction, descriptor: FunctionDescriptor, diagnosticHolder: DiagnosticSink) {}
+    open fun additionalCheck(declaration: KtNamedFunction, descriptor: FunctionDescriptor, diagnosticHolder: DiagnosticSink) {}
 
     override fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext
     ) {
         val annotationDescriptor = descriptor.getAnnotations().findAnnotation(requiredAnnotation.fqName) ?: return
 
-        if (declaration !is JetNamedFunction || descriptor !is FunctionDescriptor) {
+        if (declaration !is KtNamedFunction || descriptor !is FunctionDescriptor) {
             return
         }
 
@@ -71,7 +71,7 @@ private abstract class AbstractNativeIndexerChecker(
         private val requiredParametersCount: Int
 ) : AbstractNativeAnnotationsChecker(requiredAnnotation) {
 
-    override fun additionalCheck(declaration: JetNamedFunction, descriptor: FunctionDescriptor, diagnosticHolder: DiagnosticSink) {
+    override fun additionalCheck(declaration: KtNamedFunction, descriptor: FunctionDescriptor, diagnosticHolder: DiagnosticSink) {
         val parameters = descriptor.getValueParameters()
         val builtIns = descriptor.builtIns
         if (parameters.size() > 0) {
@@ -96,7 +96,7 @@ private abstract class AbstractNativeIndexerChecker(
 }
 
 public class NativeGetterChecker : AbstractNativeIndexerChecker(PredefinedAnnotation.NATIVE_GETTER, "getter", requiredParametersCount = 1) {
-    override fun additionalCheck(declaration: JetNamedFunction, descriptor: FunctionDescriptor, diagnosticHolder: DiagnosticSink) {
+    override fun additionalCheck(declaration: KtNamedFunction, descriptor: FunctionDescriptor, diagnosticHolder: DiagnosticSink) {
         super.additionalCheck(declaration, descriptor, diagnosticHolder)
 
         val returnType = descriptor.getReturnType()
@@ -107,7 +107,7 @@ public class NativeGetterChecker : AbstractNativeIndexerChecker(PredefinedAnnota
 }
 
 public class NativeSetterChecker : AbstractNativeIndexerChecker(PredefinedAnnotation.NATIVE_SETTER, "setter", requiredParametersCount = 2) {
-    override fun additionalCheck(declaration: JetNamedFunction, descriptor: FunctionDescriptor, diagnosticHolder: DiagnosticSink) {
+    override fun additionalCheck(declaration: KtNamedFunction, descriptor: FunctionDescriptor, diagnosticHolder: DiagnosticSink) {
         super.additionalCheck(declaration, descriptor, diagnosticHolder)
 
         val returnType = descriptor.getReturnType()
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/unsupportedFeatureCheckers.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/unsupportedFeatureCheckers.kt
index dcefa7fd311..0185d5b6b6f 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/unsupportedFeatureCheckers.kt
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/unsupportedFeatureCheckers.kt
@@ -32,12 +32,12 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 
 class ClassDeclarationChecker : DeclarationChecker {
     override fun check(
-            declaration: JetDeclaration,
+            declaration: KtDeclaration,
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext
     ) {
-        if (declaration !is JetClassOrObject || declaration is JetObjectDeclaration || declaration is JetEnumEntry) return
+        if (declaration !is KtClassOrObject || declaration is KtObjectDeclaration || declaration is KtEnumEntry) return
 
         // hack to avoid to get diagnostics when compile kotlin builtins
         val fqNameUnsafe = DescriptorUtils.getFqName(descriptor)
diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt
index 27a08d08778..6d34e86f932 100644
--- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt
+++ b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.*
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 class KotlinJavascriptAnnotationAndConstantLoader(
         module: ModuleDescriptor
@@ -82,7 +82,7 @@ class KotlinJavascriptAnnotationAndConstantLoader(
     override fun loadPropertyConstant(
             container: ProtoContainer,
             proto: ProtoBuf.Property,
-            expectedType: JetType
+            expectedType: KtType
     ): ConstantValue<*>? {
         if (!proto.hasExtension(JsProtoBuf.compileTimeValue)) return null
         val value = proto.getExtension(JsProtoBuf.compileTimeValue)
diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt
index ff729af9e67..a477e544f54 100644
--- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt
+++ b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.serialization.AnnotationSerializer
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.SerializerExtension
 import org.jetbrains.kotlin.serialization.StringTableImpl
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 public class KotlinJavascriptSerializerExtension : SerializerExtension() {
     private val stringTable = StringTableImpl()
@@ -64,7 +64,7 @@ public class KotlinJavascriptSerializerExtension : SerializerExtension() {
         }
     }
 
-    override fun serializeType(type: JetType, proto: ProtoBuf.Type.Builder) {
+    override fun serializeType(type: KtType, proto: ProtoBuf.Type.Builder) {
         for (annotation in type.annotations) {
             proto.addExtension(JsProtoBuf.typeAnnotation, annotationSerializer.serializeAnnotation(annotation))
         }
diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicTest.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicTest.java
index 0e8eb5f1ec1..92e4d822247 100644
--- a/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicTest.java
+++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicTest.java
@@ -33,7 +33,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.config.CompilerConfiguration;
-import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.js.JavaScript;
 import org.jetbrains.kotlin.js.config.Config;
 import org.jetbrains.kotlin.js.config.EcmaVersion;
@@ -45,8 +45,8 @@ import org.jetbrains.kotlin.js.test.rhino.RhinoResultChecker;
 import org.jetbrains.kotlin.js.test.utils.DirectiveTestUtils;
 import org.jetbrains.kotlin.js.test.utils.JsTestUtils;
 import org.jetbrains.kotlin.js.translate.context.Namer;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetPsiFactory;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtPsiFactory;
 import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment;
 import org.jetbrains.kotlin.test.JetTestUtils;
 
@@ -172,7 +172,7 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
     ) throws Exception {
         Project project = getProject();
         List<String> allFiles = withAdditionalKotlinFiles(files);
-        List<JetFile> jetFiles = createJetFileList(project, allFiles, null);
+        List<KtFile> jetFiles = createJetFileList(project, allFiles, null);
 
         Config config = createConfig(getProject(), moduleName, version, libraries);
         File outputFile = new File(getOutputFilePath(testName, version));
@@ -185,7 +185,7 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
     }
 
     protected void translateFiles(
-            @NotNull List<JetFile> jetFiles,
+            @NotNull List<KtFile> jetFiles,
             @NotNull File outputFile,
             @NotNull MainCallParameters mainCallParameters,
             @NotNull Config config
@@ -225,8 +225,8 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
         return false;
     }
 
-    protected void processJsProgram(@NotNull JsProgram program, @NotNull List<JetFile> jetFiles) throws Exception {
-        for (JetFile file : jetFiles) {
+    protected void processJsProgram(@NotNull JsProgram program, @NotNull List<KtFile> jetFiles) throws Exception {
+        for (KtFile file : jetFiles) {
             String text = file.getText();
             DirectiveTestUtils.processDirectives(program, text);
         }
@@ -254,9 +254,9 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
         List<String> additionalFiles = Lists.newArrayList();
 
         // add all kotlin files from testData/_commonFiles
-        additionalFiles.addAll(JsTestUtils.getFilesInDirectoryByExtension(TEST_DATA_DIR_PATH + COMMON_FILES_DIR, JetFileType.EXTENSION));
+        additionalFiles.addAll(JsTestUtils.getFilesInDirectoryByExtension(TEST_DATA_DIR_PATH + COMMON_FILES_DIR, KotlinFileType.EXTENSION));
         // add all kotlin files from <testDir>/_commonFiles
-        additionalFiles.addAll(JsTestUtils.getFilesInDirectoryByExtension(pathToTestDir() + COMMON_FILES_DIR, JetFileType.EXTENSION));
+        additionalFiles.addAll(JsTestUtils.getFilesInDirectoryByExtension(pathToTestDir() + COMMON_FILES_DIR, KotlinFileType.EXTENSION));
 
         return additionalFiles;
     }
@@ -347,8 +347,8 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
         return allFiles;
     }
 
-    private static List<JetFile> createJetFileList(@NotNull Project project, @NotNull List<String> list, @Nullable String root) {
-        List<JetFile> libFiles = Lists.newArrayList();
+    private static List<KtFile> createJetFileList(@NotNull Project project, @NotNull List<String> list, @Nullable String root) {
+        List<KtFile> libFiles = Lists.newArrayList();
 
         PsiManager psiManager = PsiManager.getInstance(project);
         VirtualFileSystem fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL);
@@ -360,7 +360,7 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
             //TODO logging?
             assert virtualFile != null;
             PsiFile psiFile = psiManager.findFile(virtualFile);
-            libFiles.add((JetFile) psiFile);
+            libFiles.add((KtFile) psiFile);
         }
         return libFiles;
     }
@@ -368,8 +368,8 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
     @NotNull
     protected String getPackageName(@NotNull String filename) throws IOException {
         String content = FileUtil.loadFile(new File(filename), true);
-        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
-        JetFile jetFile = psiFactory.createFile(content);
+        KtPsiFactory psiFactory = new KtPsiFactory(getProject());
+        KtFile jetFile = psiFactory.createFile(content);
         String packageName = jetFile.getPackageFqName().asString();
         return packageName.isEmpty() ? Namer.getRootPackageName() : packageName;
     }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java
index d85e91fe58e..857e9cd60f2 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.js.facade.exceptions.TranslationException;
 import org.jetbrains.kotlin.js.inline.JsInliner;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.Translation;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
 
@@ -54,7 +54,7 @@ public final class K2JSTranslator {
 
     @NotNull
     public TranslationResult translate(
-            @NotNull List<JetFile> files,
+            @NotNull List<KtFile> files,
             @NotNull MainCallParameters mainCallParameters
     ) throws TranslationException {
         return translate(files, mainCallParameters, null);
@@ -62,7 +62,7 @@ public final class K2JSTranslator {
 
     @NotNull
     public TranslationResult translate(
-            @NotNull List<JetFile> files,
+            @NotNull List<KtFile> files,
             @NotNull MainCallParameters mainCallParameters,
             @Nullable JsAnalysisResult analysisResult
     ) throws TranslationException {
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/facade/TranslationResult.kt b/js/js.translator/src/org/jetbrains/kotlin/js/facade/TranslationResult.kt
index ea12b79bd33..a1856e729e3 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/facade/TranslationResult.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/facade/TranslationResult.kt
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.js.config.Config
 import org.jetbrains.kotlin.js.sourceMap.JsSourceGenerationVisitor
 import org.jetbrains.kotlin.js.sourceMap.SourceMap3Builder
 import org.jetbrains.kotlin.js.sourceMap.SourceMapBuilder
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
@@ -43,7 +43,7 @@ public abstract class TranslationResult protected constructor(public val diagnos
 
     public class Success(
             private val config: Config,
-            private val files: List<JetFile>,
+            private val files: List<KtFile>,
             public val program: JsProgram,
             diagnostics: Diagnostics,
             private val moduleDescriptor: ModuleDescriptor
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfoExtensions.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfoExtensions.kt
index da728341415..6ed82a07f30 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfoExtensions.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfoExtensions.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.js.translate.callTranslator
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
-import org.jetbrains.kotlin.psi.JetSuperExpression
+import org.jetbrains.kotlin.psi.KtSuperExpression
 import com.google.dart.compiler.backend.js.ast.JsExpression
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import com.google.dart.compiler.backend.js.ast.JsName
@@ -41,7 +41,7 @@ fun CallInfo.isNative(): Boolean = AnnotationsUtils.isNativeObject(callableDescr
 
 fun CallInfo.isSuperInvocation(): Boolean {
     val dispatchReceiver = resolvedCall.getDispatchReceiver()
-    return dispatchReceiver is ExpressionReceiver && dispatchReceiver.getExpression() is JetSuperExpression
+    return dispatchReceiver is ExpressionReceiver && dispatchReceiver.getExpression() is KtSuperExpression
 }
 
 val VariableAccessInfo.variableDescriptor: VariableDescriptor
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/FunctionCallCases.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/FunctionCallCases.kt
index c35dfe04dd8..87f6cc4fd41 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/FunctionCallCases.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/FunctionCallCases.kt
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.js.translate.reference.CallArgumentTranslator
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils
 import org.jetbrains.kotlin.js.translate.utils.PsiUtils
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.calls.tasks.isDynamic
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
@@ -256,31 +256,31 @@ object DynamicOperatorCallCase : FunctionCallCase() {
     fun canApply(callInfo: FunctionCallInfo): Boolean =
             callInfo.callableDescriptor.isDynamic() &&
             callInfo.resolvedCall.getCall().getCallElement() let {
-                it is JetOperationExpression &&
-                PsiUtils.getOperationToken(it) let { (it == JetTokens.NOT_IN || OperatorTable.hasCorrespondingOperator(it)) }
+                it is KtOperationExpression &&
+                PsiUtils.getOperationToken(it) let { (it == KtTokens.NOT_IN || OperatorTable.hasCorrespondingOperator(it)) }
             }
 
     override fun FunctionCallInfo.dispatchReceiver(): JsExpression {
-        val callElement = resolvedCall.getCall().getCallElement() as JetOperationExpression
+        val callElement = resolvedCall.getCall().getCallElement() as KtOperationExpression
         val operationToken = PsiUtils.getOperationToken(callElement)
 
         val arguments = argumentsInfo.translateArguments
 
         return when (callElement) {
-            is JetBinaryExpression -> {
+            is KtBinaryExpression -> {
                 // `!in` translated as `in` and will be wrapped by negation operation in BinaryOperationTranslator#translateAsOverloadedBinaryOperation by mayBeWrapWithNegation
-                val operationTokenToFind = if (operationToken == JetTokens.NOT_IN) JetTokens.IN_KEYWORD else operationToken
+                val operationTokenToFind = if (operationToken == KtTokens.NOT_IN) KtTokens.IN_KEYWORD else operationToken
                 val binaryOperator = OperatorTable.getBinaryOperator(operationTokenToFind)
 
-                if (operationTokenToFind == JetTokens.IN_KEYWORD)
+                if (operationTokenToFind == KtTokens.IN_KEYWORD)
                     JsBinaryOperation(binaryOperator, arguments[0], dispatchReceiver)
                 else
                     JsBinaryOperation(binaryOperator, dispatchReceiver, arguments[0])
             }
-            is JetPrefixExpression -> {
+            is KtPrefixExpression -> {
                 JsPrefixOperation(OperatorTable.getUnaryOperator(operationToken), dispatchReceiver)
             }
-            is JetPostfixExpression -> {
+            is KtPostfixExpression -> {
                 // TODO drop hack with ":JsExpression" when KT-5569 will be fixed
                 @Suppress("USELESS_CAST")
                 (JsPostfixOperation(OperatorTable.getUnaryOperator(operationToken), dispatchReceiver) as JsExpression)
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/AliasingContext.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/AliasingContext.java
index bd1fd4a8d01..c59c2728e74 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/AliasingContext.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/AliasingContext.java
@@ -21,7 +21,7 @@ import gnu.trove.THashMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 
 import java.util.Collections;
 import java.util.Map;
@@ -35,7 +35,7 @@ public class AliasingContext {
     private Map<DeclarationDescriptor, JsExpression> aliasesForDescriptors;
 
     @Nullable
-    private final Map<JetExpression, JsExpression> aliasesForExpressions;
+    private final Map<KtExpression, JsExpression> aliasesForExpressions;
 
     @Nullable
     private final AliasingContext parent;
@@ -43,7 +43,7 @@ public class AliasingContext {
     private AliasingContext(
             @Nullable AliasingContext parent,
             @Nullable Map<DeclarationDescriptor, JsExpression> aliasesForDescriptors,
-            @Nullable Map<JetExpression, JsExpression> aliasesForExpressions
+            @Nullable Map<KtExpression, JsExpression> aliasesForExpressions
     ) {
         this.parent = parent;
         this.aliasesForDescriptors = aliasesForDescriptors;
@@ -61,7 +61,7 @@ public class AliasingContext {
     }
 
     @NotNull
-    public AliasingContext withExpressionsAliased(@NotNull Map<JetExpression, JsExpression> aliasesForExpressions) {
+    public AliasingContext withExpressionsAliased(@NotNull Map<KtExpression, JsExpression> aliasesForExpressions) {
         return new AliasingContext(this, null, aliasesForExpressions);
     }
 
@@ -84,7 +84,7 @@ public class AliasingContext {
     }
 
     @Nullable
-    public JsExpression getAliasForExpression(@NotNull JetExpression element) {
+    public JsExpression getAliasForExpression(@NotNull KtExpression element) {
         JsExpression alias = aliasesForExpressions == null ? null : aliasesForExpressions.get(element);
         return alias != null || parent == null ? alias : parent.getAliasForExpression(element);
     }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/TranslationContext.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/TranslationContext.java
index 62658b68431..1c461208e66 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/TranslationContext.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/TranslationContext.java
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.js.config.Config;
 import org.jetbrains.kotlin.js.translate.intrinsic.Intrinsics;
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 
@@ -140,7 +140,7 @@ public class TranslationContext {
     }
 
     @NotNull
-    public TranslationContext innerContextWithAliasesForExpressions(@NotNull Map<JetExpression, JsExpression> aliases) {
+    public TranslationContext innerContextWithAliasesForExpressions(@NotNull Map<KtExpression, JsExpression> aliases) {
         return this.innerWithAliasingContext(aliasingContext.withExpressionsAliased(aliases));
     }
 
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.kt
index f7c54f91906..15a6f5779b1 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.kt
@@ -42,13 +42,13 @@ import org.jetbrains.kotlin.js.translate.utils.JsDescriptorUtils.getSupertypesWi
 import org.jetbrains.kotlin.js.translate.utils.PsiUtils.getPrimaryConstructorParameters
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils.simpleReturnFunction
 import org.jetbrains.kotlin.js.translate.utils.jsAstUtils.toInvocationWith
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetObjectDeclaration
-import org.jetbrains.kotlin.psi.JetSecondaryConstructor
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
+import org.jetbrains.kotlin.psi.KtSecondaryConstructor
 import org.jetbrains.kotlin.resolve.BindingContextUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils.*
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.TypeConstructor
 import org.jetbrains.kotlin.types.TypeUtils.topologicallySortSuperclassesAndRecordAllInstances
 import org.jetbrains.kotlin.utils.identity
@@ -58,7 +58,7 @@ import java.util.*
  * Generates a definition of a single class.
  */
 public class ClassTranslator private constructor(
-        private val classDeclaration: JetClassOrObject,
+        private val classDeclaration: KtClassOrObject,
         context: TranslationContext
 ) : AbstractTranslator(context) {
 
@@ -190,7 +190,7 @@ public class ClassTranslator private constructor(
         for (type in supertypes) {
             supertypeConstructors.add(type.getConstructor())
         }
-        val sortedAllSuperTypes = topologicallySortSuperclassesAndRecordAllInstances(descriptor.getDefaultType(), HashMap<TypeConstructor, Set<JetType>>(), HashSet<TypeConstructor>())
+        val sortedAllSuperTypes = topologicallySortSuperclassesAndRecordAllInstances(descriptor.getDefaultType(), HashMap<TypeConstructor, Set<KtType>>(), HashSet<TypeConstructor>())
         val supertypesRefs = ArrayList<JsExpression>()
         for (typeConstructor in sortedAllSuperTypes) {
             if (supertypeConstructors.contains(typeConstructor)) {
@@ -269,7 +269,7 @@ public class ClassTranslator private constructor(
     }
 
     companion object {
-        public fun translate(classDeclaration: JetClass, context: TranslationContext): List<JsPropertyInitializer> {
+        public fun translate(classDeclaration: KtClass, context: TranslationContext): List<JsPropertyInitializer> {
             val result = arrayListOf<JsPropertyInitializer>()
 
             val classDescriptor = getClassDescriptor(context.bindingContext(), classDeclaration)
@@ -286,16 +286,16 @@ public class ClassTranslator private constructor(
         }
 
         @JvmStatic
-        public fun generateClassCreation(classDeclaration: JetClassOrObject, context: TranslationContext): JsInvocation {
+        public fun generateClassCreation(classDeclaration: KtClassOrObject, context: TranslationContext): JsInvocation {
             return ClassTranslator(classDeclaration, context).translate()
         }
 
         @JvmStatic
-        public fun generateObjectLiteral(objectDeclaration: JetObjectDeclaration, context: TranslationContext): JsExpression {
+        public fun generateObjectLiteral(objectDeclaration: KtObjectDeclaration, context: TranslationContext): JsExpression {
             return ClassTranslator(objectDeclaration, context).translateObjectLiteralExpression()
         }
 
-        private fun generateSecondaryConstructor(constructor: JetSecondaryConstructor, context: TranslationContext): JsPropertyInitializer {
+        private fun generateSecondaryConstructor(constructor: KtSecondaryConstructor, context: TranslationContext): JsPropertyInitializer {
             val constructorDescriptor = BindingUtils.getDescriptorForElement(context.bindingContext(), constructor) as ConstructorDescriptor
             val classDescriptor = constructorDescriptor.getContainingDeclaration()
 
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/DeclarationBodyVisitor.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/DeclarationBodyVisitor.java
index 069c4b8de96..c7ef6c6be8f 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/DeclarationBodyVisitor.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/DeclarationBodyVisitor.java
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.js.translate.initializer.ClassInitializerTranslator;
 import org.jetbrains.kotlin.js.translate.utils.BindingUtils;
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.List;
 
@@ -67,15 +67,15 @@ public class DeclarationBodyVisitor extends TranslatorVisitor<Void> {
     }
 
     @Override
-    public Void visitClass(@NotNull JetClass expression, TranslationContext context) {
+    public Void visitClass(@NotNull KtClass expression, TranslationContext context) {
         return null;
     }
 
     @Override
-    public Void visitEnumEntry(@NotNull JetEnumEntry enumEntry, TranslationContext data) {
+    public Void visitEnumEntry(@NotNull KtEnumEntry enumEntry, TranslationContext data) {
         JsExpression jsEnumEntryCreation;
         ClassDescriptor descriptor = getClassDescriptor(data.bindingContext(), enumEntry);
-        List<JetType> supertypes = getSupertypesWithoutFakes(descriptor);
+        List<KtType> supertypes = getSupertypesWithoutFakes(descriptor);
         if (enumEntry.getBody() != null || supertypes.size() > 1) {
             jsEnumEntryCreation = ClassTranslator.generateClassCreation(enumEntry, data);
         } else {
@@ -87,7 +87,7 @@ public class DeclarationBodyVisitor extends TranslatorVisitor<Void> {
     }
 
     @Override
-    public Void visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, TranslationContext context) {
+    public Void visitObjectDeclaration(@NotNull KtObjectDeclaration declaration, TranslationContext context) {
         if (!declaration.isCompanion()) {
             // parsed it in initializer visitor => no additional actions are needed
             return null;
@@ -101,7 +101,7 @@ public class DeclarationBodyVisitor extends TranslatorVisitor<Void> {
     }
 
     @Override
-    public Void visitNamedFunction(@NotNull JetNamedFunction expression, TranslationContext context) {
+    public Void visitNamedFunction(@NotNull KtNamedFunction expression, TranslationContext context) {
         FunctionDescriptor descriptor = getFunctionDescriptor(context.bindingContext(), expression);
         if (descriptor.getModality() == Modality.ABSTRACT) {
             return null;
@@ -113,20 +113,20 @@ public class DeclarationBodyVisitor extends TranslatorVisitor<Void> {
     }
 
     @Override
-    public Void visitProperty(@NotNull JetProperty expression, TranslationContext context) {
+    public Void visitProperty(@NotNull KtProperty expression, TranslationContext context) {
         PropertyDescriptor propertyDescriptor = BindingUtils.getPropertyDescriptor(context.bindingContext(), expression);
         PropertyTranslatorKt.translateAccessors(propertyDescriptor, expression, result, context);
         return null;
     }
 
     @Override
-    public Void visitAnonymousInitializer(@NotNull JetClassInitializer expression, TranslationContext context) {
+    public Void visitAnonymousInitializer(@NotNull KtClassInitializer expression, TranslationContext context) {
         // parsed it in initializer visitor => no additional actions are needed
         return null;
     }
 
     @Override
-    public Void visitSecondaryConstructor(@NotNull JetSecondaryConstructor constructor, TranslationContext data) {
+    public Void visitSecondaryConstructor(@NotNull KtSecondaryConstructor constructor, TranslationContext data) {
         return null;
     }
 }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/DelegationTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/DelegationTranslator.kt
index dd848fa209d..593019f02e5 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/DelegationTranslator.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/DelegationTranslator.kt
@@ -32,14 +32,14 @@ import org.jetbrains.kotlin.js.translate.utils.ManglingUtils.getMangledMemberNam
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils.simpleReturnFunction
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils.translateFunctionAsEcma5PropertyDescriptor
 import org.jetbrains.kotlin.js.translate.utils.generateDelegateCall
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetDelegationSpecifier
-import org.jetbrains.kotlin.psi.JetDelegatorByExpressionSpecifier
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtDelegationSpecifier
+import org.jetbrains.kotlin.psi.KtDelegatorByExpressionSpecifier
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import java.util.*
 
 public class DelegationTranslator(
-        private val classDeclaration: JetClassOrObject,
+        private val classDeclaration: KtClassOrObject,
         context: TranslationContext
 ) : AbstractTranslator(context) {
 
@@ -47,10 +47,10 @@ public class DelegationTranslator(
             BindingUtils.getClassDescriptor(context.bindingContext(), classDeclaration);
 
     private val delegationBySpecifiers =
-            classDeclaration.getDelegationSpecifiers().filterIsInstance<JetDelegatorByExpressionSpecifier>();
+            classDeclaration.getDelegationSpecifiers().filterIsInstance<KtDelegatorByExpressionSpecifier>();
 
     private class Field (val name: String, val generateField: Boolean)
-    private val fields = HashMap<JetDelegatorByExpressionSpecifier, Field>()
+    private val fields = HashMap<KtDelegatorByExpressionSpecifier, Field>()
 
     init {
         for (specifier in delegationBySpecifiers) {
@@ -88,7 +88,7 @@ public class DelegationTranslator(
         }
     }
 
-    private fun getSuperClass(specifier: JetDelegationSpecifier): ClassDescriptor =
+    private fun getSuperClass(specifier: KtDelegationSpecifier): ClassDescriptor =
         CodegenUtil.getSuperClassByDelegationSpecifier(specifier, bindingContext())
 
     private fun generateDelegates(toClass: ClassDescriptor, field: Field, properties: MutableList<JsPropertyInitializer>) {
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/FileDeclaration.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/FileDeclaration.kt
index 4d9aa5d1148..ba6a795a945 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/FileDeclaration.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/FileDeclaration.kt
@@ -27,10 +27,10 @@ import org.jetbrains.kotlin.js.translate.initializer.InitializerUtils.generateIn
 import org.jetbrains.kotlin.js.translate.initializer.InitializerVisitor
 import org.jetbrains.kotlin.js.translate.utils.BindingUtils.getPropertyDescriptor
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils
-import org.jetbrains.kotlin.psi.JetClass
-import org.jetbrains.kotlin.psi.JetClassInitializer
-import org.jetbrains.kotlin.psi.JetObjectDeclaration
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassInitializer
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
+import org.jetbrains.kotlin.psi.KtProperty
 
 class FileDeclarationVisitor(
         val context: TranslationContext,
@@ -50,17 +50,17 @@ class FileDeclarationVisitor(
         }
     }
 
-    public override fun visitClass(expression: JetClass, context: TranslationContext?): Void? {
+    public override fun visitClass(expression: KtClass, context: TranslationContext?): Void? {
         result.addAll(ClassTranslator.translate(expression, context!!))
         return null
     }
 
-    public override fun visitObjectDeclaration(declaration: JetObjectDeclaration, context: TranslationContext?): Void? {
+    public override fun visitObjectDeclaration(declaration: KtObjectDeclaration, context: TranslationContext?): Void? {
         InitializerUtils.generateObjectInitializer(declaration, initializerStatements, context!!)
         return null
     }
 
-    public override fun visitProperty(expression: JetProperty, context: TranslationContext?): Void? {
+    public override fun visitProperty(expression: KtProperty, context: TranslationContext?): Void? {
         context!! // hack
 
         super.visitProperty(expression, context)
@@ -78,7 +78,7 @@ class FileDeclarationVisitor(
         return null
     }
 
-    public override fun visitAnonymousInitializer(expression: JetClassInitializer, context: TranslationContext?): Void? {
+    public override fun visitAnonymousInitializer(expression: KtClassInitializer, context: TranslationContext?): Void? {
         expression.accept(initializerVisitor, initializerContext)
         return null
     }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/JsDataClassGenerator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/JsDataClassGenerator.java
index 16b7fda0216..8048e91ab04 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/JsDataClassGenerator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/JsDataClassGenerator.java
@@ -23,8 +23,8 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.js.translate.context.Namer;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils;
-import org.jetbrains.kotlin.psi.JetClassOrObject;
-import org.jetbrains.kotlin.psi.JetParameter;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtParameter;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 
 import java.util.ArrayList;
@@ -34,7 +34,7 @@ class JsDataClassGenerator extends DataClassMethodGenerator {
     private final TranslationContext context;
     private final List<? super JsPropertyInitializer> output;
 
-    JsDataClassGenerator(JetClassOrObject klass, TranslationContext context, List<? super JsPropertyInitializer> output) {
+    JsDataClassGenerator(KtClassOrObject klass, TranslationContext context, List<? super JsPropertyInitializer> output) {
         super(klass, context.bindingContext());
         this.context = context;
         this.output = output;
@@ -48,7 +48,7 @@ class JsDataClassGenerator extends DataClassMethodGenerator {
     }
 
     @Override
-    public void generateCopyFunction(@NotNull FunctionDescriptor function, @NotNull List<JetParameter> constructorParameters) {
+    public void generateCopyFunction(@NotNull FunctionDescriptor function, @NotNull List<KtParameter> constructorParameters) {
         JsFunction functionObj = generateJsMethod(function);
         JsFunctionScope funScope = functionObj.getScope();
 
@@ -56,7 +56,7 @@ class JsDataClassGenerator extends DataClassMethodGenerator {
 
         List<JsExpression> constructorArguments = new ArrayList<JsExpression>(constructorParameters.size());
         for (int i = 0; i < constructorParameters.size(); i++) {
-            JetParameter constructorParam = constructorParameters.get(i);
+            KtParameter constructorParam = constructorParameters.get(i);
             JsName paramName = funScope.declareName(constructorParam.getName());
 
             functionObj.getParameters().add(new JsParameter(paramName));
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/PackageDeclarationTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/PackageDeclarationTranslator.java
index 0a34a223bc1..fbb4d2388e9 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/PackageDeclarationTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/PackageDeclarationTranslator.java
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.js.translate.context.Namer;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
 
@@ -33,15 +33,15 @@ import java.util.*;
 import static com.google.dart.compiler.backend.js.ast.JsVars.JsVar;
 
 public final class PackageDeclarationTranslator extends AbstractTranslator {
-    private final Iterable<JetFile> files;
+    private final Iterable<KtFile> files;
     private final Map<PackageFragmentDescriptor, PackageTranslator> packageFragmentToTranslator =
             new LinkedHashMap<PackageFragmentDescriptor, PackageTranslator>();
 
-    public static List<JsStatement> translateFiles(@NotNull Collection<JetFile> files, @NotNull TranslationContext context) {
+    public static List<JsStatement> translateFiles(@NotNull Collection<KtFile> files, @NotNull TranslationContext context) {
         return new PackageDeclarationTranslator(files, context).translate();
     }
 
-    private PackageDeclarationTranslator(@NotNull Iterable<JetFile> files, @NotNull TranslationContext context) {
+    private PackageDeclarationTranslator(@NotNull Iterable<KtFile> files, @NotNull TranslationContext context) {
         super(context);
 
         this.files = files;
@@ -52,7 +52,7 @@ public final class PackageDeclarationTranslator extends AbstractTranslator {
         // predictable order
         Map<FqName, DefineInvocation> packageFqNameToDefineInvocation = new THashMap<FqName, DefineInvocation>();
 
-        for (JetFile file : files) {
+        for (KtFile file : files) {
             PackageFragmentDescriptor packageFragment =
                     BindingContextUtils.getNotNull(context().bindingContext(), BindingContext.FILE_TO_PACKAGE_FRAGMENT, file);
 
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/PackageTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/PackageTranslator.java
index 66811752736..b9a99adc3d5 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/PackageTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/PackageTranslator.java
@@ -27,8 +27,8 @@ import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils;
 import org.jetbrains.kotlin.js.translate.utils.BindingUtils;
 import org.jetbrains.kotlin.name.FqName;
-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 java.util.List;
 import java.util.Map;
@@ -64,8 +64,8 @@ final class PackageTranslator extends AbstractTranslator {
         this.visitor = visitor;
     }
     
-    public void translate(JetFile file) {
-        for (JetDeclaration declaration : file.getDeclarations()) {
+    public void translate(KtFile file) {
+        for (KtDeclaration declaration : file.getDeclarations()) {
             if (!AnnotationsUtils.isPredefinedObject(BindingUtils.getDescriptorForElement(bindingContext(), declaration))) {
                 declaration.accept(visitor, context());
             }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/PropertyTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/PropertyTranslator.kt
index 161df7bd0d8..63efb91c9ec 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/PropertyTranslator.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/PropertyTranslator.kt
@@ -32,8 +32,8 @@ import org.jetbrains.kotlin.js.translate.utils.TranslationUtils.backingFieldRefe
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils.translateFunctionAsEcma5PropertyDescriptor
 import org.jetbrains.kotlin.js.translate.utils.jsAstUtils.addParameter
 import org.jetbrains.kotlin.js.translate.utils.jsAstUtils.addStatement
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetPropertyAccessor
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtPropertyAccessor
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 
 public fun translateAccessors(
         descriptor: PropertyDescriptor,
-        declaration: JetProperty?,
+        declaration: KtProperty?,
         result: MutableList<JsPropertyInitializer>,
         context: TranslationContext
 ) {
@@ -85,7 +85,7 @@ public fun MutableList<JsPropertyInitializer>.addGetterAndSetter(
 
 private class PropertyTranslator(
         val descriptor: PropertyDescriptor,
-        val declaration: JetProperty?,
+        val declaration: KtProperty?,
         context: TranslationContext
 ) : AbstractTranslator(context) {
 
@@ -105,11 +105,11 @@ private class PropertyTranslator(
 
     private fun hasCustomSetter() = declaration?.getSetter() != null && getCustomSetterDeclaration().hasBody()
 
-    private fun getCustomGetterDeclaration(): JetPropertyAccessor =
+    private fun getCustomGetterDeclaration(): KtPropertyAccessor =
             declaration?.getGetter() ?:
                     throw IllegalStateException("declaration and getter should not be null descriptor=${descriptor} declaration=${declaration}")
 
-    private fun getCustomSetterDeclaration(): JetPropertyAccessor =
+    private fun getCustomSetterDeclaration(): KtPropertyAccessor =
             declaration?.getSetter() ?:
                     throw IllegalStateException("declaration and setter should not be null descriptor=${descriptor} declaration=${declaration}")
 
@@ -207,7 +207,7 @@ private class PropertyTranslator(
     private fun generateDefaultAccessor(accessorDescriptor: PropertyAccessorDescriptor, function: JsFunction): JsPropertyInitializer =
             translateFunctionAsEcma5PropertyDescriptor(function, accessorDescriptor, context())
 
-    private fun translateCustomAccessor(expression: JetPropertyAccessor): JsPropertyInitializer =
+    private fun translateCustomAccessor(expression: KtPropertyAccessor): JsPropertyInitializer =
             Translation.functionTranslator(expression, context()).translateAsEcma5PropertyDescriptor()
 
     private fun accessorDescription(accessorDescriptor: PropertyAccessorDescriptor): String {
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/CatchTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/CatchTranslator.kt
index d50b6f96ce0..599b8a552c2 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/CatchTranslator.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/CatchTranslator.kt
@@ -25,13 +25,13 @@ import org.jetbrains.kotlin.js.translate.general.Translation.patternTranslator
 import org.jetbrains.kotlin.js.translate.general.Translation.translateAsStatementAndMergeInBlockIfNeeded
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils.convertToBlock
-import org.jetbrains.kotlin.psi.JetCatchClause
-import org.jetbrains.kotlin.psi.JetTypeReference
+import org.jetbrains.kotlin.psi.KtCatchClause
+import org.jetbrains.kotlin.psi.KtTypeReference
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingContextUtils.getNotNull
 
 class CatchTranslator(
-        val catches: List<JetCatchClause>,
+        val catches: List<KtCatchClause>,
         context: TranslationContext
 ) : AbstractTranslator(context) {
 
@@ -76,7 +76,7 @@ class CatchTranslator(
                        translateCatches(parameterRef, catches.iterator()))
     }
 
-    private fun translateCatches(parameterRef: JsNameRef, catches: Iterator<JetCatchClause>): JsStatement {
+    private fun translateCatches(parameterRef: JsNameRef, catches: Iterator<KtCatchClause>): JsStatement {
         if (!catches.hasNext()) return JsThrow(parameterRef)
 
         val catch = catches.next()
@@ -98,7 +98,7 @@ class CatchTranslator(
         return JsIf(typeCheck, thenBlock, elseBlock)
     }
 
-    private fun translateCatchBody(context: TranslationContext, catchClause: JetCatchClause): JsBlock {
+    private fun translateCatchBody(context: TranslationContext, catchClause: KtCatchClause): JsBlock {
         val catchBody = catchClause.getCatchBody()
         val jsCatchBody =
                 if (catchBody != null)
@@ -109,7 +109,7 @@ class CatchTranslator(
         return convertToBlock(jsCatchBody)
     }
 
-    private val JetTypeReference.isThrowable: Boolean
+    private val KtTypeReference.isThrowable: Boolean
         get() {
             val jetType = getNotNull(bindingContext(), BindingContext.TYPE, this)
             val jetTypeName = jetType.getJetTypeFqName(false)
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java
index af98b972547..ca656a2eb8e 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.js.translate.operation.UnaryOperationTranslator;
 import org.jetbrains.kotlin.js.translate.reference.*;
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils;
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.NullValue;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.resolve.inline.InlineUtil;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 
 import java.util.List;
@@ -69,15 +69,15 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitConstantExpression(@NotNull JetConstantExpression expression, @NotNull TranslationContext context) {
+    public JsNode visitConstantExpression(@NotNull KtConstantExpression expression, @NotNull TranslationContext context) {
         return translateConstantExpression(expression, context).source(expression);
     }
 
     @NotNull
-    private static JsNode translateConstantExpression(@NotNull JetConstantExpression expression, @NotNull TranslationContext context) {
+    private static JsNode translateConstantExpression(@NotNull KtConstantExpression expression, @NotNull TranslationContext context) {
         CompileTimeConstant<?> compileTimeValue = ConstantExpressionEvaluator.getConstant(expression, context.bindingContext());
         assert compileTimeValue != null : message(expression, "Expression is not compile time value: " + expression.getText() + " ");
-        JetType expectedType = context.bindingContext().getType(expression);
+        KtType expectedType = context.bindingContext().getType(expression);
         ConstantValue<?> constant = compileTimeValue.toConstantValue(expectedType != null ? expectedType : TypeUtils.NO_EXPECTED_TYPE);
         if (constant instanceof NullValue) {
             return JsLiteral.NULL;
@@ -109,10 +109,10 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitBlockExpression(@NotNull JetBlockExpression jetBlock, @NotNull TranslationContext context) {
-        List<JetExpression> statements = jetBlock.getStatements();
+    public JsNode visitBlockExpression(@NotNull KtBlockExpression jetBlock, @NotNull TranslationContext context) {
+        List<KtExpression> statements = jetBlock.getStatements();
         JsBlock jsBlock = new JsBlock();
-        for (JetExpression statement : statements) {
+        for (KtExpression statement : statements) {
             JsNode jsNode = Translation.translateExpression(statement, context, jsBlock);
             JsStatement jsStatement = convertToStatement(jsNode);
             if (!JsAstUtils.isEmptyStatement(jsStatement)) {
@@ -123,8 +123,8 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
     }
 
     @Override
-    public JsNode visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration, @NotNull TranslationContext context) {
-        JetExpression jetInitializer = multiDeclaration.getInitializer();
+    public JsNode visitMultiDeclaration(@NotNull KtMultiDeclaration multiDeclaration, @NotNull TranslationContext context) {
+        KtExpression jetInitializer = multiDeclaration.getInitializer();
         assert jetInitializer != null : "Initializer for multi declaration must be not null";
         JsExpression initializer = Translation.translateAsExpression(jetInitializer, context);
         return MultiDeclarationTranslator.translate(multiDeclaration, context.scope().declareTemporary(), initializer, context);
@@ -132,13 +132,13 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitReturnExpression(@NotNull JetReturnExpression jetReturnExpression,
+    public JsNode visitReturnExpression(@NotNull KtReturnExpression jetReturnExpression,
             @NotNull TranslationContext context) {
-        JetExpression returned = jetReturnExpression.getReturnedExpression();
+        KtExpression returned = jetReturnExpression.getReturnedExpression();
 
         // TODO: add related descriptor to context and use it here
-        JetDeclarationWithBody parent = PsiTreeUtil.getParentOfType(jetReturnExpression, JetDeclarationWithBody.class);
-        if (parent instanceof JetSecondaryConstructor) {
+        KtDeclarationWithBody parent = PsiTreeUtil.getParentOfType(jetReturnExpression, KtDeclarationWithBody.class);
+        if (parent instanceof KtSecondaryConstructor) {
             return new JsReturn(new JsNameRef(Namer.ANOTHER_THIS_PARAMETER_NAME)).source(jetReturnExpression);
         }
         if (returned == null) {
@@ -153,9 +153,9 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression,
+    public JsNode visitParenthesizedExpression(@NotNull KtParenthesizedExpression expression,
             @NotNull TranslationContext context) {
-        JetExpression expressionInside = expression.getExpression();
+        KtExpression expressionInside = expression.getExpression();
         if (expressionInside != null) {
             return Translation.translateExpression(expressionInside, context);
         }
@@ -164,7 +164,7 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitBinaryExpression(@NotNull JetBinaryExpression expression,
+    public JsNode visitBinaryExpression(@NotNull KtBinaryExpression expression,
             @NotNull TranslationContext context) {
         return BinaryOperationTranslator.translate(expression, context);
     }
@@ -172,7 +172,7 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
     @Override
     @NotNull
     // assume it is a local variable declaration
-    public JsNode visitProperty(@NotNull JetProperty expression, @NotNull TranslationContext context) {
+    public JsNode visitProperty(@NotNull KtProperty expression, @NotNull TranslationContext context) {
         VariableDescriptor descriptor = BindingContextUtils.getNotNull(context.bindingContext(), BindingContext.VARIABLE, expression);
         JsExpression initializer = translateInitializerForProperty(expression, context);
         if (initializer != null && JsAstUtils.isEmptyExpression(initializer)) {
@@ -190,14 +190,14 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitCallableReferenceExpression(@NotNull JetCallableReferenceExpression expression, @NotNull TranslationContext context) {
+    public JsNode visitCallableReferenceExpression(@NotNull KtCallableReferenceExpression expression, @NotNull TranslationContext context) {
         return CallableReferenceTranslator.INSTANCE$.translate(expression, context);
     }
 
     @Override
     @NotNull
     public JsNode visitCallExpression(
-            @NotNull JetCallExpression expression,
+            @NotNull KtCallExpression expression,
             @NotNull TranslationContext context
     ) {
         return CallExpressionTranslator.translate(expression, null, context).source(expression);
@@ -205,7 +205,7 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitIfExpression(@NotNull JetIfExpression expression, @NotNull TranslationContext context) {
+    public JsNode visitIfExpression(@NotNull KtIfExpression expression, @NotNull TranslationContext context) {
         assert expression.getCondition() != null : "condition should not ne null: " + expression.getText();
         JsExpression testExpression = Translation.translateAsExpression(expression.getCondition(), context);
         if (JsAstUtils.isEmptyExpression(testExpression)) {
@@ -214,8 +214,8 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
         boolean isKotlinExpression = BindingContextUtilsKt.isUsedAsExpression(expression, context.bindingContext());
 
-        JetExpression thenExpression = expression.getThen();
-        JetExpression elseExpression = expression.getElse();
+        KtExpression thenExpression = expression.getThen();
+        KtExpression elseExpression = expression.getElse();
 
         JsStatement thenStatement =
                 thenExpression != null ? Translation.translateAsStatementAndMergeInBlockIfNeeded(thenExpression, context) : null;
@@ -236,26 +236,26 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsExpression visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression,
+    public JsExpression visitSimpleNameExpression(@NotNull KtSimpleNameExpression expression,
             @NotNull TranslationContext context) {
         return ReferenceTranslator.translateSimpleNameWithQualifier(expression, null, context).source(expression);
     }
 
     @Override
     @NotNull
-    public JsNode visitWhileExpression(@NotNull JetWhileExpression expression, @NotNull TranslationContext context) {
+    public JsNode visitWhileExpression(@NotNull KtWhileExpression expression, @NotNull TranslationContext context) {
         return LoopTranslator.createWhile(false, expression, context);
     }
 
     @Override
     @NotNull
-    public JsNode visitDoWhileExpression(@NotNull JetDoWhileExpression expression, @NotNull TranslationContext context) {
+    public JsNode visitDoWhileExpression(@NotNull KtDoWhileExpression expression, @NotNull TranslationContext context) {
         return LoopTranslator.createWhile(true, expression, context);
     }
 
     @Override
     @NotNull
-    public JsNode visitStringTemplateExpression(@NotNull JetStringTemplateExpression expression,
+    public JsNode visitStringTemplateExpression(@NotNull KtStringTemplateExpression expression,
             @NotNull TranslationContext context) {
         JsStringLiteral stringLiteral = resolveAsStringConstant(expression, context);
         if (stringLiteral != null) {
@@ -265,13 +265,13 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
     }
 
     @NotNull
-    private static JsNode resolveAsTemplate(@NotNull JetStringTemplateExpression expression,
+    private static JsNode resolveAsTemplate(@NotNull KtStringTemplateExpression expression,
             @NotNull TranslationContext context) {
         return StringTemplateTranslator.translate(expression, context);
     }
 
     @Nullable
-    private static JsStringLiteral resolveAsStringConstant(@NotNull JetExpression expression,
+    private static JsStringLiteral resolveAsStringConstant(@NotNull KtExpression expression,
             @NotNull TranslationContext context) {
         Object value = getCompileTimeValue(context.bindingContext(), expression);
         if (value == null) {
@@ -284,16 +284,16 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitDotQualifiedExpression(@NotNull JetDotQualifiedExpression expression,
+    public JsNode visitDotQualifiedExpression(@NotNull KtDotQualifiedExpression expression,
             @NotNull TranslationContext context) {
         return QualifiedExpressionTranslator.translateQualifiedExpression(expression, context);
     }
 
     @Override
     public JsNode visitLabeledExpression(
-            @NotNull JetLabeledExpression expression, TranslationContext context
+            @NotNull KtLabeledExpression expression, TranslationContext context
     ) {
-        JetExpression baseExpression = expression.getBaseExpression();
+        KtExpression baseExpression = expression.getBaseExpression();
         assert baseExpression != null;
 
         if (BindingContextUtilsKt.isUsedAsExpression(expression, context.bindingContext())) {
@@ -316,7 +316,7 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
     @Override
     @NotNull
     public JsNode visitPrefixExpression(
-            @NotNull JetPrefixExpression expression,
+            @NotNull KtPrefixExpression expression,
             @NotNull TranslationContext context
     ) {
         return UnaryOperationTranslator.translate(expression, context).source(expression);
@@ -324,46 +324,46 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitPostfixExpression(@NotNull JetPostfixExpression expression,
+    public JsNode visitPostfixExpression(@NotNull KtPostfixExpression expression,
             @NotNull TranslationContext context) {
         return UnaryOperationTranslator.translate(expression, context).source(expression);
     }
 
     @Override
     @NotNull
-    public JsNode visitIsExpression(@NotNull JetIsExpression expression,
+    public JsNode visitIsExpression(@NotNull KtIsExpression expression,
             @NotNull TranslationContext context) {
         return Translation.patternTranslator(context).translateIsExpression(expression);
     }
 
     @Override
     @NotNull
-    public JsNode visitSafeQualifiedExpression(@NotNull JetSafeQualifiedExpression expression,
+    public JsNode visitSafeQualifiedExpression(@NotNull KtSafeQualifiedExpression expression,
             @NotNull TranslationContext context) {
         return QualifiedExpressionTranslator.translateQualifiedExpression(expression, context).source(expression);
     }
 
     @Override
     @Nullable
-    public JsNode visitWhenExpression(@NotNull JetWhenExpression expression,
+    public JsNode visitWhenExpression(@NotNull KtWhenExpression expression,
             @NotNull TranslationContext context) {
         return WhenTranslator.translate(expression, context);
     }
 
     @Override
     @NotNull
-    public JsNode visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS expression,
+    public JsNode visitBinaryWithTypeRHSExpression(@NotNull KtBinaryExpressionWithTypeRHS expression,
             @NotNull TranslationContext context) {
         JsExpression jsExpression = Translation.translateAsExpression(expression.getLeft(), context);
 
-        if (expression.getOperationReference().getReferencedNameElementType() != JetTokens.AS_KEYWORD)
+        if (expression.getOperationReference().getReferencedNameElementType() != KtTokens.AS_KEYWORD)
             return jsExpression.source(expression);
 
-        JetTypeReference right = expression.getRight();
+        KtTypeReference right = expression.getRight();
         assert right != null;
 
-        JetType rightType = BindingContextUtils.getNotNull(context.bindingContext(), BindingContext.TYPE, right);
-        JetType leftType = BindingContextUtils.getTypeNotNull(context.bindingContext(), expression.getLeft());
+        KtType rightType = BindingContextUtils.getNotNull(context.bindingContext(), BindingContext.TYPE, right);
+        KtType leftType = BindingContextUtils.getTypeNotNull(context.bindingContext(), expression.getLeft());
         if (TypeUtils.isNullableType(rightType) || !TypeUtils.isNullableType(leftType)) {
             return jsExpression.source(expression);
         }
@@ -373,14 +373,14 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
         return TranslationUtils.sure(jsExpression, context).source(expression);
     }
 
-    private static String getReferencedName(JetSimpleNameExpression expression) {
+    private static String getReferencedName(KtSimpleNameExpression expression) {
         return expression.getReferencedName()
                 .replaceAll("^@", "")
                 .replaceAll("(?:^`(.*)`$)", "$1");
     }
 
-    private static JsNameRef getTargetLabel(JetExpressionWithLabel expression, TranslationContext context) {
-        JetSimpleNameExpression labelElement = expression.getTargetLabel();
+    private static JsNameRef getTargetLabel(KtExpressionWithLabel expression, TranslationContext context) {
+        KtSimpleNameExpression labelElement = expression.getTargetLabel();
         if (labelElement == null) {
             return null;
         }
@@ -395,27 +395,27 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitBreakExpression(@NotNull JetBreakExpression expression,
+    public JsNode visitBreakExpression(@NotNull KtBreakExpression expression,
             @NotNull TranslationContext context) {
         return new JsBreak(getTargetLabel(expression, context)).source(expression);
     }
 
     @Override
     @NotNull
-    public JsNode visitContinueExpression(@NotNull JetContinueExpression expression,
+    public JsNode visitContinueExpression(@NotNull KtContinueExpression expression,
             @NotNull TranslationContext context) {
         return new JsContinue(getTargetLabel(expression, context)).source(expression);
     }
 
     @Override
     @NotNull
-    public JsNode visitFunctionLiteralExpression(@NotNull JetFunctionLiteralExpression expression, @NotNull TranslationContext context) {
+    public JsNode visitFunctionLiteralExpression(@NotNull KtFunctionLiteralExpression expression, @NotNull TranslationContext context) {
         return new LiteralFunctionTranslator(context).translate(expression.getFunctionLiteral());
     }
 
     @Override
     @NotNull
-    public JsNode visitNamedFunction(@NotNull JetNamedFunction expression, @NotNull TranslationContext context) {
+    public JsNode visitNamedFunction(@NotNull KtNamedFunction expression, @NotNull TranslationContext context) {
         JsExpression alias = new LiteralFunctionTranslator(context).translate(expression);
 
         FunctionDescriptor descriptor = getFunctionDescriptor(context.bindingContext(), expression);
@@ -432,7 +432,7 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitThisExpression(@NotNull JetThisExpression expression, @NotNull TranslationContext context) {
+    public JsNode visitThisExpression(@NotNull KtThisExpression expression, @NotNull TranslationContext context) {
         DeclarationDescriptor thisExpression =
                 getDescriptorForReferenceExpression(context.bindingContext(), expression.getInstanceReference());
         assert thisExpression != null : "This expression must reference a descriptor: " + expression.getText();
@@ -442,14 +442,14 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitArrayAccessExpression(@NotNull JetArrayAccessExpression expression,
+    public JsNode visitArrayAccessExpression(@NotNull KtArrayAccessExpression expression,
             @NotNull TranslationContext context) {
         return AccessTranslationUtils.translateAsGet(expression, context);
     }
 
     @Override
     @NotNull
-    public JsNode visitSuperExpression(@NotNull JetSuperExpression expression, @NotNull TranslationContext context) {
+    public JsNode visitSuperExpression(@NotNull KtSuperExpression expression, @NotNull TranslationContext context) {
         DeclarationDescriptor superClassDescriptor = context.bindingContext().get(BindingContext.REFERENCE_TARGET, expression.getInstanceReference());
         assert superClassDescriptor != null: message(expression);
         return translateAsFQReference(superClassDescriptor, context);
@@ -457,7 +457,7 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitForExpression(@NotNull JetForExpression expression,
+    public JsNode visitForExpression(@NotNull KtForExpression expression,
             @NotNull TranslationContext context) {
         return LoopTranslator.translateForExpression(expression, context).source(expression);
     }
@@ -465,7 +465,7 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
     @Override
     @NotNull
     public JsNode visitTryExpression(
-            @NotNull JetTryExpression expression,
+            @NotNull KtTryExpression expression,
             @NotNull TranslationContext context
     ) {
         return new TryTranslator(expression, context).translate();
@@ -473,23 +473,23 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
     @Override
     @NotNull
-    public JsNode visitThrowExpression(@NotNull JetThrowExpression expression,
+    public JsNode visitThrowExpression(@NotNull KtThrowExpression expression,
             @NotNull TranslationContext context) {
-        JetExpression thrownExpression = expression.getThrownExpression();
+        KtExpression thrownExpression = expression.getThrownExpression();
         assert thrownExpression != null : "Thrown expression must not be null";
         return new JsThrow(translateAsExpression(thrownExpression, context)).source(expression);
     }
 
     @Override
     @NotNull
-    public JsNode visitObjectLiteralExpression(@NotNull JetObjectLiteralExpression expression,
+    public JsNode visitObjectLiteralExpression(@NotNull KtObjectLiteralExpression expression,
             @NotNull TranslationContext context) {
         return ClassTranslator.generateObjectLiteral(expression.getObjectDeclaration(), context);
     }
 
     @Override
     @NotNull
-    public JsNode visitObjectDeclaration(@NotNull JetObjectDeclaration expression,
+    public JsNode visitObjectDeclaration(@NotNull KtObjectDeclaration expression,
             @NotNull TranslationContext context) {
         DeclarationDescriptor descriptor = getDescriptorForElement(context.bindingContext(), expression);
         JsName name = context.getNameForDescriptor(descriptor);
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/FunctionTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/FunctionTranslator.java
index 8c08fc56285..08b9b998919 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/FunctionTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/FunctionTranslator.java
@@ -27,8 +27,8 @@ import org.jetbrains.kotlin.js.translate.context.Namer;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils;
-import org.jetbrains.kotlin.psi.JetDeclarationWithBody;
-import org.jetbrains.kotlin.psi.JetFunctionLiteralExpression;
+import org.jetbrains.kotlin.psi.KtDeclarationWithBody;
+import org.jetbrains.kotlin.psi.KtFunctionLiteralExpression;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 
@@ -44,7 +44,7 @@ import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.setParameters;
 
 public final class FunctionTranslator extends AbstractTranslator {
     @NotNull
-    public static FunctionTranslator newInstance(@NotNull JetDeclarationWithBody function,
+    public static FunctionTranslator newInstance(@NotNull KtDeclarationWithBody function,
             @NotNull TranslationContext context) {
         return new FunctionTranslator(function, context);
     }
@@ -52,7 +52,7 @@ public final class FunctionTranslator extends AbstractTranslator {
     @NotNull
     private TranslationContext functionBodyContext;
     @NotNull
-    private final JetDeclarationWithBody functionDeclaration;
+    private final KtDeclarationWithBody functionDeclaration;
     @Nullable
     private JsName extensionFunctionReceiverName;
     @NotNull
@@ -60,7 +60,7 @@ public final class FunctionTranslator extends AbstractTranslator {
     @NotNull
     private final FunctionDescriptor descriptor;
 
-    private FunctionTranslator(@NotNull JetDeclarationWithBody functionDeclaration, @NotNull TranslationContext context) {
+    private FunctionTranslator(@NotNull KtDeclarationWithBody functionDeclaration, @NotNull TranslationContext context) {
         super(context);
         this.descriptor = getFunctionDescriptor(context.bindingContext(), functionDeclaration);
         this.functionDeclaration = functionDeclaration;
@@ -160,6 +160,6 @@ public final class FunctionTranslator extends AbstractTranslator {
     }
 
     private boolean isExtensionFunction() {
-        return DescriptorUtils.isExtension(descriptor) && !(functionDeclaration instanceof JetFunctionLiteralExpression);
+        return DescriptorUtils.isExtension(descriptor) && !(functionDeclaration instanceof KtFunctionLiteralExpression);
     }
 }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/LiteralFunctionTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/LiteralFunctionTranslator.kt
index e96108d625c..b6bbe097bf8 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/LiteralFunctionTranslator.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/LiteralFunctionTranslator.kt
@@ -30,11 +30,11 @@ import org.jetbrains.kotlin.js.translate.utils.BindingUtils.getFunctionDescripto
 import org.jetbrains.kotlin.js.translate.utils.FunctionBodyTranslator.translateFunctionBody
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils.simpleReturnFunction
-import org.jetbrains.kotlin.psi.JetDeclarationWithBody
+import org.jetbrains.kotlin.psi.KtDeclarationWithBody
 import org.jetbrains.kotlin.resolve.inline.InlineUtil
 
 class LiteralFunctionTranslator(context: TranslationContext) : AbstractTranslator(context) {
-    fun translate(declaration: JetDeclarationWithBody): JsExpression {
+    fun translate(declaration: KtDeclarationWithBody): JsExpression {
         val invokingContext = context()
         val descriptor = getFunctionDescriptor(invokingContext.bindingContext(), declaration)
 
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/LoopTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/LoopTranslator.kt
index f8d868941ad..0dad7e92508 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/LoopTranslator.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/LoopTranslator.kt
@@ -35,15 +35,15 @@ import org.jetbrains.kotlin.js.translate.utils.PsiUtils.getLoopParameter
 import org.jetbrains.kotlin.js.translate.utils.PsiUtils.getLoopRange
 import org.jetbrains.kotlin.js.translate.utils.TemporariesUtils.temporariesInitialization
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.psi.JetForExpression
-import org.jetbrains.kotlin.psi.JetMultiDeclaration
-import org.jetbrains.kotlin.psi.JetWhileExpressionBase
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtMultiDeclaration
+import org.jetbrains.kotlin.psi.KtWhileExpressionBase
 import org.jetbrains.kotlin.resolve.DescriptorUtils.getClassDescriptorForType
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 
-public fun createWhile(doWhile: Boolean, expression: JetWhileExpressionBase, context: TranslationContext): JsNode {
+public fun createWhile(doWhile: Boolean, expression: KtWhileExpressionBase, context: TranslationContext): JsNode {
     val conditionExpression = expression.getCondition() ?:
                               throw IllegalArgumentException("condition expression should not be null: ${expression.getText()}")
     val conditionBlock = JsBlock()
@@ -95,7 +95,7 @@ public fun createWhile(doWhile: Boolean, expression: JetWhileExpressionBase, con
     return result.source(expression)!!
 }
 
-public fun translateForExpression(expression: JetForExpression, context: TranslationContext): JsStatement {
+public fun translateForExpression(expression: KtForExpression, context: TranslationContext): JsStatement {
     val loopRange = getLoopRange(expression)
     val rangeType = getTypeForExpression(context.bindingContext(), loopRange)
 
@@ -106,7 +106,7 @@ public fun translateForExpression(expression: JetForExpression, context: Transla
     }
 
     fun isForOverRangeLiteral(): Boolean =
-            loopRange is JetBinaryExpression && loopRange.getOperationToken() == JetTokens.RANGE && isForOverRange()
+            loopRange is KtBinaryExpression && loopRange.getOperationToken() == KtTokens.RANGE && isForOverRange()
 
    fun isForOverArray(): Boolean {
         //TODO: better check
@@ -115,7 +115,7 @@ public fun translateForExpression(expression: JetForExpression, context: Transla
                getClassDescriptorForType(rangeType).getName().asString() == "IntArray"
     }
 
-    val multiParameter: JetMultiDeclaration? = expression.getMultiParameter();
+    val multiParameter: KtMultiDeclaration? = expression.getMultiParameter();
 
     fun declareParameter(): JsName {
         val loopParameter = getLoopParameter(expression)
@@ -150,7 +150,7 @@ public fun translateForExpression(expression: JetForExpression, context: Transla
 
     // TODO: implement reverse semantics
     fun translateForOverLiteralRange(): JsStatement {
-        if (loopRange !is JetBinaryExpression) throw IllegalStateException("expected JetBinaryExpression, but ${loopRange.getText()}")
+        if (loopRange !is KtBinaryExpression) throw IllegalStateException("expected JetBinaryExpression, but ${loopRange.getText()}")
 
         val startBlock = JsBlock()
         val leftExpression = TranslationUtils.translateLeftExpression(context, loopRange, startBlock)
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/MultiDeclarationTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/MultiDeclarationTranslator.java
index e62dc018c13..3813f41ee8b 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/MultiDeclarationTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/MultiDeclarationTranslator.java
@@ -23,14 +23,13 @@ import com.google.dart.compiler.backend.js.ast.JsVars;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
-import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.VariableDescriptor;
 import org.jetbrains.kotlin.js.translate.callTranslator.CallTranslator;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
 import org.jetbrains.kotlin.js.translate.reference.CallExpressionTranslator;
-import org.jetbrains.kotlin.psi.JetMultiDeclaration;
-import org.jetbrains.kotlin.psi.JetMultiDeclarationEntry;
+import org.jetbrains.kotlin.psi.KtMultiDeclaration;
+import org.jetbrains.kotlin.psi.KtMultiDeclarationEntry;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
@@ -45,7 +44,7 @@ public class MultiDeclarationTranslator extends AbstractTranslator {
     // if multiObjectName was init, initializer must be null
     @NotNull
     public static JsVars translate(
-            @NotNull JetMultiDeclaration multiDeclaration,
+            @NotNull KtMultiDeclaration multiDeclaration,
             @NotNull JsName multiObjectName,
             @Nullable JsExpression initializer,
             @NotNull TranslationContext context
@@ -54,14 +53,14 @@ public class MultiDeclarationTranslator extends AbstractTranslator {
     }
 
     @NotNull
-    private final JetMultiDeclaration multiDeclaration;
+    private final KtMultiDeclaration multiDeclaration;
     @NotNull
     private final JsName multiObjectName;
     @Nullable
     private final JsExpression initializer;
 
     private MultiDeclarationTranslator(
-            @NotNull JetMultiDeclaration multiDeclaration,
+            @NotNull KtMultiDeclaration multiDeclaration,
             @NotNull JsName multiObjectName,
             @Nullable JsExpression initializer,
             @NotNull TranslationContext context
@@ -79,7 +78,7 @@ public class MultiDeclarationTranslator extends AbstractTranslator {
         }
 
         JsNameRef multiObjNameRef = multiObjectName.makeRef();
-        for (JetMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
+        for (KtMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
             ResolvedCall<FunctionDescriptor> entryInitCall =  context().bindingContext().get(BindingContext.COMPONENT_RESOLVED_CALL, entry);
             assert entryInitCall != null : "Entry init call must be not null";
             JsExpression entryInitializer = CallTranslator.translate(context(), entryInitCall, multiObjNameRef);
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/PatternTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/PatternTranslator.java
index f44af6ddf0b..f5421b04d75 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/PatternTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/PatternTranslator.java
@@ -29,11 +29,11 @@ import org.jetbrains.kotlin.js.patterns.NamePredicate;
 import org.jetbrains.kotlin.js.translate.utils.BindingUtils;
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetIsExpression;
-import org.jetbrains.kotlin.psi.JetTypeReference;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtIsExpression;
+import org.jetbrains.kotlin.psi.KtTypeReference;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import static org.jetbrains.kotlin.js.translate.utils.BindingUtils.getTypeByReference;
 import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.*;
@@ -50,9 +50,9 @@ public final class PatternTranslator extends AbstractTranslator {
     }
 
     @NotNull
-    public JsExpression translateIsExpression(@NotNull JetIsExpression expression) {
+    public JsExpression translateIsExpression(@NotNull KtIsExpression expression) {
         JsExpression left = Translation.translateAsExpression(expression.getLeftHandSide(), context());
-        JetTypeReference typeReference = expression.getTypeReference();
+        KtTypeReference typeReference = expression.getTypeReference();
         assert typeReference != null;
         JsExpression result = translateIsCheck(left, typeReference);
         if (expression.isNegated()) {
@@ -62,8 +62,8 @@ public final class PatternTranslator extends AbstractTranslator {
     }
 
     @NotNull
-    public JsExpression translateIsCheck(@NotNull JsExpression subject, @NotNull JetTypeReference typeReference) {
-        JetType type = BindingUtils.getTypeByReference(bindingContext(), typeReference);
+    public JsExpression translateIsCheck(@NotNull JsExpression subject, @NotNull KtTypeReference typeReference) {
+        KtType type = BindingUtils.getTypeByReference(bindingContext(), typeReference);
         JsExpression checkFunReference = getIsTypeCheckCallable(type);
         JsInvocation isCheck = new JsInvocation(checkFunReference, subject);
 
@@ -75,7 +75,7 @@ public final class PatternTranslator extends AbstractTranslator {
     }
 
     @NotNull
-    public JsExpression getIsTypeCheckCallable(@NotNull JetType type) {
+    public JsExpression getIsTypeCheckCallable(@NotNull KtType type) {
         JsExpression builtinCheck = getIsTypeCheckCallableForBuiltin(type);
         if (builtinCheck != null) return builtinCheck;
 
@@ -94,7 +94,7 @@ public final class PatternTranslator extends AbstractTranslator {
     }
 
     @Nullable
-    private JsExpression getIsTypeCheckCallableForBuiltin(@NotNull JetType type) {
+    private JsExpression getIsTypeCheckCallableForBuiltin(@NotNull KtType type) {
         Name typeName = DescriptorUtilsKt.getNameIfStandardType(type);
 
         if (NamePredicate.STRING.apply(typeName)) {
@@ -142,24 +142,24 @@ public final class PatternTranslator extends AbstractTranslator {
         return or(TranslationUtils.isNullCheck(expressionToMatch), isCheck);
     }
 
-    private boolean isNullable(JetTypeReference typeReference) {
+    private boolean isNullable(KtTypeReference typeReference) {
         return getTypeByReference(bindingContext(), typeReference).isMarkedNullable();
     }
 
     @NotNull
-    private JsNameRef getClassNameReference(@NotNull JetType type) {
+    private JsNameRef getClassNameReference(@NotNull KtType type) {
         ClassDescriptor referencedClass = DescriptorUtils.getClassDescriptorForType(type);
         return context().getQualifiedReference(referencedClass);
     }
 
     @NotNull
-    public JsExpression translateExpressionPattern(@NotNull JsExpression expressionToMatch, @NotNull JetExpression patternExpression) {
+    public JsExpression translateExpressionPattern(@NotNull JsExpression expressionToMatch, @NotNull KtExpression patternExpression) {
         JsExpression expressionToMatchAgainst = translateExpressionForExpressionPattern(patternExpression);
         return equality(expressionToMatch, expressionToMatchAgainst);
     }
 
     @NotNull
-    public JsExpression translateExpressionForExpressionPattern(@NotNull JetExpression patternExpression) {
+    public JsExpression translateExpressionForExpressionPattern(@NotNull KtExpression patternExpression) {
         return Translation.translateAsExpression(patternExpression, context());
     }
 }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/StringTemplateTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/StringTemplateTranslator.java
index 036691f01e9..62a8dfda2f9 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/StringTemplateTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/StringTemplateTranslator.java
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.js.translate.general.Translation;
 import org.jetbrains.kotlin.js.translate.intrinsic.functions.factories.TopLevelFIF;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collections;
 
@@ -38,15 +38,15 @@ import static org.jetbrains.kotlin.js.translate.utils.ErrorReportingUtils.messag
 import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.sum;
 
 public final class StringTemplateTranslator extends AbstractTranslator {
-    private final JetStringTemplateEntry[] expressionEntries;
+    private final KtStringTemplateEntry[] expressionEntries;
 
     @NotNull
-    public static JsExpression translate(@NotNull JetStringTemplateExpression expression,
+    public static JsExpression translate(@NotNull KtStringTemplateExpression expression,
                                          @NotNull TranslationContext context) {
         return (new StringTemplateTranslator(expression, context).translate());
     }
 
-    private StringTemplateTranslator(@NotNull JetStringTemplateExpression expression,
+    private StringTemplateTranslator(@NotNull KtStringTemplateExpression expression,
                                      @NotNull TranslationContext context) {
         super(context);
 
@@ -57,13 +57,13 @@ public final class StringTemplateTranslator extends AbstractTranslator {
     @NotNull
     private JsExpression translate() {
         EntryVisitor entryVisitor = new EntryVisitor();
-        for (JetStringTemplateEntry entry : expressionEntries) {
+        for (KtStringTemplateEntry entry : expressionEntries) {
             entry.accept(entryVisitor);
         }
         return entryVisitor.getResultingExpression();
     }
 
-    private final class EntryVisitor extends JetVisitorVoid {
+    private final class EntryVisitor extends KtVisitorVoid {
 
         @Nullable
         private JsExpression resultingExpression = null;
@@ -78,8 +78,8 @@ public final class StringTemplateTranslator extends AbstractTranslator {
         }
 
         @Override
-        public void visitStringTemplateEntryWithExpression(@NotNull JetStringTemplateEntryWithExpression entry) {
-            JetExpression entryExpression = entry.getExpression();
+        public void visitStringTemplateEntryWithExpression(@NotNull KtStringTemplateEntryWithExpression entry) {
+            KtExpression entryExpression = entry.getExpression();
             assert entryExpression != null :
                     "JetStringTemplateEntryWithExpression must have not null entry expression.";
             JsExpression translatedExpression = Translation.translateAsExpression(entryExpression, context());
@@ -88,7 +88,7 @@ public final class StringTemplateTranslator extends AbstractTranslator {
                 return;
             }
 
-            JetType type = context().bindingContext().getType(entryExpression);
+            KtType type = context().bindingContext().getType(entryExpression);
             if (type == null || type.isMarkedNullable()) {
                 append(TopLevelFIF.TO_STRING.apply((JsExpression) null, Collections.singletonList(translatedExpression), context()));
             }
@@ -100,7 +100,7 @@ public final class StringTemplateTranslator extends AbstractTranslator {
             }
         }
 
-        private boolean mustCallToString(@NotNull JetType type) {
+        private boolean mustCallToString(@NotNull KtType type) {
             Name typeName = DescriptorUtilsKt.getNameIfStandardType(type);
             if (typeName != null) {
                 //TODO: this is a hacky optimization, should use some generic approach
@@ -115,12 +115,12 @@ public final class StringTemplateTranslator extends AbstractTranslator {
         }
 
         @Override
-        public void visitLiteralStringTemplateEntry(@NotNull JetLiteralStringTemplateEntry entry) {
+        public void visitLiteralStringTemplateEntry(@NotNull KtLiteralStringTemplateEntry entry) {
             appendText(entry.getText());
         }
 
         @Override
-        public void visitEscapeStringTemplateEntry(@NotNull JetEscapeStringTemplateEntry entry) {
+        public void visitEscapeStringTemplateEntry(@NotNull KtEscapeStringTemplateEntry entry) {
             appendText(entry.getUnescapedValue());
         }
 
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/TryTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/TryTranslator.kt
index 925953b1a1a..d8ecca0dc4e 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/TryTranslator.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/TryTranslator.kt
@@ -17,15 +17,15 @@
 package org.jetbrains.kotlin.js.translate.expression
 
 import com.google.dart.compiler.backend.js.ast.*
-import org.jetbrains.kotlin.psi.JetTryExpression
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtTryExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.js.translate.context.TranslationContext
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator
 import org.jetbrains.kotlin.js.translate.general.Translation.translateAsStatementAndMergeInBlockIfNeeded
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils.convertToBlock
 
 public class TryTranslator(
-        val expression: JetTryExpression,
+        val expression: KtTryExpression,
         context: TranslationContext
 ) : AbstractTranslator(context) {
     public fun translate(): JsTry {
@@ -40,7 +40,7 @@ public class TryTranslator(
         return JsTry(tryBlock, catchBlock, finallyBlock)
     }
 
-    private fun translateAsBlock(expression: JetExpression?): JsBlock? {
+    private fun translateAsBlock(expression: KtExpression?): JsBlock? {
         if (expression == null) return null
 
         val statement = translateAsStatementAndMergeInBlockIfNeeded(expression, context())
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/WhenTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/WhenTranslator.java
index e1b3bc45db9..410a749670f 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/WhenTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/WhenTranslator.java
@@ -31,22 +31,22 @@ import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.negated;
 
 public final class WhenTranslator extends AbstractTranslator {
     @Nullable
-    public static JsNode translate(@NotNull JetWhenExpression expression, @NotNull TranslationContext context) {
+    public static JsNode translate(@NotNull KtWhenExpression expression, @NotNull TranslationContext context) {
         return new WhenTranslator(expression, context).translate();
     }
 
     @NotNull
-    private final JetWhenExpression whenExpression;
+    private final KtWhenExpression whenExpression;
 
     @Nullable
     private final JsExpression expressionToMatch;
 
-    private WhenTranslator(@NotNull JetWhenExpression expression, @NotNull TranslationContext context) {
+    private WhenTranslator(@NotNull KtWhenExpression expression, @NotNull TranslationContext context) {
         super(context);
 
         whenExpression = expression;
 
-        JetExpression subject = expression.getSubjectExpression();
+        KtExpression subject = expression.getSubjectExpression();
         if (subject != null) {
             JsExpression subjectExpression = Translation.translateAsExpression(subject, context);
             if (TranslationUtils.isCacheNeeded(subjectExpression)) {
@@ -68,7 +68,7 @@ public final class WhenTranslator extends AbstractTranslator {
 
         JsIf currentIf = null;
         JsIf resultIf = null;
-        for (JetWhenEntry entry : whenExpression.getEntries()) {
+        for (KtWhenEntry entry : whenExpression.getEntries()) {
             JsBlock statementBlock = new JsBlock();
             JsStatement statement = translateEntryExpression(entry, context(), statementBlock);
 
@@ -99,17 +99,17 @@ public final class WhenTranslator extends AbstractTranslator {
 
     @NotNull
     private static JsStatement translateEntryExpression(
-            @NotNull JetWhenEntry entry,
+            @NotNull KtWhenEntry entry,
             @NotNull TranslationContext context,
             @NotNull JsBlock block) {
-        JetExpression expressionToExecute = entry.getExpression();
+        KtExpression expressionToExecute = entry.getExpression();
         assert expressionToExecute != null : "WhenEntry should have whenExpression to execute.";
         return Translation.translateAsStatement(expressionToExecute, context, block);
     }
 
     @NotNull
-    private JsExpression translateConditions(@NotNull JetWhenEntry entry, @NotNull TranslationContext context) {
-        JetWhenCondition[] conditions = entry.getConditions();
+    private JsExpression translateConditions(@NotNull KtWhenEntry entry, @NotNull TranslationContext context) {
+        KtWhenCondition[] conditions = entry.getConditions();
 
         assert conditions.length > 0 : "When entry (not else) should have at least one condition";
 
@@ -126,7 +126,7 @@ public final class WhenTranslator extends AbstractTranslator {
     }
 
     @NotNull
-    private JsExpression translateOrCondition(@NotNull JsExpression leftExpression, @NotNull JetWhenCondition condition, @NotNull TranslationContext context) {
+    private JsExpression translateOrCondition(@NotNull JsExpression leftExpression, @NotNull KtWhenCondition condition, @NotNull TranslationContext context) {
         TranslationContext rightContext = context.innerBlock();
         JsExpression rightExpression = translateCondition(condition, rightContext);
         context.moveVarsFrom(rightContext);
@@ -143,15 +143,15 @@ public final class WhenTranslator extends AbstractTranslator {
     }
 
     @NotNull
-    private JsExpression translateCondition(@NotNull JetWhenCondition condition, @NotNull TranslationContext context) {
-        if ((condition instanceof JetWhenConditionIsPattern) || (condition instanceof JetWhenConditionWithExpression)) {
+    private JsExpression translateCondition(@NotNull KtWhenCondition condition, @NotNull TranslationContext context) {
+        if ((condition instanceof KtWhenConditionIsPattern) || (condition instanceof KtWhenConditionWithExpression)) {
             return translatePatternCondition(condition, context);
         }
         throw new AssertionError("Unsupported when condition " + condition.getClass());
     }
 
     @NotNull
-    private JsExpression translatePatternCondition(@NotNull JetWhenCondition condition, @NotNull TranslationContext context) {
+    private JsExpression translatePatternCondition(@NotNull KtWhenCondition condition, @NotNull TranslationContext context) {
         JsExpression patternMatchExpression = translateWhenConditionToBooleanExpression(condition, context);
         if (isNegated(condition)) {
             return negated(patternMatchExpression);
@@ -160,30 +160,30 @@ public final class WhenTranslator extends AbstractTranslator {
     }
 
     @NotNull
-    private JsExpression translateWhenConditionToBooleanExpression(@NotNull JetWhenCondition condition, @NotNull TranslationContext context) {
-        if (condition instanceof JetWhenConditionIsPattern) {
-            return translateIsCondition((JetWhenConditionIsPattern) condition, context);
+    private JsExpression translateWhenConditionToBooleanExpression(@NotNull KtWhenCondition condition, @NotNull TranslationContext context) {
+        if (condition instanceof KtWhenConditionIsPattern) {
+            return translateIsCondition((KtWhenConditionIsPattern) condition, context);
         }
-        else if (condition instanceof JetWhenConditionWithExpression) {
-            return translateExpressionCondition((JetWhenConditionWithExpression) condition, context);
+        else if (condition instanceof KtWhenConditionWithExpression) {
+            return translateExpressionCondition((KtWhenConditionWithExpression) condition, context);
         }
         throw new AssertionError("Wrong type of JetWhenCondition");
     }
 
     @NotNull
-    private JsExpression translateIsCondition(@NotNull JetWhenConditionIsPattern conditionIsPattern, @NotNull TranslationContext context) {
+    private JsExpression translateIsCondition(@NotNull KtWhenConditionIsPattern conditionIsPattern, @NotNull TranslationContext context) {
         JsExpression expressionToMatch = getExpressionToMatch();
         assert expressionToMatch != null : "An is-check is not allowed in when() without subject.";
 
-        JetTypeReference typeReference = conditionIsPattern.getTypeReference();
+        KtTypeReference typeReference = conditionIsPattern.getTypeReference();
         assert typeReference != null : "An is-check must have a type reference.";
 
         return Translation.patternTranslator(context).translateIsCheck(expressionToMatch, typeReference);
     }
 
     @NotNull
-    private JsExpression translateExpressionCondition(@NotNull JetWhenConditionWithExpression condition, @NotNull TranslationContext context) {
-        JetExpression patternExpression = condition.getExpression();
+    private JsExpression translateExpressionCondition(@NotNull KtWhenConditionWithExpression condition, @NotNull TranslationContext context) {
+        KtExpression patternExpression = condition.getExpression();
         assert patternExpression != null : "Expression pattern should have an expression.";
 
         JsExpression expressionToMatch = getExpressionToMatch();
@@ -200,9 +200,9 @@ public final class WhenTranslator extends AbstractTranslator {
         return expressionToMatch;
     }
 
-    private static boolean isNegated(@NotNull JetWhenCondition condition) {
-        if (condition instanceof JetWhenConditionIsPattern) {
-            return ((JetWhenConditionIsPattern)condition).isNegated();
+    private static boolean isNegated(@NotNull KtWhenCondition condition) {
+        if (condition instanceof KtWhenConditionIsPattern) {
+            return ((KtWhenConditionIsPattern)condition).isNegated();
         }
         return false;
     }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/JetTestFunctionDetector.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/JetTestFunctionDetector.java
index 43e4001b7f4..a4f7d3627de 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/JetTestFunctionDetector.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/JetTestFunctionDetector.java
@@ -27,12 +27,12 @@ import org.jetbrains.kotlin.descriptors.Modality;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.js.translate.utils.BindingUtils;
-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.scopes.JetScope;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.Collection;
 import java.util.List;
@@ -48,7 +48,7 @@ public class JetTestFunctionDetector {
         Annotations annotations = functionDescriptor.getAnnotations();
         for (AnnotationDescriptor annotation : annotations) {
             // TODO ideally we should find the fully qualified name here...
-            JetType type = annotation.getType();
+            KtType type = annotation.getType();
             String name = type.toString();
             if (name.equals("Test")) {
                 return true;
@@ -67,10 +67,10 @@ public class JetTestFunctionDetector {
     @NotNull
     public static List<FunctionDescriptor> getTestFunctionDescriptors(
             @NotNull BindingContext bindingContext,
-            @NotNull Collection<JetFile> files
+            @NotNull Collection<KtFile> files
     ) {
         List<FunctionDescriptor> answer = Lists.newArrayList();
-        for (JetFile file : files) {
+        for (KtFile file : files) {
             answer.addAll(getTestFunctions(bindingContext, file.getDeclarations()));
         }
         return answer;
@@ -79,14 +79,14 @@ public class JetTestFunctionDetector {
     @NotNull
     private static List<FunctionDescriptor> getTestFunctions(
             @NotNull BindingContext bindingContext,
-            @NotNull List<JetDeclaration> declarations
+            @NotNull List<KtDeclaration> declarations
     ) {
         List<FunctionDescriptor> answer = Lists.newArrayList();
-        for (JetDeclaration declaration : declarations) {
-            JetScope scope = null;
+        for (KtDeclaration declaration : declarations) {
+            KtScope scope = null;
 
-            if (declaration instanceof JetClass) {
-                JetClass klass = (JetClass) declaration;
+            if (declaration instanceof KtClass) {
+                KtClass klass = (KtClass) declaration;
                 ClassDescriptor classDescriptor = BindingUtils.getClassDescriptor(bindingContext, klass);
 
                 if (classDescriptor.getModality() != Modality.ABSTRACT) {
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/Translation.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/Translation.java
index 08190319468..602d94d4d54 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/Translation.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/Translation.java
@@ -43,10 +43,10 @@ import org.jetbrains.kotlin.js.translate.test.JSTester;
 import org.jetbrains.kotlin.js.translate.test.QUnitTester;
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils;
 import org.jetbrains.kotlin.js.translate.utils.mutator.AssignToExpressionMutator;
-import org.jetbrains.kotlin.psi.JetDeclarationWithBody;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
+import org.jetbrains.kotlin.psi.KtDeclarationWithBody;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilsKt;
 
@@ -69,7 +69,7 @@ public final class Translation {
     }
 
     @NotNull
-    public static FunctionTranslator functionTranslator(@NotNull JetDeclarationWithBody function,
+    public static FunctionTranslator functionTranslator(@NotNull KtDeclarationWithBody function,
             @NotNull TranslationContext context) {
         return FunctionTranslator.newInstance(function, context);
     }
@@ -80,12 +80,12 @@ public final class Translation {
     }
 
     @NotNull
-    public static JsNode translateExpression(@NotNull JetExpression expression, @NotNull TranslationContext context) {
+    public static JsNode translateExpression(@NotNull KtExpression expression, @NotNull TranslationContext context) {
         return translateExpression(expression, context, context.dynamicContext().jsBlock());
     }
 
     @NotNull
-    public static JsNode translateExpression(@NotNull JetExpression expression, @NotNull TranslationContext context, @NotNull JsBlock block) {
+    public static JsNode translateExpression(@NotNull KtExpression expression, @NotNull TranslationContext context, @NotNull JsBlock block) {
         JsExpression aliasForExpression = context.aliasingContext().getAliasForExpression(expression);
         if (aliasForExpression != null) {
             return aliasForExpression;
@@ -105,18 +105,18 @@ public final class Translation {
 
     //NOTE: use with care
     @NotNull
-    public static JsNode doTranslateExpression(JetExpression expression, TranslationContext context) {
+    public static JsNode doTranslateExpression(KtExpression expression, TranslationContext context) {
         return expression.accept(new ExpressionVisitor(), context);
     }
 
     @NotNull
-    public static JsExpression translateAsExpression(@NotNull JetExpression expression, @NotNull TranslationContext context) {
+    public static JsExpression translateAsExpression(@NotNull KtExpression expression, @NotNull TranslationContext context) {
         return translateAsExpression(expression, context, context.dynamicContext().jsBlock());
     }
 
     @NotNull
     public static JsExpression translateAsExpression(
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             @NotNull TranslationContext context,
             @NotNull JsBlock block
     ) {
@@ -138,13 +138,13 @@ public final class Translation {
     }
 
     @NotNull
-    public static JsStatement translateAsStatement(@NotNull JetExpression expression, @NotNull TranslationContext context) {
+    public static JsStatement translateAsStatement(@NotNull KtExpression expression, @NotNull TranslationContext context) {
         return translateAsStatement(expression, context, context.dynamicContext().jsBlock());
     }
 
     @NotNull
     public static JsStatement translateAsStatement(
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             @NotNull TranslationContext context,
             @NotNull JsBlock block) {
         return convertToStatement(translateExpression(expression, context, block));
@@ -152,7 +152,7 @@ public final class Translation {
 
     @NotNull
     public static JsStatement translateAsStatementAndMergeInBlockIfNeeded(
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             @NotNull TranslationContext context
     ) {
         JsBlock block = new JsBlock();
@@ -162,7 +162,7 @@ public final class Translation {
 
     @NotNull
     public static TranslationContext generateAst(@NotNull BindingTrace bindingTrace,
-            @NotNull Collection<JetFile> files, @NotNull MainCallParameters mainCallParameters,
+            @NotNull Collection<KtFile> files, @NotNull MainCallParameters mainCallParameters,
             @NotNull ModuleDescriptor moduleDescriptor,
             @NotNull Config config)
             throws TranslationException {
@@ -178,7 +178,7 @@ public final class Translation {
     }
 
     @NotNull
-    private static TranslationContext doGenerateAst(@NotNull BindingTrace bindingTrace, @NotNull Collection<JetFile> files,
+    private static TranslationContext doGenerateAst(@NotNull BindingTrace bindingTrace, @NotNull Collection<KtFile> files,
             @NotNull MainCallParameters mainCallParameters,
             @NotNull ModuleDescriptor moduleDescriptor,
             @NotNull Config config) throws MainFunctionNotFoundException {
@@ -213,7 +213,7 @@ public final class Translation {
         }
     }
 
-    private static void mayBeGenerateTests(@NotNull Collection<JetFile> files, @NotNull Config config,
+    private static void mayBeGenerateTests(@NotNull Collection<KtFile> files, @NotNull Config config,
             @NotNull JsBlock rootBlock, @NotNull TranslationContext context) {
         JSTester tester = config.isTestConfig() ? new JSRhinoUnitTester() : new QUnitTester();
         tester.initialize(context, rootBlock);
@@ -223,10 +223,10 @@ public final class Translation {
 
     //TODO: determine whether should throw exception
     @Nullable
-    private static JsStatement generateCallToMain(@NotNull TranslationContext context, @NotNull Collection<JetFile> files,
+    private static JsStatement generateCallToMain(@NotNull TranslationContext context, @NotNull Collection<KtFile> files,
             @NotNull List<String> arguments) throws MainFunctionNotFoundException {
         MainFunctionDetector mainFunctionDetector = new MainFunctionDetector(context.bindingContext());
-        JetNamedFunction mainFunction = mainFunctionDetector.getMainFunction(files);
+        KtNamedFunction mainFunction = mainFunctionDetector.getMainFunction(files);
         if (mainFunction == null) {
             return null;
         }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/TranslatorVisitor.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/TranslatorVisitor.java
index f39ab04f301..cc32e0200f9 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/TranslatorVisitor.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/general/TranslatorVisitor.java
@@ -19,27 +19,27 @@ package org.jetbrains.kotlin.js.translate.general;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.js.resolve.diagnostics.ErrorsJs;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
-import org.jetbrains.kotlin.psi.JetDeclaration;
-import org.jetbrains.kotlin.psi.JetDeclarationContainer;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetVisitor;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtDeclarationContainer;
+import org.jetbrains.kotlin.psi.KtElement;
+import org.jetbrains.kotlin.psi.KtVisitor;
 
 /**
  * This class is a base class for all visitors.
  */
-public abstract class TranslatorVisitor<T> extends JetVisitor<T, TranslationContext> {
+public abstract class TranslatorVisitor<T> extends KtVisitor<T, TranslationContext> {
 
     protected abstract T emptyResult(@NotNull TranslationContext context);
 
     @Override
-    public T visitJetElement(@NotNull JetElement expression, TranslationContext context) {
+    public T visitJetElement(@NotNull KtElement expression, TranslationContext context) {
         context.bindingTrace().report(ErrorsJs.NOT_SUPPORTED.on(expression, expression));
         return emptyResult(context);
     }
 
-    public final void traverseContainer(@NotNull JetDeclarationContainer jetClass,
+    public final void traverseContainer(@NotNull KtDeclarationContainer jetClass,
             @NotNull TranslationContext context) {
-        for (JetDeclaration declaration : jetClass.getDeclarations()) {
+        for (KtDeclaration declaration : jetClass.getDeclarations()) {
             declaration.accept(this, context);
         }
     }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/ClassInitializerTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/ClassInitializerTranslator.java
index 55e34a61bc0..42ea0a08e9b 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/ClassInitializerTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/ClassInitializerTranslator.java
@@ -28,11 +28,11 @@ import org.jetbrains.kotlin.js.translate.declaration.DelegationTranslator;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
 import org.jetbrains.kotlin.js.translate.reference.CallArgumentTranslator;
 import org.jetbrains.kotlin.js.translate.utils.jsAstUtils.AstUtilsKt;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -45,14 +45,14 @@ import static org.jetbrains.kotlin.resolve.DescriptorUtils.getClassDescriptorFor
 
 public final class ClassInitializerTranslator extends AbstractTranslator {
     @NotNull
-    private final JetClassOrObject classDeclaration;
+    private final KtClassOrObject classDeclaration;
     @NotNull
     private final List<JsStatement> initializerStatements = new SmartList<JsStatement>();
     private final JsFunction initFunction;
     private final TranslationContext context;
 
     public ClassInitializerTranslator(
-            @NotNull JetClassOrObject classDeclaration,
+            @NotNull KtClassOrObject classDeclaration,
             @NotNull TranslationContext context
     ) {
         super(context);
@@ -68,7 +68,7 @@ public final class ClassInitializerTranslator extends AbstractTranslator {
     }
 
     @NotNull
-    private static JsFunction createInitFunction(JetClassOrObject declaration, TranslationContext context) {
+    private static JsFunction createInitFunction(KtClassOrObject declaration, TranslationContext context) {
         //TODO: it's inconsistent that we have scope for class and function for constructor, currently have problems implementing better way
         ClassDescriptor classDescriptor = getClassDescriptor(context.bindingContext(), declaration);
         ConstructorDescriptor primaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
@@ -114,7 +114,7 @@ public final class ClassInitializerTranslator extends AbstractTranslator {
     }
 
     @NotNull
-    public JsExpression generateEnumEntryInstanceCreation(@NotNull JetType enumClassType) {
+    public JsExpression generateEnumEntryInstanceCreation(@NotNull KtType enumClassType) {
         ResolvedCall<FunctionDescriptor> superCall = getSuperCall();
 
         if (superCall == null) {
@@ -127,7 +127,7 @@ public final class ClassInitializerTranslator extends AbstractTranslator {
     }
 
     private void mayBeAddCallToSuperMethod(JsFunction initializer) {
-        if (classDeclaration.hasModifier(JetTokens.ENUM_KEYWORD)) {
+        if (classDeclaration.hasModifier(KtTokens.ENUM_KEYWORD)) {
             addCallToSuperMethod(Collections.<JsExpression>emptyList(), initializer);
             return;
         }
@@ -135,7 +135,7 @@ public final class ClassInitializerTranslator extends AbstractTranslator {
             ResolvedCall<FunctionDescriptor> superCall = getSuperCall();
             if (superCall == null) return;
 
-            if (classDeclaration instanceof JetEnumEntry) {
+            if (classDeclaration instanceof KtEnumEntry) {
                 JsExpression expression = CallTranslator.translate(context(), superCall, null);
                 JsExpression fixedInvocation = AstUtilsKt.toInvocationWith(expression, JsLiteral.THIS);
                 initializerStatements.add(0, fixedInvocation.makeStmt());
@@ -158,9 +158,9 @@ public final class ClassInitializerTranslator extends AbstractTranslator {
 
     @Nullable
     private ResolvedCall<FunctionDescriptor> getSuperCall() {
-        for (JetDelegationSpecifier specifier : classDeclaration.getDelegationSpecifiers()) {
-            if (specifier instanceof JetDelegatorToSuperCall) {
-                JetDelegatorToSuperCall superCall = (JetDelegatorToSuperCall) specifier;
+        for (KtDelegationSpecifier specifier : classDeclaration.getDelegationSpecifiers()) {
+            if (specifier instanceof KtDelegatorToSuperCall) {
+                KtDelegatorToSuperCall superCall = (KtDelegatorToSuperCall) specifier;
                 //noinspection unchecked
                 return (ResolvedCall<FunctionDescriptor>) CallUtilKt.getResolvedCallWithAssert(superCall, bindingContext());
             }
@@ -170,16 +170,16 @@ public final class ClassInitializerTranslator extends AbstractTranslator {
 
     @NotNull
     List<JsParameter> translatePrimaryConstructorParameters() {
-        List<JetParameter> parameterList = getPrimaryConstructorParameters(classDeclaration);
+        List<KtParameter> parameterList = getPrimaryConstructorParameters(classDeclaration);
         List<JsParameter> result = new ArrayList<JsParameter>();
-        for (JetParameter jetParameter : parameterList) {
+        for (KtParameter jetParameter : parameterList) {
             result.add(translateParameter(jetParameter));
         }
         return result;
     }
 
     @NotNull
-    private JsParameter translateParameter(@NotNull JetParameter jetParameter) {
+    private JsParameter translateParameter(@NotNull KtParameter jetParameter) {
         DeclarationDescriptor parameterDescriptor =
                 getDescriptorForElement(bindingContext(), jetParameter);
         JsName parameterName = context().getNameForDescriptor(parameterDescriptor);
@@ -189,7 +189,7 @@ public final class ClassInitializerTranslator extends AbstractTranslator {
     }
 
     private void mayBeAddInitializerStatementForProperty(@NotNull JsParameter jsParameter,
-            @NotNull JetParameter jetParameter) {
+            @NotNull KtParameter jetParameter) {
         PropertyDescriptor propertyDescriptor =
                 getPropertyDescriptorForConstructorParameter(bindingContext(), jetParameter);
         if (propertyDescriptor == null) {
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerUtils.java
index 6dd88281b0c..186b79426ad 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerUtils.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerUtils.java
@@ -26,9 +26,9 @@ import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.declaration.ClassTranslator;
 import org.jetbrains.kotlin.js.translate.general.Translation;
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetObjectDeclaration;
-import org.jetbrains.kotlin.psi.JetProperty;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtObjectDeclaration;
+import org.jetbrains.kotlin.psi.KtProperty;
 
 import java.util.List;
 
@@ -48,8 +48,8 @@ public final class InitializerUtils {
     }
 
     @Nullable
-    public static JsStatement generateInitializerForDelegate(@NotNull TranslationContext context, @NotNull JetProperty property) {
-        JetExpression delegate = property.getDelegateExpression();
+    public static JsStatement generateInitializerForDelegate(@NotNull TranslationContext context, @NotNull KtProperty property) {
+        KtExpression delegate = property.getDelegateExpression();
         if (delegate != null) {
             JsExpression value = Translation.translateAsExpression(delegate, context);
             String name = property.getName();
@@ -60,7 +60,7 @@ public final class InitializerUtils {
     }
 
     public static void generateObjectInitializer(
-            @NotNull JetObjectDeclaration declaration,
+            @NotNull KtObjectDeclaration declaration,
             @NotNull List<JsStatement> initializers,
             @NotNull TranslationContext context
     ) {
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerVisitor.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerVisitor.java
index 1470e599c1b..80274e308d4 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerVisitor.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerVisitor.java
@@ -43,8 +43,8 @@ public final class InitializerVisitor extends TranslatorVisitor<Void> {
     }
 
     @Override
-    public final Void visitProperty(@NotNull JetProperty property, @NotNull TranslationContext context) {
-        JetExpression initializer = property.getInitializer();
+    public final Void visitProperty(@NotNull KtProperty property, @NotNull TranslationContext context) {
+        KtExpression initializer = property.getInitializer();
         if (initializer != null) {
             result.add(generateInitializerForProperty(context, getPropertyDescriptor(context.bindingContext(), property),
                                                       Translation.translateAsExpression(initializer, context)));
@@ -57,8 +57,8 @@ public final class InitializerVisitor extends TranslatorVisitor<Void> {
     }
 
     @Override
-    public Void visitAnonymousInitializer(@NotNull JetClassInitializer initializer, @NotNull TranslationContext context) {
-        JetExpression initializerBody = initializer.getBody();
+    public Void visitAnonymousInitializer(@NotNull KtClassInitializer initializer, @NotNull TranslationContext context) {
+        KtExpression initializerBody = initializer.getBody();
         if (initializerBody != null) {
             result.add(translateAsStatementAndMergeInBlockIfNeeded(initializerBody, context));
         }
@@ -67,12 +67,12 @@ public final class InitializerVisitor extends TranslatorVisitor<Void> {
 
     @Override
     // Not interested in other types of declarations, they do not contain initializers.
-    public Void visitDeclaration(@NotNull JetDeclaration expression, @NotNull TranslationContext context) {
+    public Void visitDeclaration(@NotNull KtDeclaration expression, @NotNull TranslationContext context) {
         return null;
     }
 
     @Override
-    public Void visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, @NotNull TranslationContext context) {
+    public Void visitObjectDeclaration(@NotNull KtObjectDeclaration declaration, @NotNull TranslationContext context) {
         if (!declaration.isCompanion()) {
             InitializerUtils.generateObjectInitializer(declaration, result, context);
         }
@@ -80,7 +80,7 @@ public final class InitializerVisitor extends TranslatorVisitor<Void> {
     }
 
     @Override
-    public Void visitSecondaryConstructor(@NotNull JetSecondaryConstructor constructor, TranslationContext data) {
+    public Void visitSecondaryConstructor(@NotNull KtSecondaryConstructor constructor, TranslationContext data) {
         return null;
     }
 }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/Intrinsics.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/Intrinsics.java
index c451d27c934..e6aa3166f42 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/Intrinsics.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/Intrinsics.java
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.js.translate.intrinsic.objects.ObjectIntrinsic;
 import org.jetbrains.kotlin.js.translate.intrinsic.objects.ObjectIntrinsics;
 import org.jetbrains.kotlin.js.translate.intrinsic.operation.BinaryOperationIntrinsic;
 import org.jetbrains.kotlin.js.translate.intrinsic.operation.BinaryOperationIntrinsics;
-import org.jetbrains.kotlin.psi.JetBinaryExpression;
+import org.jetbrains.kotlin.psi.KtBinaryExpression;
 
 /**
  * Provides mechanism to substitute method calls /w native constructs directly.
@@ -38,7 +38,7 @@ public final class Intrinsics {
 
     @NotNull
     public BinaryOperationIntrinsic getBinaryOperationIntrinsic(
-            @NotNull JetBinaryExpression expression,
+            @NotNull KtBinaryExpression expression,
             @NotNull TranslationContext context
     ) {
         return binaryOperationIntrinsics.getIntrinsic(expression, context);
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java
index dfbe15190c5..207529dc61a 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.js.translate.intrinsic.functions.basic.FunctionIntri
 import org.jetbrains.kotlin.js.translate.operation.OperatorTable;
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils;
 import org.jetbrains.kotlin.js.translate.utils.JsDescriptorUtils;
-import org.jetbrains.kotlin.lexer.JetToken;
+import org.jetbrains.kotlin.lexer.KtToken;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
@@ -179,7 +179,7 @@ public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory {
 
     @NotNull
     private static JsBinaryOperator getOperator(@NotNull FunctionDescriptor descriptor) {
-        JetToken token = OperatorConventions.BINARY_OPERATION_NAMES.inverse().get(descriptor.getName());
+        KtToken token = OperatorConventions.BINARY_OPERATION_NAMES.inverse().get(descriptor.getName());
         if (token == null) {
             token = OperatorConventions.BOOLEAN_OPERATIONS.inverse().get(descriptor.getName());
         }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveUnaryOperationFIF.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveUnaryOperationFIF.java
index 9e54d80e341..79147aa2ce1 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveUnaryOperationFIF.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveUnaryOperationFIF.java
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.js.translate.intrinsic.functions.basic.FunctionIntri
 import org.jetbrains.kotlin.js.translate.operation.OperatorTable;
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils;
 import org.jetbrains.kotlin.js.translate.utils.JsDescriptorUtils;
-import org.jetbrains.kotlin.lexer.JetToken;
+import org.jetbrains.kotlin.lexer.KtToken;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
@@ -199,7 +199,7 @@ public enum PrimitiveUnaryOperationFIF implements FunctionIntrinsicFactory {
             jsOperator = JsUnaryOperator.BIT_NOT;
         }
         else {
-            JetToken jetToken = OperatorConventions.UNARY_OPERATION_NAMES_WITH_DEPRECATED_INVERTED.get(name);
+            KtToken jetToken = OperatorConventions.UNARY_OPERATION_NAMES_WITH_DEPRECATED_INVERTED.get(name);
             jsOperator = OperatorTable.getUnaryOperator(jetToken);
         }
 
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/TopLevelFIF.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/TopLevelFIF.java
index 45d0cdec963..b3f045cd403 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/TopLevelFIF.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/TopLevelFIF.java
@@ -27,19 +27,18 @@ import org.jetbrains.kotlin.js.patterns.DescriptorPredicate;
 import org.jetbrains.kotlin.js.patterns.NamePredicate;
 import org.jetbrains.kotlin.js.resolve.JsPlatform;
 import org.jetbrains.kotlin.js.translate.callTranslator.CallInfo;
-import org.jetbrains.kotlin.js.translate.context.Namer;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.intrinsic.functions.basic.FunctionIntrinsic;
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils;
 import org.jetbrains.kotlin.js.translate.utils.BindingUtils;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetQualifiedExpression;
-import org.jetbrains.kotlin.psi.JetReferenceExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtQualifiedExpression;
+import org.jetbrains.kotlin.psi.KtReferenceExpression;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.List;
 
@@ -179,15 +178,15 @@ public final class TopLevelFIF extends CompositeFIF {
             JsExpression thisOrReceiver = getThisOrReceiverOrNull(callInfo);
             assert thisOrReceiver != null;
             if (expressionReceiver != null) {
-                JetExpression expression = expressionReceiver.getExpression();
-                JetReferenceExpression referenceExpression = null;
-                if (expression instanceof JetReferenceExpression) {
-                    referenceExpression = (JetReferenceExpression) expression;
+                KtExpression expression = expressionReceiver.getExpression();
+                KtReferenceExpression referenceExpression = null;
+                if (expression instanceof KtReferenceExpression) {
+                    referenceExpression = (KtReferenceExpression) expression;
                 }
-                else if (expression instanceof JetQualifiedExpression) {
-                    JetExpression candidate = ((JetQualifiedExpression) expression).getReceiverExpression();
-                    if (candidate instanceof JetReferenceExpression) {
-                        referenceExpression = (JetReferenceExpression) candidate;
+                else if (expression instanceof KtQualifiedExpression) {
+                    KtExpression candidate = ((KtQualifiedExpression) expression).getReceiverExpression();
+                    if (candidate instanceof KtReferenceExpression) {
+                        referenceExpression = (KtReferenceExpression) candidate;
                     }
                 }
 
@@ -220,7 +219,7 @@ public final class TopLevelFIF extends CompositeFIF {
                 @NotNull List<JsExpression> arguments,
                 @NotNull TranslationContext context
         ) {
-            JetType keyType = callInfo.getResolvedCall().getTypeArguments().values().iterator().next();
+            KtType keyType = callInfo.getResolvedCall().getTypeArguments().values().iterator().next();
             Name keyTypeName = DescriptorUtilsKt.getNameIfStandardType(keyType);
             String collectionClassName = null;
             if (keyTypeName != null) {
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/CompareToBOIF.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/CompareToBOIF.kt
index 561a890c01f..145e94be4c5 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/CompareToBOIF.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/CompareToBOIF.kt
@@ -19,9 +19,9 @@ package org.jetbrains.kotlin.js.translate.intrinsic.operation
 import com.google.common.collect.ImmutableSet
 import com.google.dart.compiler.backend.js.ast.*
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.psi.JetBinaryExpression
+import org.jetbrains.kotlin.psi.KtBinaryExpression
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
-import org.jetbrains.kotlin.lexer.JetToken
+import org.jetbrains.kotlin.lexer.KtToken
 import org.jetbrains.kotlin.js.patterns.PatternBuilder.pattern
 import org.jetbrains.kotlin.js.translate.context.TranslationContext
 import org.jetbrains.kotlin.js.translate.operation.OperatorTable
@@ -36,28 +36,28 @@ object CompareToBOIF : BinaryOperationIntrinsicFactory {
     val PRIMITIVE_COMPARE_TO = pattern("Int|Short|Byte|Double|Float|Char|String.compareTo")
 
     private object CompareToIntrinsic : AbstractBinaryOperationIntrinsic() {
-        override fun apply(expression: JetBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
+        override fun apply(expression: KtBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
             val operator = OperatorTable.getBinaryOperator(getOperationToken(expression))
             return JsBinaryOperation(operator, left, right)
         }
     }
 
     private object CompareToCharIntrinsic : AbstractBinaryOperationIntrinsic() {
-        override fun apply(expression: JetBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
+        override fun apply(expression: KtBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
             val operator = OperatorTable.getBinaryOperator(getOperationToken(expression))
             return JsBinaryOperation(operator, left, JsAstUtils.charToInt(right))
         }
     }
 
     private object CompareCharToPrimitiveIntrinsic : AbstractBinaryOperationIntrinsic() {
-        override fun apply(expression: JetBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
+        override fun apply(expression: KtBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
             val operator = OperatorTable.getBinaryOperator(getOperationToken(expression))
             return JsBinaryOperation(operator, JsAstUtils.charToInt(left), right)
         }
     }
 
     private object CompareToFunctionIntrinsic : AbstractBinaryOperationIntrinsic() {
-        override fun apply(expression: JetBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
+        override fun apply(expression: KtBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
             val operator = OperatorTable.getBinaryOperator(getOperationToken(expression))
             val compareTo = JsAstUtils.compareTo(left, right)
             return JsBinaryOperation(operator, compareTo, JsNumberLiteral.ZERO)
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/EqualsBOIF.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/EqualsBOIF.kt
index a1bf4a5b568..54a8828ccab 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/EqualsBOIF.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/EqualsBOIF.kt
@@ -29,8 +29,8 @@ import org.jetbrains.kotlin.js.translate.utils.JsAstUtils
 import org.jetbrains.kotlin.js.translate.utils.JsDescriptorUtils
 import org.jetbrains.kotlin.js.translate.utils.PsiUtils.getOperationToken
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetBinaryExpression
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtBinaryExpression
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
@@ -42,14 +42,14 @@ object EqualsBOIF : BinaryOperationIntrinsicFactory {
     val LONG_EQUALS_ANY = pattern("Long.equals")
 
     private object LONG_EQUALS_ANY_INTRINSIC : AbstractBinaryOperationIntrinsic() {
-        override fun apply(expression: JetBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
+        override fun apply(expression: KtBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
             val invokeEquals = JsAstUtils.equalsForObject(left, right)
             return if (expression.isNegated()) JsAstUtils.not(invokeEquals) else invokeEquals
         }
     }
 
     private object EqualsIntrinsic : AbstractBinaryOperationIntrinsic() {
-        override fun apply(expression: JetBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
+        override fun apply(expression: KtBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
             val isNegated = expression.isNegated()
             if (right == JsLiteral.NULL || left == JsLiteral.NULL) {
                 return TranslationUtils.nullCheck(if (right == JsLiteral.NULL) left else right, isNegated)
@@ -73,7 +73,7 @@ object EqualsBOIF : BinaryOperationIntrinsicFactory {
             return if (isNegated) JsAstUtils.negated(result) else result
         }
 
-        private fun canUseSimpleEquals(expression: JetBinaryExpression, context: TranslationContext): Boolean {
+        private fun canUseSimpleEquals(expression: KtBinaryExpression, context: TranslationContext): Boolean {
             val left = expression.getLeft()
             assert(left != null) { "No left-hand side: " + expression.getText() }
             val typeName = JsDescriptorUtils.getNameIfStandardType(left!!, context)
@@ -82,7 +82,7 @@ object EqualsBOIF : BinaryOperationIntrinsicFactory {
     }
 
     object EnumEqualsIntrinsic : AbstractBinaryOperationIntrinsic() {
-        override fun apply(expression: JetBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsBinaryOperation {
+        override fun apply(expression: KtBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsBinaryOperation {
             val operator = if (expression.isNegated()) JsBinaryOperator.REF_NEQ else JsBinaryOperator.REF_EQ
             return JsBinaryOperation(operator, left, right)
         }
@@ -102,5 +102,5 @@ object EqualsBOIF : BinaryOperationIntrinsicFactory {
                 else -> null
             }
 
-    private fun JetBinaryExpression.isNegated() = getOperationToken(this) == JetTokens.EXCLEQ
+    private fun KtBinaryExpression.isNegated() = getOperationToken(this) == KtTokens.EXCLEQ
 }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/LongCompareToBOIF.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/LongCompareToBOIF.kt
index 769b5c8e933..7714987f394 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/LongCompareToBOIF.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/LongCompareToBOIF.kt
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.js.translate.utils.JsAstUtils.invokeMethod
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils.longFromInt
 import org.jetbrains.kotlin.js.translate.utils.JsDescriptorUtils
 import org.jetbrains.kotlin.js.translate.utils.PsiUtils.getOperationToken
-import org.jetbrains.kotlin.psi.JetBinaryExpression
+import org.jetbrains.kotlin.psi.KtBinaryExpression
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.utils.identity as ID
 
@@ -45,21 +45,21 @@ public object LongCompareToBOIF : BinaryOperationIntrinsicFactory {
     val LONG_COMPARE_TO_LONG_PATTERN = pattern("Long.compareTo(Long)")
 
     private object FLOATING_POINT_COMPARE_TO_LONG : AbstractBinaryOperationIntrinsic() {
-        override fun apply(expression: JetBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
+        override fun apply(expression: KtBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
             val operator = OperatorTable.getBinaryOperator(getOperationToken(expression))
             return JsBinaryOperation(operator, left, invokeMethod(right, Namer.LONG_TO_NUMBER))
         }
     }
 
     private object LONG_COMPARE_TO_FLOATING_POINT : AbstractBinaryOperationIntrinsic() {
-        override fun apply(expression: JetBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
+        override fun apply(expression: KtBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
             val operator = OperatorTable.getBinaryOperator(getOperationToken(expression))
             return JsBinaryOperation(operator, invokeMethod(left, Namer.LONG_TO_NUMBER), right)
         }
     }
 
     private class CompareToBinaryIntrinsic(val toLeft: (JsExpression) -> JsExpression, val toRight: (JsExpression) -> JsExpression) : AbstractBinaryOperationIntrinsic() {
-        override fun apply(expression: JetBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
+        override fun apply(expression: KtBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression {
             val operator = OperatorTable.getBinaryOperator(getOperationToken(expression))
             val compareInvocation = compareForObject(toLeft(left), toRight(right))
             return JsBinaryOperation(operator, compareInvocation, JsNumberLiteral.ZERO)
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/binaryOperationIntrinsics.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/binaryOperationIntrinsics.kt
index 135187f6467..1ea3afe0285 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/binaryOperationIntrinsics.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/binaryOperationIntrinsics.kt
@@ -17,8 +17,8 @@
 package org.jetbrains.kotlin.js.translate.intrinsic.operation
 
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.lexer.JetToken
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.lexer.KtToken
 import org.jetbrains.kotlin.js.translate.context.TranslationContext
 import org.jetbrains.kotlin.js.translate.utils.BindingUtils.getCallableDescriptorForOperationExpression
 import org.jetbrains.kotlin.js.translate.utils.PsiUtils.getOperationToken
@@ -28,18 +28,18 @@ import com.google.common.collect.ImmutableSet
 
 public interface BinaryOperationIntrinsic {
 
-    fun apply(expression: JetBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression
+    fun apply(expression: KtBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression
 
     fun exists(): Boolean
 }
 
 public class BinaryOperationIntrinsics {
 
-    private val intrinsicCache = THashMap<Pair<JetToken, FunctionDescriptor>, BinaryOperationIntrinsic>()
+    private val intrinsicCache = THashMap<Pair<KtToken, FunctionDescriptor>, BinaryOperationIntrinsic>()
 
     private val factories = listOf(LongCompareToBOIF, EqualsBOIF, CompareToBOIF)
 
-    public fun getIntrinsic(expression: JetBinaryExpression, context: TranslationContext): BinaryOperationIntrinsic {
+    public fun getIntrinsic(expression: KtBinaryExpression, context: TranslationContext): BinaryOperationIntrinsic {
         val token = getOperationToken(expression)
         val descriptor = getCallableDescriptorForOperationExpression(context.bindingContext(), expression)
         if (descriptor == null || descriptor !is FunctionDescriptor) {
@@ -49,16 +49,16 @@ public class BinaryOperationIntrinsics {
         return lookUpCache(token, descriptor) ?: computeAndCacheIntrinsic(token, descriptor)
     }
 
-    private fun lookUpCache(token: JetToken, descriptor: FunctionDescriptor): BinaryOperationIntrinsic? =
+    private fun lookUpCache(token: KtToken, descriptor: FunctionDescriptor): BinaryOperationIntrinsic? =
             intrinsicCache.get(Pair(token, descriptor))
 
-    private fun computeAndCacheIntrinsic(token: JetToken, descriptor: FunctionDescriptor): BinaryOperationIntrinsic {
+    private fun computeAndCacheIntrinsic(token: KtToken, descriptor: FunctionDescriptor): BinaryOperationIntrinsic {
         val result = computeIntrinsic(token, descriptor)
         intrinsicCache.put(Pair(token, descriptor), result)
         return result
     }
 
-    private fun computeIntrinsic(token: JetToken, descriptor: FunctionDescriptor): BinaryOperationIntrinsic {
+    private fun computeIntrinsic(token: KtToken, descriptor: FunctionDescriptor): BinaryOperationIntrinsic {
         for (factory in factories) {
             if (factory.getSupportTokens().contains(token)) {
                 val intrinsic = factory.getIntrinsic(descriptor)
@@ -73,14 +73,14 @@ public class BinaryOperationIntrinsics {
 
 interface BinaryOperationIntrinsicFactory {
 
-    public fun getSupportTokens(): ImmutableSet<out JetToken>
+    public fun getSupportTokens(): ImmutableSet<out KtToken>
 
     public fun getIntrinsic(descriptor: FunctionDescriptor): BinaryOperationIntrinsic?
 }
 
 abstract class AbstractBinaryOperationIntrinsic : BinaryOperationIntrinsic {
 
-    public override abstract fun apply(expression: JetBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression
+    public override abstract fun apply(expression: KtBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression
 
     public override fun exists(): Boolean = true
 }
@@ -88,6 +88,6 @@ abstract class AbstractBinaryOperationIntrinsic : BinaryOperationIntrinsic {
 object NO_INTRINSIC : AbstractBinaryOperationIntrinsic() {
     override fun exists(): Boolean = false
 
-    override fun apply(expression: JetBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression =
+    override fun apply(expression: KtBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression =
             throw UnsupportedOperationException("BinaryOperationIntrinsic#NO_INTRINSIC_#apply")
 }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/AssignmentTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/AssignmentTranslator.java
index 5959a142d5a..012d56250db 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/AssignmentTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/AssignmentTranslator.java
@@ -21,11 +21,11 @@ import com.google.dart.compiler.backend.js.ast.JsExpression;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
-import org.jetbrains.kotlin.psi.JetBinaryExpression;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.psi.KtBinaryExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
-import org.jetbrains.kotlin.lexer.JetToken;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
 import org.jetbrains.kotlin.js.translate.reference.AccessTranslationUtils;
@@ -41,12 +41,12 @@ import static org.jetbrains.kotlin.js.translate.utils.TranslationUtils.translate
 
 public abstract class AssignmentTranslator extends AbstractTranslator {
 
-    public static boolean isAssignmentOperator(JetToken operationToken) {
+    public static boolean isAssignmentOperator(KtToken operationToken) {
         return (OperatorConventions.ASSIGNMENT_OPERATIONS.keySet().contains(operationToken) || isAssignment(operationToken));
     }
 
     @NotNull
-    public static JsExpression translate(@NotNull JetBinaryExpression expression,
+    public static JsExpression translate(@NotNull KtBinaryExpression expression,
                                          @NotNull TranslationContext context) {
         if (hasCorrespondingFunctionIntrinsic(context, expression)) {
             return IntrinsicAssignmentTranslator.doTranslate(expression, context);
@@ -55,25 +55,25 @@ public abstract class AssignmentTranslator extends AbstractTranslator {
     }
 
     @NotNull
-    protected final JetBinaryExpression expression;
+    protected final KtBinaryExpression expression;
     protected final AccessTranslator accessTranslator;
     protected final boolean isVariableReassignment;
     @NotNull
     protected final JsExpression right;
 
-    protected AssignmentTranslator(@NotNull JetBinaryExpression expression,
+    protected AssignmentTranslator(@NotNull KtBinaryExpression expression,
                                    @NotNull TranslationContext context) {
         super(context);
         this.expression = expression;
         this.isVariableReassignment = isVariableReassignment(context.bindingContext(), expression);
-        JetExpression left = expression.getLeft();
+        KtExpression left = expression.getLeft();
         assert left != null : "No left-hand side: " + expression.getText();
 
         JsBlock rightBlock = new JsBlock();
         this.right = translateRightExpression(context, expression, rightBlock);
 
         if (isValProperty(left, context)) {
-            JetSimpleNameExpression simpleName = getSimpleName(left);
+            KtSimpleNameExpression simpleName = getSimpleName(left);
             assert simpleName != null;
             this.accessTranslator = BackingFieldAccessTranslator.newInstance(simpleName, context);
         } else {
@@ -84,10 +84,10 @@ public abstract class AssignmentTranslator extends AbstractTranslator {
     }
 
     private static boolean isValProperty(
-            @NotNull JetExpression expression,
+            @NotNull KtExpression expression,
             @NotNull TranslationContext context
     ) {
-        JetSimpleNameExpression simpleNameExpression = getSimpleName(expression);
+        KtSimpleNameExpression simpleNameExpression = getSimpleName(expression);
 
         if (simpleNameExpression != null) {
             DeclarationDescriptor descriptor = getDescriptorForReferenceExpression(context.bindingContext(), simpleNameExpression);
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/BinaryOperationTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/BinaryOperationTranslator.java
index 1f079c8ca30..83d87a607a9 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/BinaryOperationTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/BinaryOperationTranslator.java
@@ -30,14 +30,14 @@ import org.jetbrains.kotlin.js.translate.intrinsic.functions.factories.TopLevelF
 import org.jetbrains.kotlin.js.translate.intrinsic.operation.BinaryOperationIntrinsic;
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils;
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils;
-import org.jetbrains.kotlin.lexer.JetToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
-import org.jetbrains.kotlin.psi.JetBinaryExpression;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
+import org.jetbrains.kotlin.psi.KtBinaryExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilsKt;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
 
@@ -52,44 +52,44 @@ import static org.jetbrains.kotlin.js.translate.utils.PsiUtils.*;
 public final class BinaryOperationTranslator extends AbstractTranslator {
 
     @NotNull
-    public static JsExpression translate(@NotNull JetBinaryExpression expression,
+    public static JsExpression translate(@NotNull KtBinaryExpression expression,
             @NotNull TranslationContext context) {
         JsExpression jsExpression = new BinaryOperationTranslator(expression, context).translate();
         return jsExpression.source(expression);
     }
 
     @NotNull
-    /*package*/ static JsExpression translateAsOverloadedCall(@NotNull JetBinaryExpression expression,
+    /*package*/ static JsExpression translateAsOverloadedCall(@NotNull KtBinaryExpression expression,
             @NotNull TranslationContext context) {
         JsExpression jsExpression = (new BinaryOperationTranslator(expression, context)).translateAsOverloadedBinaryOperation();
         return jsExpression.source(expression);
     }
 
     @NotNull
-    private final JetBinaryExpression expression;
+    private final KtBinaryExpression expression;
 
     @NotNull
-    private final JetExpression leftJetExpression;
+    private final KtExpression leftKtExpression;
 
     @NotNull
-    private final JetExpression rightJetExpression;
+    private final KtExpression rightKtExpression;
 
     @NotNull
-    private final JetToken operationToken;
+    private final KtToken operationToken;
 
     @Nullable
     private final CallableDescriptor operationDescriptor;
 
-    private BinaryOperationTranslator(@NotNull JetBinaryExpression expression,
+    private BinaryOperationTranslator(@NotNull KtBinaryExpression expression,
             @NotNull TranslationContext context) {
         super(context);
         this.expression = expression;
 
         assert expression.getLeft() != null : "Binary expression should have a left expression: " + expression.getText();
-        leftJetExpression = expression.getLeft();
+        leftKtExpression = expression.getLeft();
 
         assert expression.getRight() != null : "Binary expression should have a right expression: " + expression.getText();
-        rightJetExpression = expression.getRight();
+        rightKtExpression = expression.getRight();
 
         this.operationToken = getOperationToken(expression);
         this.operationDescriptor = getCallableDescriptorForOperationExpression(bindingContext(), expression);
@@ -101,7 +101,7 @@ public final class BinaryOperationTranslator extends AbstractTranslator {
         if (intrinsic.exists()) {
             return applyIntrinsic(intrinsic);
         }
-        if (operationToken == JetTokens.ELVIS) {
+        if (operationToken == KtTokens.ELVIS) {
             return translateElvis();
         }
         if (isAssignmentOperator(operationToken)) {
@@ -123,13 +123,13 @@ public final class BinaryOperationTranslator extends AbstractTranslator {
 
     @NotNull
     private JsExpression translateElvis() {
-        JsExpression leftExpression = Translation.translateAsExpression(leftJetExpression, context());
+        JsExpression leftExpression = Translation.translateAsExpression(leftKtExpression, context());
         if (JsAstUtils.isEmptyExpression(leftExpression)) {
             return leftExpression;
         }
 
         JsBlock rightBlock = new JsBlock();
-        JsExpression rightExpression = Translation.translateAsExpression(rightJetExpression, context(), rightBlock);
+        JsExpression rightExpression = Translation.translateAsExpression(rightKtExpression, context(), rightBlock);
 
         if (rightBlock.isEmpty()) {
             return TranslationUtils.notNullConditional(leftExpression, rightExpression, context());
@@ -168,13 +168,13 @@ public final class BinaryOperationTranslator extends AbstractTranslator {
 
     @NotNull
     private JsExpression applyIntrinsic(@NotNull BinaryOperationIntrinsic intrinsic) {
-        JsExpression leftExpression = Translation.translateAsExpression(leftJetExpression, context());
+        JsExpression leftExpression = Translation.translateAsExpression(leftKtExpression, context());
         if (JsAstUtils.isEmptyExpression(leftExpression)) {
             return leftExpression;
         }
 
         JsBlock rightBlock = new JsBlock();
-        JsExpression rightExpression = Translation.translateAsExpression(rightJetExpression, context(), rightBlock);
+        JsExpression rightExpression = Translation.translateAsExpression(rightKtExpression, context(), rightBlock);
 
         if (rightBlock.isEmpty()) {
             return intrinsic.apply(expression, leftExpression, rightExpression, context());
@@ -206,13 +206,13 @@ public final class BinaryOperationTranslator extends AbstractTranslator {
     private JsExpression translateAsUnOverloadableBinaryOperation() {
         assert OperatorConventions.NOT_OVERLOADABLE.contains(operationToken);
         JsBinaryOperator operator = OperatorTable.getBinaryOperator(operationToken);
-        JsExpression leftExpression = Translation.translateAsExpression(leftJetExpression, context());
+        JsExpression leftExpression = Translation.translateAsExpression(leftKtExpression, context());
         if (JsAstUtils.isEmptyExpression(leftExpression)) {
             return leftExpression;
         }
 
         JsBlock rightBlock = new JsBlock();
-        JsExpression rightExpression = Translation.translateAsExpression(rightJetExpression, context(), rightBlock);
+        JsExpression rightExpression = Translation.translateAsExpression(rightKtExpression, context(), rightBlock);
 
         if (rightBlock.isEmpty()) {
             return new JsBinaryOperation(operator, leftExpression, rightExpression);
@@ -222,8 +222,8 @@ public final class BinaryOperationTranslator extends AbstractTranslator {
             return new JsBinaryOperation(operator, leftExpression, rightExpression);
         }
 
-        assert operationToken.equals(JetTokens.ANDAND) || operationToken.equals(JetTokens.OROR) : "Unsupported binary operation: " + expression.getText();
-        boolean isOror = operationToken.equals(JetTokens.OROR);
+        assert operationToken.equals(KtTokens.ANDAND) || operationToken.equals(KtTokens.OROR) : "Unsupported binary operation: " + expression.getText();
+        boolean isOror = operationToken.equals(KtTokens.OROR);
         JsExpression literalResult = isOror ? JsLiteral.TRUE : JsLiteral.FALSE;
         leftExpression = isOror ? not(leftExpression) : leftExpression;
 
@@ -255,20 +255,20 @@ public final class BinaryOperationTranslator extends AbstractTranslator {
     }
 
     private boolean isEquals() {
-        return operationToken == JetTokens.EQEQ || operationToken == JetTokens.EXCLEQ;
+        return operationToken == KtTokens.EQEQ || operationToken == KtTokens.EXCLEQ;
     }
 
     private JsExpression translateEquals() {
-        JsExpression left = Translation.translateAsExpression(leftJetExpression, context());
-        JsExpression right = Translation.translateAsExpression(rightJetExpression, context());
+        JsExpression left = Translation.translateAsExpression(leftKtExpression, context());
+        JsExpression right = Translation.translateAsExpression(rightKtExpression, context());
 
         if (left == JsLiteral.NULL || right == JsLiteral.NULL) {
-            JsBinaryOperator operator = operationToken == JetTokens.EXCLEQ ? JsBinaryOperator.NEQ : JsBinaryOperator.EQ;
+            JsBinaryOperator operator = operationToken == KtTokens.EXCLEQ ? JsBinaryOperator.NEQ : JsBinaryOperator.EQ;
             return new JsBinaryOperation(operator, left, right);
         }
 
-        JetType leftType = context().bindingContext().getType(leftJetExpression);
-        JetType rightType = context().bindingContext().getType(rightJetExpression);
+        KtType leftType = context().bindingContext().getType(leftKtExpression);
+        KtType rightType = context().bindingContext().getType(rightKtExpression);
 
         if (leftType != null && TypeUtils.isNullableType(leftType) || rightType != null && TypeUtils.isNullableType(rightType)) {
             return mayBeWrapWithNegation(TopLevelFIF.KOTLIN_EQUALS.apply(left, Collections.singletonList(right), context()));
@@ -287,9 +287,9 @@ public final class BinaryOperationTranslator extends AbstractTranslator {
     @NotNull
     private JsExpression getReceiver() {
         if (isInOrNotInOperation(expression)) {
-            return Translation.translateAsExpression(rightJetExpression, context());
+            return Translation.translateAsExpression(rightKtExpression, context());
         } else {
-            return Translation.translateAsExpression(leftJetExpression, context());
+            return Translation.translateAsExpression(leftKtExpression, context());
         }
     }
 
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/CompareToTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/CompareToTranslator.java
index 5b423f7d12e..30afbd8d786 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/CompareToTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/CompareToTranslator.java
@@ -24,8 +24,8 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
-import org.jetbrains.kotlin.lexer.JetToken;
-import org.jetbrains.kotlin.psi.JetBinaryExpression;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.psi.KtBinaryExpression;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
 
 import static org.jetbrains.kotlin.js.translate.utils.BindingUtils.getCallableDescriptorForOperationExpression;
@@ -36,7 +36,7 @@ import static org.jetbrains.kotlin.js.translate.utils.PsiUtils.getOperationToken
 public final class CompareToTranslator extends AbstractTranslator {
 
     public static boolean isCompareToCall(
-            @NotNull JetToken operationToken,
+            @NotNull KtToken operationToken,
             @Nullable CallableDescriptor operationDescriptor
     ) {
         if (!OperatorConventions.COMPARISON_OPERATIONS.contains(operationToken) || operationDescriptor == null) return false;
@@ -45,16 +45,16 @@ public final class CompareToTranslator extends AbstractTranslator {
     }
 
     @NotNull
-    public static JsExpression translate(@NotNull JetBinaryExpression expression,
+    public static JsExpression translate(@NotNull KtBinaryExpression expression,
             @NotNull TranslationContext context) {
         return (new CompareToTranslator(expression, context)).translate();
     }
 
     @NotNull
-    private final JetBinaryExpression expression;
+    private final KtBinaryExpression expression;
 
     private CompareToTranslator(
-            @NotNull JetBinaryExpression expression,
+            @NotNull KtBinaryExpression expression,
             @NotNull TranslationContext context
     ) {
         super(context);
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/IncrementTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/IncrementTranslator.java
index 9ab83c240b3..a03bbdfa9b5 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/IncrementTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/IncrementTranslator.java
@@ -28,8 +28,8 @@ import org.jetbrains.kotlin.js.translate.context.TemporaryVariable;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
 import org.jetbrains.kotlin.js.translate.reference.CachedAccessTranslator;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetUnaryExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtUnaryExpression;
 import org.jetbrains.kotlin.resolve.calls.tasks.DynamicCallsKt;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
 
@@ -52,7 +52,7 @@ public abstract class IncrementTranslator extends AbstractTranslator {
     }
 
     @NotNull
-    public static JsExpression translate(@NotNull JetUnaryExpression expression,
+    public static JsExpression translate(@NotNull KtUnaryExpression expression,
                                          @NotNull TranslationContext context) {
         if (hasCorrespondingFunctionIntrinsic(context, expression) || isDynamic(context, expression)) {
             return IntrinsicIncrementTranslator.doTranslate(expression, context);
@@ -61,15 +61,15 @@ public abstract class IncrementTranslator extends AbstractTranslator {
     }
 
     @NotNull
-    protected final JetUnaryExpression expression;
+    protected final KtUnaryExpression expression;
     @NotNull
     protected final CachedAccessTranslator accessTranslator;
 
-    protected IncrementTranslator(@NotNull JetUnaryExpression expression,
+    protected IncrementTranslator(@NotNull KtUnaryExpression expression,
                                   @NotNull TranslationContext context) {
         super(context);
         this.expression = expression;
-        JetExpression baseExpression = getBaseExpression(expression);
+        KtExpression baseExpression = getBaseExpression(expression);
         this.accessTranslator = getCachedAccessTranslator(baseExpression, context());
     }
 
@@ -126,7 +126,7 @@ public abstract class IncrementTranslator extends AbstractTranslator {
     @NotNull
     abstract JsExpression operationExpression(@NotNull JsExpression receiver);
 
-    private static boolean isDynamic(TranslationContext context, JetUnaryExpression expression) {
+    private static boolean isDynamic(TranslationContext context, KtUnaryExpression expression) {
         CallableDescriptor operationDescriptor = getCallableDescriptorForOperationExpression(context.bindingContext(), expression);
         return DynamicCallsKt.isDynamic(operationDescriptor);
     }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/IntrinsicAssignmentTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/IntrinsicAssignmentTranslator.java
index a5a0bc6b37e..f17c0255378 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/IntrinsicAssignmentTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/IntrinsicAssignmentTranslator.java
@@ -21,9 +21,9 @@ import com.google.dart.compiler.backend.js.ast.JsBinaryOperator;
 import com.google.dart.compiler.backend.js.ast.JsExpression;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
-import org.jetbrains.kotlin.lexer.JetToken;
-import org.jetbrains.kotlin.psi.JetBinaryExpression;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.psi.KtBinaryExpression;
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
 
 import static org.jetbrains.kotlin.js.translate.utils.PsiUtils.getOperationToken;
@@ -33,12 +33,12 @@ public final class IntrinsicAssignmentTranslator extends AssignmentTranslator {
 
 
     @NotNull
-    public static JsExpression doTranslate(@NotNull JetBinaryExpression expression,
+    public static JsExpression doTranslate(@NotNull KtBinaryExpression expression,
                                            @NotNull TranslationContext context) {
         return (new IntrinsicAssignmentTranslator(expression, context)).translate();
     }
 
-    private IntrinsicAssignmentTranslator(@NotNull JetBinaryExpression expression,
+    private IntrinsicAssignmentTranslator(@NotNull KtBinaryExpression expression,
                                           @NotNull TranslationContext context) {
         super(expression, context);
     }
@@ -53,7 +53,7 @@ public final class IntrinsicAssignmentTranslator extends AssignmentTranslator {
 
     @NotNull
     private JsExpression translateAsAssignmentOperation() {
-        if (expression.getLeft() instanceof JetSimpleNameExpression) {
+        if (expression.getLeft() instanceof KtSimpleNameExpression) {
             return translateAsPlainAssignmentOperation();
         }
         return translateAsAssignToCounterpart();
@@ -69,9 +69,9 @@ public final class IntrinsicAssignmentTranslator extends AssignmentTranslator {
 
     @NotNull
     private JsBinaryOperator getCounterpartOperator() {
-        JetToken assignmentOperationToken = getOperationToken(expression);
+        KtToken assignmentOperationToken = getOperationToken(expression);
         assert OperatorConventions.ASSIGNMENT_OPERATIONS.containsKey(assignmentOperationToken);
-        JetToken counterpartToken = OperatorConventions.ASSIGNMENT_OPERATION_COUNTERPARTS.get(assignmentOperationToken);
+        KtToken counterpartToken = OperatorConventions.ASSIGNMENT_OPERATION_COUNTERPARTS.get(assignmentOperationToken);
         assert OperatorTable.hasCorrespondingBinaryOperator(counterpartToken) :
                 "Unsupported token encountered: " + counterpartToken.toString();
         return OperatorTable.getBinaryOperator(counterpartToken);
@@ -85,7 +85,7 @@ public final class IntrinsicAssignmentTranslator extends AssignmentTranslator {
 
     @NotNull
     private JsBinaryOperator getAssignmentOperator() {
-        JetToken token = getOperationToken(expression);
+        KtToken token = getOperationToken(expression);
         assert OperatorConventions.ASSIGNMENT_OPERATIONS.containsKey(token);
         assert OperatorTable.hasCorrespondingBinaryOperator(token) :
                 "Unsupported token encountered: " + token.toString();
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/IntrinsicIncrementTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/IntrinsicIncrementTranslator.java
index bda898a66ea..f8f20917c5c 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/IntrinsicIncrementTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/IntrinsicIncrementTranslator.java
@@ -19,10 +19,10 @@ package org.jetbrains.kotlin.js.translate.operation;
 import com.google.dart.compiler.backend.js.ast.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
-import org.jetbrains.kotlin.lexer.JetToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
-import org.jetbrains.kotlin.psi.JetUnaryExpression;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
+import org.jetbrains.kotlin.psi.KtUnaryExpression;
 
 import static org.jetbrains.kotlin.js.translate.utils.PsiUtils.getOperationToken;
 import static org.jetbrains.kotlin.js.translate.utils.PsiUtils.isPrefix;
@@ -31,13 +31,13 @@ import static org.jetbrains.kotlin.js.translate.utils.PsiUtils.isPrefix;
 public final class IntrinsicIncrementTranslator extends IncrementTranslator {
 
     @NotNull
-    public static JsExpression doTranslate(@NotNull JetUnaryExpression expression,
+    public static JsExpression doTranslate(@NotNull KtUnaryExpression expression,
                                            @NotNull TranslationContext context) {
         return (new IntrinsicIncrementTranslator(expression, context))
                 .translate();
     }
 
-    private IntrinsicIncrementTranslator(@NotNull JetUnaryExpression expression,
+    private IntrinsicIncrementTranslator(@NotNull KtUnaryExpression expression,
                                          @NotNull TranslationContext context) {
         super(expression, context);
     }
@@ -51,7 +51,7 @@ public final class IntrinsicIncrementTranslator extends IncrementTranslator {
     }
 
     private boolean isPrimitiveExpressionIncrement() {
-        return expression.getBaseExpression() instanceof JetSimpleNameExpression;
+        return expression.getBaseExpression() instanceof KtSimpleNameExpression;
     }
 
     @NotNull
@@ -75,11 +75,11 @@ public final class IntrinsicIncrementTranslator extends IncrementTranslator {
     @NotNull
     private JsBinaryOperation unaryAsBinary(@NotNull JsExpression leftExpression) {
         JsNumberLiteral oneLiteral = program().getNumberLiteral(1);
-        JetToken token = getOperationToken(expression);
-        if (token.equals(JetTokens.PLUSPLUS)) {
+        KtToken token = getOperationToken(expression);
+        if (token.equals(KtTokens.PLUSPLUS)) {
             return new JsBinaryOperation(JsBinaryOperator.ADD, leftExpression, oneLiteral);
         }
-        if (token.equals(JetTokens.MINUSMINUS)) {
+        if (token.equals(KtTokens.MINUSMINUS)) {
             return new JsBinaryOperation(JsBinaryOperator.SUB, leftExpression, oneLiteral);
         }
         throw new AssertionError("This method should be called only for increment and decrement operators");
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OperatorTable.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OperatorTable.java
index c59d562b2b7..7d2f15ec2f9 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OperatorTable.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OperatorTable.java
@@ -20,65 +20,65 @@ import com.google.common.collect.ImmutableBiMap;
 import com.google.dart.compiler.backend.js.ast.JsBinaryOperator;
 import com.google.dart.compiler.backend.js.ast.JsUnaryOperator;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.lexer.JetToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
 import java.util.Map;
 
 public final class OperatorTable {
 
     //TODO : not all operators , add and test bit operators
-    private static final Map<JetToken, JsBinaryOperator> binaryOperatorsMap = ImmutableBiMap.<JetToken, JsBinaryOperator>builder()
-            .put(JetTokens.PLUS, JsBinaryOperator.ADD)
-            .put(JetTokens.MINUS, JsBinaryOperator.SUB)
-            .put(JetTokens.MUL, JsBinaryOperator.MUL)
-            .put(JetTokens.DIV, JsBinaryOperator.DIV)
-            .put(JetTokens.EQ, JsBinaryOperator.ASG)
-            .put(JetTokens.GT, JsBinaryOperator.GT)
-            .put(JetTokens.GTEQ, JsBinaryOperator.GTE)
-            .put(JetTokens.LT, JsBinaryOperator.LT)
-            .put(JetTokens.LTEQ, JsBinaryOperator.LTE)
-            .put(JetTokens.ANDAND, JsBinaryOperator.AND)
-            .put(JetTokens.OROR, JsBinaryOperator.OR)
-            .put(JetTokens.PERC, JsBinaryOperator.MOD)
-            .put(JetTokens.PLUSEQ, JsBinaryOperator.ASG_ADD)
-            .put(JetTokens.MINUSEQ, JsBinaryOperator.ASG_SUB)
-            .put(JetTokens.DIVEQ, JsBinaryOperator.ASG_DIV)
-            .put(JetTokens.MULTEQ, JsBinaryOperator.ASG_MUL)
-            .put(JetTokens.PERCEQ, JsBinaryOperator.ASG_MOD)
-            .put(JetTokens.IN_KEYWORD, JsBinaryOperator.INOP)
-            .put(JetTokens.EQEQEQ, JsBinaryOperator.REF_EQ)
-            .put(JetTokens.EXCLEQEQEQ, JsBinaryOperator.REF_NEQ)
+    private static final Map<KtToken, JsBinaryOperator> binaryOperatorsMap = ImmutableBiMap.<KtToken, JsBinaryOperator>builder()
+            .put(KtTokens.PLUS, JsBinaryOperator.ADD)
+            .put(KtTokens.MINUS, JsBinaryOperator.SUB)
+            .put(KtTokens.MUL, JsBinaryOperator.MUL)
+            .put(KtTokens.DIV, JsBinaryOperator.DIV)
+            .put(KtTokens.EQ, JsBinaryOperator.ASG)
+            .put(KtTokens.GT, JsBinaryOperator.GT)
+            .put(KtTokens.GTEQ, JsBinaryOperator.GTE)
+            .put(KtTokens.LT, JsBinaryOperator.LT)
+            .put(KtTokens.LTEQ, JsBinaryOperator.LTE)
+            .put(KtTokens.ANDAND, JsBinaryOperator.AND)
+            .put(KtTokens.OROR, JsBinaryOperator.OR)
+            .put(KtTokens.PERC, JsBinaryOperator.MOD)
+            .put(KtTokens.PLUSEQ, JsBinaryOperator.ASG_ADD)
+            .put(KtTokens.MINUSEQ, JsBinaryOperator.ASG_SUB)
+            .put(KtTokens.DIVEQ, JsBinaryOperator.ASG_DIV)
+            .put(KtTokens.MULTEQ, JsBinaryOperator.ASG_MUL)
+            .put(KtTokens.PERCEQ, JsBinaryOperator.ASG_MOD)
+            .put(KtTokens.IN_KEYWORD, JsBinaryOperator.INOP)
+            .put(KtTokens.EQEQEQ, JsBinaryOperator.REF_EQ)
+            .put(KtTokens.EXCLEQEQEQ, JsBinaryOperator.REF_NEQ)
             .build();
 
-    private static final ImmutableBiMap<JetToken, JsUnaryOperator> unaryOperatorsMap = ImmutableBiMap.<JetToken, JsUnaryOperator>builder()
-            .put(JetTokens.PLUSPLUS, JsUnaryOperator.INC)
-            .put(JetTokens.MINUSMINUS, JsUnaryOperator.DEC)
-            .put(JetTokens.EXCL, JsUnaryOperator.NOT)
-            .put(JetTokens.MINUS, JsUnaryOperator.NEG)
-            .put(JetTokens.PLUS, JsUnaryOperator.POS)
+    private static final ImmutableBiMap<KtToken, JsUnaryOperator> unaryOperatorsMap = ImmutableBiMap.<KtToken, JsUnaryOperator>builder()
+            .put(KtTokens.PLUSPLUS, JsUnaryOperator.INC)
+            .put(KtTokens.MINUSMINUS, JsUnaryOperator.DEC)
+            .put(KtTokens.EXCL, JsUnaryOperator.NOT)
+            .put(KtTokens.MINUS, JsUnaryOperator.NEG)
+            .put(KtTokens.PLUS, JsUnaryOperator.POS)
             .build();
 
     private OperatorTable() {
     }
 
-    public static boolean hasCorrespondingOperator(@NotNull JetToken token) {
+    public static boolean hasCorrespondingOperator(@NotNull KtToken token) {
         return binaryOperatorsMap.containsKey(token) || unaryOperatorsMap.containsKey(token);
     }
 
-    public static boolean hasCorrespondingBinaryOperator(@NotNull JetToken token) {
+    public static boolean hasCorrespondingBinaryOperator(@NotNull KtToken token) {
         return binaryOperatorsMap.containsKey(token);
     }
 
     @NotNull
-    static public JsBinaryOperator getBinaryOperator(@NotNull JetToken token) {
-        assert JetTokens.OPERATIONS.contains(token) : "Token should represent an operation!";
+    static public JsBinaryOperator getBinaryOperator(@NotNull KtToken token) {
+        assert KtTokens.OPERATIONS.contains(token) : "Token should represent an operation!";
         return binaryOperatorsMap.get(token);
     }
 
     @NotNull
-    static public JsUnaryOperator getUnaryOperator(@NotNull JetToken token) {
-        assert JetTokens.OPERATIONS.contains(token) : "Token should represent an operation!";
+    static public JsUnaryOperator getUnaryOperator(@NotNull KtToken token) {
+        assert KtTokens.OPERATIONS.contains(token) : "Token should represent an operation!";
         return unaryOperatorsMap.get(token);
     }
 }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedAssignmentTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedAssignmentTranslator.java
index 768ea0a5e19..1e88ed5414c 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedAssignmentTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedAssignmentTranslator.java
@@ -21,14 +21,14 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.js.translate.callTranslator.CallTranslator;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
-import org.jetbrains.kotlin.psi.JetBinaryExpression;
+import org.jetbrains.kotlin.psi.KtBinaryExpression;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 
 public final class OverloadedAssignmentTranslator extends AssignmentTranslator {
 
     @NotNull
-    public static JsExpression doTranslate(@NotNull JetBinaryExpression expression,
+    public static JsExpression doTranslate(@NotNull KtBinaryExpression expression,
             @NotNull TranslationContext context) {
         return (new OverloadedAssignmentTranslator(expression, context)).translate();
     }
@@ -36,7 +36,7 @@ public final class OverloadedAssignmentTranslator extends AssignmentTranslator {
     @NotNull
     private final ResolvedCall<? extends FunctionDescriptor> resolvedCall;
 
-    private OverloadedAssignmentTranslator(@NotNull JetBinaryExpression expression,
+    private OverloadedAssignmentTranslator(@NotNull KtBinaryExpression expression,
             @NotNull TranslationContext context) {
         super(expression, context);
         resolvedCall = CallUtilKt.getFunctionResolvedCallWithAssert(expression, context.bindingContext());
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedIncrementTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedIncrementTranslator.java
index 11a6b9d367a..3b246cc7238 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedIncrementTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedIncrementTranslator.java
@@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.js.translate.callTranslator.CallTranslator;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
-import org.jetbrains.kotlin.psi.JetUnaryExpression;
+import org.jetbrains.kotlin.psi.KtUnaryExpression;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 
@@ -31,7 +31,7 @@ public final class OverloadedIncrementTranslator extends IncrementTranslator {
     private final ResolvedCall<? extends FunctionDescriptor> resolvedCall;
 
     /*package*/ OverloadedIncrementTranslator(
-            @NotNull JetUnaryExpression expression,
+            @NotNull KtUnaryExpression expression,
             @NotNull TranslationContext context
     ) {
         super(expression, context);
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/UnaryOperationTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/UnaryOperationTranslator.java
index 56681ac4706..520f0a040e1 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/UnaryOperationTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/UnaryOperationTranslator.java
@@ -25,16 +25,16 @@ import org.jetbrains.kotlin.js.translate.callTranslator.CallTranslator;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils;
 import org.jetbrains.kotlin.js.translate.utils.TranslationUtils;
-import org.jetbrains.kotlin.lexer.JetTokens;
-import org.jetbrains.kotlin.psi.JetConstantExpression;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetUnaryExpression;
+import org.jetbrains.kotlin.lexer.KtTokens;
+import org.jetbrains.kotlin.psi.KtConstantExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtUnaryExpression;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import static org.jetbrains.kotlin.js.translate.general.Translation.translateAsExpression;
 import static org.jetbrains.kotlin.js.translate.utils.BindingUtils.getCompileTimeValue;
@@ -49,20 +49,20 @@ public final class UnaryOperationTranslator {
 
     @NotNull
     public static JsExpression translate(
-            @NotNull JetUnaryExpression expression,
+            @NotNull KtUnaryExpression expression,
             @NotNull TranslationContext context
     ) {
         IElementType operationToken = expression.getOperationReference().getReferencedNameElementType();
-        if (operationToken == JetTokens.EXCLEXCL) {
-            JetExpression baseExpression = getBaseExpression(expression);
-            JetType type = BindingContextUtils.getTypeNotNull(context.bindingContext(), baseExpression);
+        if (operationToken == KtTokens.EXCLEXCL) {
+            KtExpression baseExpression = getBaseExpression(expression);
+            KtType type = BindingContextUtils.getTypeNotNull(context.bindingContext(), baseExpression);
             JsExpression translatedExpression = translateAsExpression(baseExpression, context);
             return type.isMarkedNullable() ? sure(translatedExpression, context) : translatedExpression;
         }
 
-        if (operationToken == JetTokens.MINUS) {
-            JetExpression baseExpression = getBaseExpression(expression);
-            if (baseExpression instanceof JetConstantExpression) {
+        if (operationToken == KtTokens.MINUS) {
+            KtExpression baseExpression = getBaseExpression(expression);
+            if (baseExpression instanceof KtConstantExpression) {
                 CompileTimeConstant<?> compileTimeValue = ConstantExpressionEvaluator.getConstant(expression, context.bindingContext());
                 assert compileTimeValue != null : message(expression, "Expression is not compile time value: " + expression.getText() + " ");
                 Object value = getCompileTimeValue(context.bindingContext(), expression, compileTimeValue);
@@ -85,8 +85,8 @@ public final class UnaryOperationTranslator {
         return CallTranslator.translate(context, resolvedCall, baseExpression);
     }
 
-    private static boolean isExclForBinaryEqualLikeExpr(@NotNull JetUnaryExpression expression, @NotNull JsExpression baseExpression) {
-        if (getOperationToken(expression).equals(JetTokens.EXCL)) {
+    private static boolean isExclForBinaryEqualLikeExpr(@NotNull KtUnaryExpression expression, @NotNull JsExpression baseExpression) {
+        if (getOperationToken(expression).equals(KtTokens.EXCL)) {
             if (baseExpression instanceof JsBinaryOperation) {
                 return isEqualLikeOperator(((JsBinaryOperation) baseExpression).getOperator());
             }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AbstractCallExpressionTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AbstractCallExpressionTranslator.java
index 61c26c827f0..e012429cb4c 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AbstractCallExpressionTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AbstractCallExpressionTranslator.java
@@ -22,21 +22,21 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
-import org.jetbrains.kotlin.psi.JetCallExpression;
+import org.jetbrains.kotlin.psi.KtCallExpression;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 
 public abstract class AbstractCallExpressionTranslator extends AbstractTranslator {
 
     @NotNull
-    protected final JetCallExpression expression;
+    protected final KtCallExpression expression;
     @NotNull
     protected final ResolvedCall<? extends FunctionDescriptor> resolvedCall;
     @Nullable
     protected final JsExpression receiver;
 
     protected AbstractCallExpressionTranslator(
-            @NotNull JetCallExpression expression,
+            @NotNull KtCallExpression expression,
             @Nullable JsExpression receiver,
             @NotNull TranslationContext context
     ) {
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AccessTranslationUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AccessTranslationUtils.java
index 9dc4bdfd71e..37e8a93a85e 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AccessTranslationUtils.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/AccessTranslationUtils.java
@@ -33,36 +33,36 @@ public final class AccessTranslationUtils {
     }
 
     @NotNull
-    public static AccessTranslator getAccessTranslator(@NotNull JetExpression referenceExpression,
+    public static AccessTranslator getAccessTranslator(@NotNull KtExpression referenceExpression,
                                                        @NotNull TranslationContext context) {
         return getAccessTranslator(referenceExpression, context, false);
     }
 
     @NotNull
-    public static AccessTranslator getAccessTranslator(@NotNull JetExpression referenceExpression,
+    public static AccessTranslator getAccessTranslator(@NotNull KtExpression referenceExpression,
             @NotNull TranslationContext context, boolean forceOrderOfEvaluation) {
-        assert ((referenceExpression instanceof JetReferenceExpression) ||
-                (referenceExpression instanceof JetQualifiedExpression));
-        if (referenceExpression instanceof JetQualifiedExpression) {
-            return QualifiedExpressionTranslator.getAccessTranslator((JetQualifiedExpression) referenceExpression, context, forceOrderOfEvaluation);
+        assert ((referenceExpression instanceof KtReferenceExpression) ||
+                (referenceExpression instanceof KtQualifiedExpression));
+        if (referenceExpression instanceof KtQualifiedExpression) {
+            return QualifiedExpressionTranslator.getAccessTranslator((KtQualifiedExpression) referenceExpression, context, forceOrderOfEvaluation);
         }
-        if (referenceExpression instanceof JetSimpleNameExpression) {
-            return ReferenceTranslator.getAccessTranslator((JetSimpleNameExpression) referenceExpression, context);
+        if (referenceExpression instanceof KtSimpleNameExpression) {
+            return ReferenceTranslator.getAccessTranslator((KtSimpleNameExpression) referenceExpression, context);
         }
-        assert referenceExpression instanceof JetArrayAccessExpression;
-        return getArrayAccessTranslator((JetArrayAccessExpression) referenceExpression, context, forceOrderOfEvaluation);
+        assert referenceExpression instanceof KtArrayAccessExpression;
+        return getArrayAccessTranslator((KtArrayAccessExpression) referenceExpression, context, forceOrderOfEvaluation);
     }
 
     @NotNull
     private static AccessTranslator getArrayAccessTranslator(
-            @NotNull JetArrayAccessExpression expression,
+            @NotNull KtArrayAccessExpression expression,
             @NotNull TranslationContext context,
             boolean forceOrderOfEvaluation
     ) {
         TranslationContext accessArrayContext;
         if (forceOrderOfEvaluation) {
-            Map<JetExpression, JsExpression> indexesMap = new LinkedHashMap<JetExpression, JsExpression>();
-            for(JetExpression indexExpression : expression.getIndexExpressions()) {
+            Map<KtExpression, JsExpression> indexesMap = new LinkedHashMap<KtExpression, JsExpression>();
+            for(KtExpression indexExpression : expression.getIndexExpressions()) {
                 JsExpression jsIndexExpression = Translation.translateAsExpression(indexExpression, context);
                 if (TranslationUtils.isCacheNeeded(jsIndexExpression)) {
                     TemporaryVariable temporaryVariable = context.declareTemporary(null);
@@ -80,13 +80,13 @@ public final class AccessTranslationUtils {
     }
 
     @NotNull
-    public static CachedAccessTranslator getCachedAccessTranslator(@NotNull JetExpression referenceExpression,
+    public static CachedAccessTranslator getCachedAccessTranslator(@NotNull KtExpression referenceExpression,
                                                                    @NotNull TranslationContext context) {
         return getAccessTranslator(referenceExpression, context).getCached();
     }
 
     @NotNull
-    public static JsExpression translateAsGet(@NotNull JetExpression expression,
+    public static JsExpression translateAsGet(@NotNull KtExpression expression,
                                               @NotNull TranslationContext context) {
         return (getAccessTranslator(expression, context)).translateAsGet();
     }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ArrayAccessTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ArrayAccessTranslator.java
index 4e79ee539f0..c76d873ead9 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ArrayAccessTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ArrayAccessTranslator.java
@@ -26,8 +26,8 @@ import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
 import org.jetbrains.kotlin.js.translate.general.Translation;
 import org.jetbrains.kotlin.js.translate.utils.BindingUtils;
-import org.jetbrains.kotlin.psi.JetArrayAccessExpression;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtArrayAccessExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.psi.ValueArgument;
 import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
@@ -38,15 +38,15 @@ import java.util.*;
 public class ArrayAccessTranslator extends AbstractTranslator implements AccessTranslator {
 
     /*package*/
-    static ArrayAccessTranslator newInstance(@NotNull JetArrayAccessExpression expression,
+    static ArrayAccessTranslator newInstance(@NotNull KtArrayAccessExpression expression,
                                              @NotNull TranslationContext context) {
         return new ArrayAccessTranslator(expression, context);
     }
 
     @NotNull
-    private final JetArrayAccessExpression expression;
+    private final KtArrayAccessExpression expression;
 
-    protected ArrayAccessTranslator(@NotNull JetArrayAccessExpression expression,
+    protected ArrayAccessTranslator(@NotNull KtArrayAccessExpression expression,
                                     @NotNull TranslationContext context) {
         super(context);
         this.expression = expression;
@@ -87,7 +87,7 @@ public class ArrayAccessTranslator extends AbstractTranslator implements AccessT
 
     @NotNull
     protected JsExpression getArrayExpression() {
-        JetExpression arrayExpression = expression.getArrayExpression();
+        KtExpression arrayExpression = expression.getArrayExpression();
         assert arrayExpression != null : "Code with parsing errors shouldn't be translated";
         return Translation.translateAsExpression(arrayExpression, context());
     }
@@ -109,7 +109,7 @@ public class ArrayAccessTranslator extends AbstractTranslator implements AccessT
         ValueArgument valueArgument = ((ExpressionValueArgument) lastArgument).getValueArgument();
         assert valueArgument != null;
 
-        JetExpression element = valueArgument.getArgumentExpression();
+        KtExpression element = valueArgument.getArgumentExpression();
         return context().innerContextWithAliasesForExpressions(Collections.singletonMap(element, toSetTo));
     }
 
@@ -117,16 +117,16 @@ public class ArrayAccessTranslator extends AbstractTranslator implements AccessT
     @Override
     public CachedAccessTranslator getCached() {
         List<TemporaryVariable> temporaries = new ArrayList<TemporaryVariable>();
-        Map<JetExpression, JsExpression> aliases = new HashMap<JetExpression, JsExpression>();
+        Map<KtExpression, JsExpression> aliases = new HashMap<KtExpression, JsExpression>();
 
         TemporaryVariable temporaryArrayExpression = context().declareTemporary(getArrayExpression());
         temporaries.add(temporaryArrayExpression);
 
-        for (JetExpression jetExpression : expression.getIndexExpressions()) {
-            JsExpression jsExpression = Translation.translateAsExpression(jetExpression, context());
+        for (KtExpression ktExpression : expression.getIndexExpressions()) {
+            JsExpression jsExpression = Translation.translateAsExpression(ktExpression, context());
             TemporaryVariable temporaryVariable = context().declareTemporary(jsExpression);
             temporaries.add(temporaryVariable);
-            aliases.put(jetExpression, temporaryVariable.reference());
+            aliases.put(ktExpression, temporaryVariable.reference());
         }
         return new CachedArrayAccessTranslator(expression, context().innerContextWithAliasesForExpressions(aliases),
                                                temporaryArrayExpression, temporaries);
@@ -139,7 +139,7 @@ public class ArrayAccessTranslator extends AbstractTranslator implements AccessT
         private final List<TemporaryVariable> declaredTemporaries;
 
         protected CachedArrayAccessTranslator(
-                @NotNull JetArrayAccessExpression expression,
+                @NotNull KtArrayAccessExpression expression,
                 @NotNull TranslationContext context,
                 @NotNull TemporaryVariable temporaryArrayExpression,
                 @NotNull List<TemporaryVariable> temporaries
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/BackingFieldAccessTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/BackingFieldAccessTranslator.java
index a9d75a58cb5..eb45d037527 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/BackingFieldAccessTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/BackingFieldAccessTranslator.java
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptorKt;
 import org.jetbrains.kotlin.js.translate.context.TemporaryVariable;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
 
 import java.util.Collections;
 import java.util.List;
@@ -38,7 +38,7 @@ public final class BackingFieldAccessTranslator extends AbstractTranslator imple
     private final PropertyDescriptor descriptor;
 
     /*package*/
-    public static BackingFieldAccessTranslator newInstance(@NotNull JetSimpleNameExpression expression,
+    public static BackingFieldAccessTranslator newInstance(@NotNull KtSimpleNameExpression expression,
                                                     @NotNull TranslationContext context) {
         PropertyDescriptor referencedProperty = SyntheticFieldDescriptorKt.getReferencedProperty(
                 getDescriptorForReferenceExpression(context.bindingContext(), expression)
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt
index 35e2fe4b224..ca98d5e977b 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt
@@ -29,10 +29,10 @@ import org.jetbrains.kotlin.js.translate.expression.PatternTranslator
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator
 import org.jetbrains.kotlin.js.translate.general.Translation
 import org.jetbrains.kotlin.js.translate.utils.*
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.ValueArgument
 import org.jetbrains.kotlin.resolve.calls.model.*
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 
 import java.util.ArrayList
 import java.util.Collections
@@ -336,7 +336,7 @@ public class CallArgumentTranslator private constructor(
 
 }
 
-private fun Map<TypeParameterDescriptor, JetType>.addReifiedTypeArgsTo(
+private fun Map<TypeParameterDescriptor, KtType>.addReifiedTypeArgsTo(
         info: CallArgumentTranslator.ArgumentsInfo,
         context: TranslationContext
 ): CallArgumentTranslator.ArgumentsInfo {
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallExpressionTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallExpressionTranslator.java
index a557646fe98..c03a2756577 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallExpressionTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallExpressionTranslator.java
@@ -25,8 +25,8 @@ import org.jetbrains.kotlin.js.parser.ParserUtilsKt;
 import org.jetbrains.kotlin.js.resolve.diagnostics.JsCallChecker;
 import org.jetbrains.kotlin.js.translate.callTranslator.CallTranslator;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
-import org.jetbrains.kotlin.psi.JetCallExpression;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtCallExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.psi.ValueArgument;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
@@ -43,7 +43,7 @@ public final class CallExpressionTranslator extends AbstractCallExpressionTransl
 
     @NotNull
     public static JsNode translate(
-            @NotNull JetCallExpression expression,
+            @NotNull KtCallExpression expression,
             @Nullable JsExpression receiver,
             @NotNull TranslationContext context
     ) {
@@ -62,7 +62,7 @@ public final class CallExpressionTranslator extends AbstractCallExpressionTransl
         return callExpression;
     }
 
-    public static boolean shouldBeInlined(@NotNull JetCallExpression expression, @NotNull TranslationContext context) {
+    public static boolean shouldBeInlined(@NotNull KtCallExpression expression, @NotNull TranslationContext context) {
         if (!context.getConfig().isInlineEnabled()) return false;
 
         CallableDescriptor descriptor = getFunctionDescriptor(expression, context);
@@ -83,7 +83,7 @@ public final class CallExpressionTranslator extends AbstractCallExpressionTransl
     }
 
     private CallExpressionTranslator(
-            @NotNull JetCallExpression expression,
+            @NotNull KtCallExpression expression,
             @Nullable JsExpression receiver,
             @NotNull TranslationContext context
     ) {
@@ -98,7 +98,7 @@ public final class CallExpressionTranslator extends AbstractCallExpressionTransl
     @NotNull
     private JsNode translateJsCode() {
         List<? extends ValueArgument> arguments = expression.getValueArguments();
-        JetExpression argumentExpression = arguments.get(0).getArgumentExpression();
+        KtExpression argumentExpression = arguments.get(0).getArgumentExpression();
         assert argumentExpression != null;
 
         List<JsStatement> statements = parseJsCode(argumentExpression);
@@ -119,7 +119,7 @@ public final class CallExpressionTranslator extends AbstractCallExpressionTransl
     }
 
     @NotNull
-    private List<JsStatement> parseJsCode(@NotNull JetExpression jsCodeExpression) {
+    private List<JsStatement> parseJsCode(@NotNull KtExpression jsCodeExpression) {
         String jsCode = JsCallChecker.extractStringValue(getConstant(jsCodeExpression, context().bindingContext()));
 
         assert jsCode != null : "jsCode must be compile time string " + jsCodeExpression.getText();
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallableReferenceTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallableReferenceTranslator.kt
index 189fc399f85..816fc5018e0 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallableReferenceTranslator.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallableReferenceTranslator.kt
@@ -25,13 +25,13 @@ import org.jetbrains.kotlin.js.translate.context.TranslationContext
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils
 import org.jetbrains.kotlin.js.translate.utils.BindingUtils
 import org.jetbrains.kotlin.js.translate.utils.JsDescriptorUtils
-import org.jetbrains.kotlin.psi.JetCallableReferenceExpression
+import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import java.util.ArrayList
 
 object CallableReferenceTranslator {
 
-    fun translate(expression: JetCallableReferenceExpression, context: TranslationContext): JsExpression {
+    fun translate(expression: KtCallableReferenceExpression, context: TranslationContext): JsExpression {
         val descriptor = BindingUtils.getDescriptorForReferenceExpression(context.bindingContext(), expression.getCallableReference())
         return when (descriptor) {
             is PropertyDescriptor ->
@@ -43,12 +43,12 @@ object CallableReferenceTranslator {
         }
     }
 
-    private fun reportNotSupported(context: TranslationContext, expression: JetCallableReferenceExpression): JsExpression {
+    private fun reportNotSupported(context: TranslationContext, expression: KtCallableReferenceExpression): JsExpression {
         context.bindingTrace().report(ErrorsJs.REFERENCE_TO_BUILTIN_MEMBERS_NOT_SUPPORTED.on(expression, expression))
         return context.getEmptyExpression()
     }
 
-    private fun translateForFunction(descriptor: FunctionDescriptor, context: TranslationContext, expression: JetCallableReferenceExpression): JsExpression {
+    private fun translateForFunction(descriptor: FunctionDescriptor, context: TranslationContext, expression: KtCallableReferenceExpression): JsExpression {
         return when {
         // TODO Support for callable reference to builtin functions and members
             JsDescriptorUtils.isBuiltin(descriptor) ->
@@ -64,7 +64,7 @@ object CallableReferenceTranslator {
         }
     }
 
-    private fun translateForProperty(descriptor: PropertyDescriptor, context: TranslationContext, expression: JetCallableReferenceExpression): JsExpression {
+    private fun translateForProperty(descriptor: PropertyDescriptor, context: TranslationContext, expression: KtCallableReferenceExpression): JsExpression {
         return when {
         // TODO Support for callable reference to builtin properties
             JsDescriptorUtils.isBuiltin(descriptor) ->
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CompanionObjectAccessTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CompanionObjectAccessTranslator.java
index 7478d101630..a9db236503c 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CompanionObjectAccessTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CompanionObjectAccessTranslator.java
@@ -26,8 +26,8 @@ import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
 import org.jetbrains.kotlin.js.translate.intrinsic.objects.ObjectIntrinsic;
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils;
-import org.jetbrains.kotlin.psi.JetReferenceExpression;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
+import org.jetbrains.kotlin.psi.KtReferenceExpression;
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
 
 import java.util.Collections;
 import java.util.List;
@@ -40,7 +40,7 @@ import static org.jetbrains.kotlin.resolve.DescriptorUtils.isNonCompanionObject;
 public class CompanionObjectAccessTranslator extends AbstractTranslator implements CachedAccessTranslator {
     @NotNull
     /*package*/ static CompanionObjectAccessTranslator newInstance(
-            @NotNull JetSimpleNameExpression expression,
+            @NotNull KtSimpleNameExpression expression,
             @NotNull TranslationContext context
     ) {
         DeclarationDescriptor referenceDescriptor = getDescriptorForReferenceExpression(context.bindingContext(), expression);
@@ -49,7 +49,7 @@ public class CompanionObjectAccessTranslator extends AbstractTranslator implemen
     }
 
     /*package*/ static boolean isCompanionObjectReference(
-            @NotNull JetReferenceExpression expression,
+            @NotNull KtReferenceExpression expression,
             @NotNull TranslationContext context
     ) {
         DeclarationDescriptor descriptor = getDescriptorForReferenceExpression(context.bindingContext(), expression);
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/QualifiedExpressionTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/QualifiedExpressionTranslator.java
index 8a7a1709de6..d210d02de67 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/QualifiedExpressionTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/QualifiedExpressionTranslator.java
@@ -39,7 +39,7 @@ public final class QualifiedExpressionTranslator {
     }
 
     @NotNull
-    public static AccessTranslator getAccessTranslator(@NotNull JetQualifiedExpression expression,
+    public static AccessTranslator getAccessTranslator(@NotNull KtQualifiedExpression expression,
                                                        @NotNull TranslationContext context, boolean forceOrderOfEvaluation) {
         JsExpression receiver = translateReceiver(expression, context);
         if (forceOrderOfEvaluation && receiver != null) {
@@ -52,30 +52,30 @@ public final class QualifiedExpressionTranslator {
 
     @NotNull
     public static JsNode translateQualifiedExpression(
-            @NotNull JetQualifiedExpression expression,
+            @NotNull KtQualifiedExpression expression,
             @NotNull TranslationContext context
     ) {
         JsExpression receiver = translateReceiver(expression, context);
-        JetExpression selector = getSelector(expression);
+        KtExpression selector = getSelector(expression);
         return dispatchToCorrectTranslator(receiver, selector, context);
     }
 
     @NotNull
     private static JsNode dispatchToCorrectTranslator(
             @Nullable JsExpression receiver,
-            @NotNull JetExpression selector,
+            @NotNull KtExpression selector,
             @NotNull TranslationContext context
     ) {
         if (ReferenceTranslator.canBePropertyAccess(selector, context)) {
-            assert selector instanceof JetSimpleNameExpression : "Selectors for properties must be simple names.";
-            return VariableAccessTranslator.newInstance(context, (JetSimpleNameExpression)selector, receiver).translateAsGet();
+            assert selector instanceof KtSimpleNameExpression : "Selectors for properties must be simple names.";
+            return VariableAccessTranslator.newInstance(context, (KtSimpleNameExpression)selector, receiver).translateAsGet();
         }
-        if (selector instanceof JetCallExpression) {
+        if (selector instanceof KtCallExpression) {
             return invokeCallExpressionTranslator(receiver, selector, context);
         }
         //TODO: never get there
-        if (selector instanceof JetSimpleNameExpression) {
-            return ReferenceTranslator.translateSimpleNameWithQualifier((JetSimpleNameExpression) selector, receiver, context);
+        if (selector instanceof KtSimpleNameExpression) {
+            return ReferenceTranslator.translateSimpleNameWithQualifier((KtSimpleNameExpression) selector, receiver, context);
         }
         throw new AssertionError("Unexpected qualified expression: " + selector.getText());
     }
@@ -83,20 +83,20 @@ public final class QualifiedExpressionTranslator {
     @NotNull
     private static JsNode invokeCallExpressionTranslator(
             @Nullable JsExpression receiver,
-            @NotNull JetExpression selector,
+            @NotNull KtExpression selector,
             @NotNull TranslationContext context
     ) {
         try {
-            return CallExpressionTranslator.translate((JetCallExpression) selector, receiver, context);
+            return CallExpressionTranslator.translate((KtCallExpression) selector, receiver, context);
         } catch (RuntimeException e) {
             throw  ErrorReportingUtils.reportErrorWithLocation(selector, e);
         }
     }
 
     @Nullable
-    private static JsExpression translateReceiver(@NotNull JetQualifiedExpression expression,
+    private static JsExpression translateReceiver(@NotNull KtQualifiedExpression expression,
                                                   @NotNull TranslationContext context) {
-        JetExpression receiverExpression = expression.getReceiverExpression();
+        KtExpression receiverExpression = expression.getReceiverExpression();
         if (isFullQualifierForExpression(receiverExpression, context)) {
             return null;
         }
@@ -104,19 +104,19 @@ public final class QualifiedExpressionTranslator {
     }
 
     //TODO: prove correctness
-    private static boolean isFullQualifierForExpression(@Nullable JetExpression receiverExpression, @NotNull TranslationContext context) {
+    private static boolean isFullQualifierForExpression(@Nullable KtExpression receiverExpression, @NotNull TranslationContext context) {
         if (receiverExpression == null) {
             return false;
         }
-        if (receiverExpression instanceof JetReferenceExpression) {
+        if (receiverExpression instanceof KtReferenceExpression) {
             DeclarationDescriptor descriptorForReferenceExpression =
-                getDescriptorForReferenceExpression(context.bindingContext(), (JetReferenceExpression)receiverExpression);
+                getDescriptorForReferenceExpression(context.bindingContext(), (KtReferenceExpression)receiverExpression);
             if (descriptorForReferenceExpression instanceof PackageViewDescriptor) {
                 return true;
             }
         }
-        if (receiverExpression instanceof JetQualifiedExpression) {
-            return isFullQualifierForExpression(((JetQualifiedExpression)receiverExpression).getSelectorExpression(), context);
+        if (receiverExpression instanceof KtQualifiedExpression) {
+            return isFullQualifierForExpression(((KtQualifiedExpression)receiverExpression).getSelectorExpression(), context);
         }
         return false;
     }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ReferenceAccessTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ReferenceAccessTranslator.java
index d22c536b8ef..cdb9fb22ca5 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ReferenceAccessTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ReferenceAccessTranslator.java
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.js.translate.context.TemporaryVariable;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
 
 import java.util.Collections;
 import java.util.List;
@@ -34,7 +34,7 @@ import static org.jetbrains.kotlin.js.translate.utils.BindingUtils.getDescriptor
 public final class ReferenceAccessTranslator extends AbstractTranslator implements CachedAccessTranslator {
 
     @NotNull
-    /*package*/ static ReferenceAccessTranslator newInstance(@NotNull JetSimpleNameExpression expression,
+    /*package*/ static ReferenceAccessTranslator newInstance(@NotNull KtSimpleNameExpression expression,
                                                              @NotNull TranslationContext context) {
         DeclarationDescriptor referenceDescriptor = getDescriptorForReferenceExpression(context.bindingContext(), expression);
         assert referenceDescriptor != null : "JetSimpleName expression must reference a descriptor " + expression.getText();
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ReferenceTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ReferenceTranslator.java
index e45d25282af..a26a9fbf78a 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ReferenceTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ReferenceTranslator.java
@@ -20,20 +20,19 @@ import com.google.dart.compiler.backend.js.ast.JsExpression;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor;
 import org.jetbrains.kotlin.js.translate.context.Namer;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils;
 import org.jetbrains.kotlin.js.translate.utils.BindingUtils;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetQualifiedExpression;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtQualifiedExpression;
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 
 import static org.jetbrains.kotlin.js.translate.utils.BindingUtils.getDescriptorForReferenceExpression;
 import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.setQualifier;
 import static org.jetbrains.kotlin.js.translate.utils.PsiUtils.getSelectorAsSimpleName;
-import static org.jetbrains.kotlin.psi.JetPsiUtil.isBackingFieldReference;
+import static org.jetbrains.kotlin.psi.KtPsiUtil.isBackingFieldReference;
 
 public final class ReferenceTranslator {
 
@@ -41,14 +40,14 @@ public final class ReferenceTranslator {
     }
 
     @NotNull
-    public static JsExpression translateSimpleName(@NotNull JetSimpleNameExpression expression,
+    public static JsExpression translateSimpleName(@NotNull KtSimpleNameExpression expression,
             @NotNull TranslationContext context) {
         return getAccessTranslator(expression, context).translateAsGet();
     }
 
     @NotNull
     public static JsExpression translateSimpleNameWithQualifier(
-            @NotNull JetSimpleNameExpression expression,
+            @NotNull KtSimpleNameExpression expression,
             @Nullable JsExpression qualifier,
             @NotNull TranslationContext context
     ) {
@@ -95,13 +94,13 @@ public final class ReferenceTranslator {
     }
 
     @NotNull
-    public static AccessTranslator getAccessTranslator(@NotNull JetSimpleNameExpression referenceExpression,
+    public static AccessTranslator getAccessTranslator(@NotNull KtSimpleNameExpression referenceExpression,
             @NotNull TranslationContext context) {
         return getAccessTranslator(referenceExpression, null, context);
     }
 
     @NotNull
-    public static AccessTranslator getAccessTranslator(@NotNull JetSimpleNameExpression referenceExpression,
+    public static AccessTranslator getAccessTranslator(@NotNull KtSimpleNameExpression referenceExpression,
             @Nullable JsExpression receiver,
             @NotNull TranslationContext context) {
         if (isBackingFieldReference(referenceExpression, getDescriptorForReferenceExpression(context.bindingContext(), referenceExpression))) {
@@ -116,13 +115,13 @@ public final class ReferenceTranslator {
         return ReferenceAccessTranslator.newInstance(referenceExpression, context);
     }
 
-    public static boolean canBePropertyAccess(@NotNull JetExpression expression, @NotNull TranslationContext context) {
-        JetSimpleNameExpression simpleNameExpression = null;
-        if (expression instanceof JetQualifiedExpression) {
-            simpleNameExpression = getSelectorAsSimpleName((JetQualifiedExpression) expression);
+    public static boolean canBePropertyAccess(@NotNull KtExpression expression, @NotNull TranslationContext context) {
+        KtSimpleNameExpression simpleNameExpression = null;
+        if (expression instanceof KtQualifiedExpression) {
+            simpleNameExpression = getSelectorAsSimpleName((KtQualifiedExpression) expression);
         }
-        else if (expression instanceof JetSimpleNameExpression) {
-            simpleNameExpression = (JetSimpleNameExpression) expression;
+        else if (expression instanceof KtSimpleNameExpression) {
+            simpleNameExpression = (KtSimpleNameExpression) expression;
         }
 
         if (simpleNameExpression == null) return false;
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/VariableAccessTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/VariableAccessTranslator.java
index 6c15c67211b..54ec96273c0 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/VariableAccessTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/VariableAccessTranslator.java
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.js.translate.callTranslator.CallTranslator;
 import org.jetbrains.kotlin.js.translate.context.TemporaryVariable;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
-import org.jetbrains.kotlin.psi.JetReferenceExpression;
+import org.jetbrains.kotlin.psi.KtReferenceExpression;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall;
@@ -35,7 +35,7 @@ import java.util.List;
 public class VariableAccessTranslator extends AbstractTranslator implements AccessTranslator {
     public static VariableAccessTranslator newInstance(
             @NotNull TranslationContext context,
-            @NotNull JetReferenceExpression referenceExpression,
+            @NotNull KtReferenceExpression referenceExpression,
             @Nullable JsExpression receiver
     ) {
         ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCallWithAssert(referenceExpression, context.bindingContext());
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/test/JSTestGenerator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/test/JSTestGenerator.java
index e9d9d83edf9..7c62530044a 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/test/JSTestGenerator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/test/JSTestGenerator.java
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.js.translate.callTranslator.CallTranslator;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.JetTestFunctionDetector;
 import org.jetbrains.kotlin.js.translate.reference.ReferenceTranslator;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 
 import java.util.Collection;
@@ -39,7 +39,7 @@ public final class JSTestGenerator {
     }
 
     public static void generateTestCalls(@NotNull TranslationContext context,
-            @NotNull Collection<JetFile> files, @NotNull JSTester tester) {
+            @NotNull Collection<KtFile> files, @NotNull JSTester tester) {
         List<FunctionDescriptor> functionDescriptors = JetTestFunctionDetector.getTestFunctionDescriptors(context.bindingContext(), files);
         doGenerateTestCalls(functionDescriptors, context, tester);
     }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/BindingUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/BindingUtils.java
index 44b256d5ee6..db7610a075d 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/BindingUtils.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/BindingUtils.java
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 
 import java.util.List;
@@ -60,56 +60,56 @@ public final class BindingUtils {
 
     @NotNull
     public static ClassDescriptor getClassDescriptor(@NotNull BindingContext context,
-            @NotNull JetClassOrObject declaration) {
+            @NotNull KtClassOrObject declaration) {
         return BindingContextUtils.getNotNull(context, BindingContext.CLASS, declaration);
     }
 
     @NotNull
     public static FunctionDescriptor getFunctionDescriptor(@NotNull BindingContext context,
-            @NotNull JetDeclarationWithBody declaration) {
+            @NotNull KtDeclarationWithBody declaration) {
         return getDescriptorForExpression(context, declaration, FunctionDescriptor.class);
     }
 
     @NotNull
     public static PropertyDescriptor getPropertyDescriptor(@NotNull BindingContext context,
-            @NotNull JetProperty declaration) {
+            @NotNull KtProperty declaration) {
         return getDescriptorForExpression(context, declaration, PropertyDescriptor.class);
     }
 
     @NotNull
-    private static JetParameter getParameterForDescriptor(@NotNull ValueParameterDescriptor descriptor) {
+    private static KtParameter getParameterForDescriptor(@NotNull ValueParameterDescriptor descriptor) {
         PsiElement result = DescriptorToSourceUtils.descriptorToDeclaration(descriptor);
-        assert result instanceof JetParameter : message(descriptor, "ValueParameterDescriptor should have corresponding JetParameter");
-        return (JetParameter) result;
+        assert result instanceof KtParameter : message(descriptor, "ValueParameterDescriptor should have corresponding JetParameter");
+        return (KtParameter) result;
     }
 
-    public static boolean hasAncestorClass(@NotNull BindingContext context, @NotNull JetClassOrObject classDeclaration) {
+    public static boolean hasAncestorClass(@NotNull BindingContext context, @NotNull KtClassOrObject classDeclaration) {
         ClassDescriptor classDescriptor = getClassDescriptor(context, classDeclaration);
         List<ClassDescriptor> superclassDescriptors = DescriptorUtils.getSuperclassDescriptors(classDescriptor);
         return (JsDescriptorUtils.findAncestorClass(superclassDescriptors) != null);
     }
 
     @NotNull
-    public static JetType getTypeByReference(@NotNull BindingContext context,
-            @NotNull JetTypeReference typeReference) {
+    public static KtType getTypeByReference(@NotNull BindingContext context,
+            @NotNull KtTypeReference typeReference) {
         return BindingContextUtils.getNotNull(context, BindingContext.TYPE, typeReference);
     }
 
     @NotNull
     public static ClassDescriptor getClassDescriptorForTypeReference(@NotNull BindingContext context,
-            @NotNull JetTypeReference typeReference) {
+            @NotNull KtTypeReference typeReference) {
         return DescriptorUtils.getClassDescriptorForType(getTypeByReference(context, typeReference));
     }
 
     @Nullable
     public static PropertyDescriptor getPropertyDescriptorForConstructorParameter(@NotNull BindingContext context,
-            @NotNull JetParameter parameter) {
+            @NotNull KtParameter parameter) {
         return context.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, parameter);
     }
 
     @Nullable
     public static DeclarationDescriptor getDescriptorForReferenceExpression(@NotNull BindingContext context,
-            @NotNull JetReferenceExpression reference) {
+            @NotNull KtReferenceExpression reference) {
         if (BindingContextUtils.isExpressionWithValidReference(reference, context)) {
             return BindingContextUtils.getNotNull(context, BindingContext.REFERENCE_TARGET, reference);
         }
@@ -118,20 +118,20 @@ public final class BindingUtils {
 
     @Nullable
     public static DeclarationDescriptor getNullableDescriptorForReferenceExpression(@NotNull BindingContext context,
-            @NotNull JetReferenceExpression reference) {
+            @NotNull KtReferenceExpression reference) {
         return context.get(BindingContext.REFERENCE_TARGET, reference);
     }
 
-    public static boolean isVariableReassignment(@NotNull BindingContext context, @NotNull JetExpression expression) {
+    public static boolean isVariableReassignment(@NotNull BindingContext context, @NotNull KtExpression expression) {
         return BindingContextUtils.getNotNull(context, BindingContext.VARIABLE_REASSIGNMENT, expression);
     }
 
     @Nullable
     public static CallableDescriptor getCallableDescriptorForOperationExpression(
             @NotNull BindingContext context,
-            @NotNull JetOperationExpression expression
+            @NotNull KtOperationExpression expression
     ) {
-        JetSimpleNameExpression operationReference = expression.getOperationReference();
+        KtSimpleNameExpression operationReference = expression.getOperationReference();
         DeclarationDescriptor descriptorForReferenceExpression =
                 getNullableDescriptorForReferenceExpression(context, operationReference);
 
@@ -149,7 +149,7 @@ public final class BindingUtils {
     }
 
     @Nullable
-    public static Object getCompileTimeValue(@NotNull BindingContext context, @NotNull JetExpression expression) {
+    public static Object getCompileTimeValue(@NotNull BindingContext context, @NotNull KtExpression expression) {
         CompileTimeConstant<?> compileTimeValue = ConstantExpressionEvaluator.getConstant(expression, context);
         if (compileTimeValue != null) {
             return getCompileTimeValue(context, expression, compileTimeValue);
@@ -158,17 +158,17 @@ public final class BindingUtils {
     }
 
     @Nullable
-    public static Object getCompileTimeValue(@NotNull BindingContext context, @NotNull JetExpression expression, @NotNull CompileTimeConstant<?> constant) {
-        JetType expectedType = context.getType(expression);
+    public static Object getCompileTimeValue(@NotNull BindingContext context, @NotNull KtExpression expression, @NotNull CompileTimeConstant<?> constant) {
+        KtType expectedType = context.getType(expression);
         return constant.getValue(expectedType == null ? TypeUtils.NO_EXPECTED_TYPE : expectedType);
     }
 
     @NotNull
-    public static JetExpression getDefaultArgument(@NotNull ValueParameterDescriptor parameterDescriptor) {
+    public static KtExpression getDefaultArgument(@NotNull ValueParameterDescriptor parameterDescriptor) {
         ValueParameterDescriptor descriptorWhichDeclaresDefaultValue =
                 getOriginalDescriptorWhichDeclaresDefaultValue(parameterDescriptor);
-        JetParameter psiParameter = getParameterForDescriptor(descriptorWhichDeclaresDefaultValue);
-        JetExpression defaultValue = psiParameter.getDefaultValue();
+        KtParameter psiParameter = getParameterForDescriptor(descriptorWhichDeclaresDefaultValue);
+        KtExpression defaultValue = psiParameter.getDefaultValue();
         assert defaultValue != null : message(parameterDescriptor, "No default value found in PSI");
         return defaultValue;
     }
@@ -187,31 +187,31 @@ public final class BindingUtils {
 
     @NotNull
     public static ResolvedCall<FunctionDescriptor> getIteratorFunction(@NotNull BindingContext context,
-            @NotNull JetExpression rangeExpression) {
+            @NotNull KtExpression rangeExpression) {
         return BindingContextUtils.getNotNull(context, BindingContext.LOOP_RANGE_ITERATOR_RESOLVED_CALL, rangeExpression);
     }
 
     @NotNull
     public static ResolvedCall<FunctionDescriptor> getNextFunction(@NotNull BindingContext context,
-            @NotNull JetExpression rangeExpression) {
+            @NotNull KtExpression rangeExpression) {
         return BindingContextUtils.getNotNull(context, BindingContext.LOOP_RANGE_NEXT_RESOLVED_CALL, rangeExpression);
     }
 
     @NotNull
     public static ResolvedCall<FunctionDescriptor> getHasNextCallable(@NotNull BindingContext context,
-            @NotNull JetExpression rangeExpression) {
+            @NotNull KtExpression rangeExpression) {
         return BindingContextUtils.getNotNull(context, BindingContext.LOOP_RANGE_HAS_NEXT_RESOLVED_CALL, rangeExpression);
     }
 
     @NotNull
-    public static JetType getTypeForExpression(@NotNull BindingContext context,
-            @NotNull JetExpression expression) {
+    public static KtType getTypeForExpression(@NotNull BindingContext context,
+            @NotNull KtExpression expression) {
         return BindingContextUtils.getTypeNotNull(context, expression);
     }
 
     @NotNull
     public static ResolvedCall<FunctionDescriptor> getResolvedCallForArrayAccess(@NotNull BindingContext context,
-            @NotNull JetArrayAccessExpression arrayAccessExpression,
+            @NotNull KtArrayAccessExpression arrayAccessExpression,
             boolean isGet) {
         return BindingContextUtils.getNotNull(context, isGet ? INDEXED_LVALUE_GET : INDEXED_LVALUE_SET, arrayAccessExpression);
     }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/ErrorReportingUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/ErrorReportingUtils.java
index d4a0a3075ec..5a261d1969f 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/ErrorReportingUtils.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/ErrorReportingUtils.java
@@ -20,14 +20,14 @@ import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 
 public final class ErrorReportingUtils {
     private ErrorReportingUtils() {
     }
 
     @NotNull
-    public static RuntimeException reportErrorWithLocation(@NotNull JetExpression selector, @NotNull RuntimeException e) {
+    public static RuntimeException reportErrorWithLocation(@NotNull KtExpression selector, @NotNull RuntimeException e) {
         return reportErrorWithLocation(e, DiagnosticUtils.atLocation(selector));
     }
 
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/FunctionBodyTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/FunctionBodyTranslator.java
index 3a61f4fe279..8c7455e6967 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/FunctionBodyTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/FunctionBodyTranslator.java
@@ -25,10 +25,10 @@ import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator;
 import org.jetbrains.kotlin.js.translate.general.Translation;
 import org.jetbrains.kotlin.js.translate.utils.mutator.Mutator;
-import org.jetbrains.kotlin.psi.JetDeclarationWithBody;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtDeclarationWithBody;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -41,7 +41,7 @@ public final class FunctionBodyTranslator extends AbstractTranslator {
 
     @NotNull
     public static JsBlock translateFunctionBody(@NotNull FunctionDescriptor descriptor,
-                                                @NotNull JetDeclarationWithBody declarationWithBody,
+                                                @NotNull KtDeclarationWithBody declarationWithBody,
                                                 @NotNull TranslationContext functionBodyContext) {
         return (new FunctionBodyTranslator(descriptor, declarationWithBody, functionBodyContext)).translate();
     }
@@ -56,7 +56,7 @@ public final class FunctionBodyTranslator extends AbstractTranslator {
             if (!DescriptorUtilsKt.hasDefaultValue(valueParameter)) continue;
 
             JsNameRef jsNameRef = functionBodyContext.getNameForDescriptor(valueParameter).makeRef();
-            JetExpression defaultArgument = getDefaultArgument(valueParameter);
+            KtExpression defaultArgument = getDefaultArgument(valueParameter);
             JsBlock defaultArgBlock = new JsBlock();
             JsExpression defaultValue = Translation.translateAsExpression(defaultArgument, functionBodyContext, defaultArgBlock);
             JsStatement assignStatement = assignment(jsNameRef, defaultValue).makeStmt();
@@ -72,10 +72,10 @@ public final class FunctionBodyTranslator extends AbstractTranslator {
     @NotNull
     private final FunctionDescriptor descriptor;
     @NotNull
-    private final JetDeclarationWithBody declaration;
+    private final KtDeclarationWithBody declaration;
 
     private FunctionBodyTranslator(@NotNull FunctionDescriptor descriptor,
-                                   @NotNull JetDeclarationWithBody declaration,
+                                   @NotNull KtDeclarationWithBody declaration,
                                    @NotNull TranslationContext context) {
         super(context);
         this.descriptor = descriptor;
@@ -84,7 +84,7 @@ public final class FunctionBodyTranslator extends AbstractTranslator {
 
     @NotNull
     private JsBlock translate() {
-        JetExpression jetBodyExpression = declaration.getBodyExpression();
+        KtExpression jetBodyExpression = declaration.getBodyExpression();
         assert jetBodyExpression != null : "Cannot translate a body of an abstract function.";
         JsBlock jsBlock = new JsBlock(setDefaultValueForArguments(descriptor, context()));
         jsBlock.getStatements().addAll(mayBeWrapWithReturn(Translation.translateExpression(jetBodyExpression, context(), jsBlock)).getStatements());
@@ -100,7 +100,7 @@ public final class FunctionBodyTranslator extends AbstractTranslator {
     }
 
     private boolean mustAddReturnToGeneratedFunctionBody() {
-        JetType functionReturnType = descriptor.getReturnType();
+        KtType functionReturnType = descriptor.getReturnType();
         assert functionReturnType != null : "Function return typed type must be resolved.";
         return (!declaration.hasBlockBody()) && (!KotlinBuiltIns.isUnit(functionReturnType));
     }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsDescriptorUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsDescriptorUtils.java
index 9a9e460e6ad..b9d7528c582 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsDescriptorUtils.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/JsDescriptorUtils.java
@@ -27,11 +27,11 @@ import org.jetbrains.kotlin.js.config.LibrarySourcesConfig;
 import org.jetbrains.kotlin.js.descriptorUtils.DescriptorUtilsKt;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
 
 import java.util.Collection;
@@ -80,11 +80,11 @@ public final class JsDescriptorUtils {
     }
 
     @NotNull
-    public static List<JetType> getSupertypesWithoutFakes(ClassDescriptor descriptor) {
-        Collection<JetType> supertypes = descriptor.getTypeConstructor().getSupertypes();
-        return ContainerUtil.filter(supertypes, new Condition<JetType>() {
+    public static List<KtType> getSupertypesWithoutFakes(ClassDescriptor descriptor) {
+        Collection<KtType> supertypes = descriptor.getTypeConstructor().getSupertypes();
+        return ContainerUtil.filter(supertypes, new Condition<KtType>() {
             @Override
-            public boolean value(JetType type) {
+            public boolean value(KtType type) {
                 ClassDescriptor classDescriptor = getClassDescriptorForType(type);
 
                 return !FAKE_CLASSES.contains(getFqNameSafe(classDescriptor).asString()) &&
@@ -160,8 +160,8 @@ public final class JsDescriptorUtils {
     }
 
     @Nullable
-    public static Name getNameIfStandardType(@NotNull JetExpression expression, @NotNull TranslationContext context) {
-        JetType type = context.bindingContext().getType(expression);
+    public static Name getNameIfStandardType(@NotNull KtExpression expression, @NotNull TranslationContext context) {
+        KtType type = context.bindingContext().getType(expression);
         return type != null ? DescriptorUtilsKt.getNameIfStandardType(type) : null;
     }
 
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/ManglingUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/ManglingUtils.java
index 5e71ee1a191..a097769a3cb 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/ManglingUtils.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/ManglingUtils.java
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.name.FqNameUnsafe;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 
 import java.util.*;
 
@@ -154,7 +154,7 @@ public class ManglingUtils {
     private static String getSimpleMangledName(@NotNull CallableMemberDescriptor descriptor) {
         DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration();
 
-        JetScope jetScope = null;
+        KtScope jetScope = null;
 
         String nameToCompare = descriptor.getName().asString();
 
@@ -175,7 +175,7 @@ public class ManglingUtils {
         if (jetScope != null) {
             final String finalNameToCompare = nameToCompare;
 
-            Collection<DeclarationDescriptor> declarations = jetScope.getDescriptors(DescriptorKindFilter.CALLABLES, JetScope.Companion.getALL_NAME_FILTER());
+            Collection<DeclarationDescriptor> declarations = jetScope.getDescriptors(DescriptorKindFilter.CALLABLES, KtScope.Companion.getALL_NAME_FILTER());
             List<CallableDescriptor> overloadedFunctions =
                     CollectionsKt.flatMap(declarations, new Function1<DeclarationDescriptor, Iterable<? extends CallableDescriptor>>() {
                 @Override
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/PsiUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/PsiUtils.java
index eee10a906cf..4419779628b 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/PsiUtils.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/PsiUtils.java
@@ -21,8 +21,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
-import org.jetbrains.kotlin.lexer.JetToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtToken;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
@@ -37,103 +37,103 @@ public final class PsiUtils {
     }
 
     @Nullable
-    public static JetSimpleNameExpression getSimpleName(@NotNull JetExpression expression) {
-        if (expression instanceof JetSimpleNameExpression) {
-            return (JetSimpleNameExpression) expression;
+    public static KtSimpleNameExpression getSimpleName(@NotNull KtExpression expression) {
+        if (expression instanceof KtSimpleNameExpression) {
+            return (KtSimpleNameExpression) expression;
         }
 
-        if (expression instanceof JetQualifiedExpression) {
-            return getSelectorAsSimpleName((JetQualifiedExpression) expression);
+        if (expression instanceof KtQualifiedExpression) {
+            return getSelectorAsSimpleName((KtQualifiedExpression) expression);
         }
 
         return null;
     }
 
     @Nullable
-    public static JetSimpleNameExpression getSelectorAsSimpleName(@NotNull JetQualifiedExpression expression) {
-        JetExpression selectorExpression = getSelector(expression);
-        if (!(selectorExpression instanceof JetSimpleNameExpression)) {
+    public static KtSimpleNameExpression getSelectorAsSimpleName(@NotNull KtQualifiedExpression expression) {
+        KtExpression selectorExpression = getSelector(expression);
+        if (!(selectorExpression instanceof KtSimpleNameExpression)) {
             return null;
         }
-        return (JetSimpleNameExpression) selectorExpression;
+        return (KtSimpleNameExpression) selectorExpression;
     }
 
     @NotNull
-    public static JetExpression getSelector(@NotNull JetQualifiedExpression expression) {
-        JetExpression selectorExpression = expression.getSelectorExpression();
+    public static KtExpression getSelector(@NotNull KtQualifiedExpression expression) {
+        KtExpression selectorExpression = expression.getSelectorExpression();
         assert selectorExpression != null : "Selector should not be null.";
         return selectorExpression;
     }
 
     @NotNull
-    public static JetSimpleNameExpression getNotNullSimpleNameSelector(@NotNull JetQualifiedExpression expression) {
-        JetSimpleNameExpression selectorAsSimpleName = getSelectorAsSimpleName(expression);
+    public static KtSimpleNameExpression getNotNullSimpleNameSelector(@NotNull KtQualifiedExpression expression) {
+        KtSimpleNameExpression selectorAsSimpleName = getSelectorAsSimpleName(expression);
         assert selectorAsSimpleName != null;
         return selectorAsSimpleName;
     }
 
     @NotNull
-    public static JetToken getOperationToken(@NotNull JetOperationExpression expression) {
-        JetSimpleNameExpression operationExpression = expression.getOperationReference();
+    public static KtToken getOperationToken(@NotNull KtOperationExpression expression) {
+        KtSimpleNameExpression operationExpression = expression.getOperationReference();
         IElementType elementType = operationExpression.getReferencedNameElementType();
-        assert elementType instanceof JetToken : "Expected JetToken type, but " + elementType.getClass() + ", expression: " + expression.getText();
-        return (JetToken) elementType;
+        assert elementType instanceof KtToken : "Expected KtToken type, but " + elementType.getClass() + ", expression: " + expression.getText();
+        return (KtToken) elementType;
     }
 
     @NotNull
-    public static JetExpression getBaseExpression(@NotNull JetUnaryExpression expression) {
-        JetExpression baseExpression = expression.getBaseExpression();
+    public static KtExpression getBaseExpression(@NotNull KtUnaryExpression expression) {
+        KtExpression baseExpression = expression.getBaseExpression();
         assert baseExpression != null;
         return baseExpression;
     }
 
-    public static boolean isPrefix(@NotNull JetUnaryExpression expression) {
-        return (expression instanceof JetPrefixExpression);
+    public static boolean isPrefix(@NotNull KtUnaryExpression expression) {
+        return (expression instanceof KtPrefixExpression);
     }
 
-    public static boolean isAssignment(JetToken token) {
-        return (token == JetTokens.EQ);
+    public static boolean isAssignment(KtToken token) {
+        return (token == KtTokens.EQ);
     }
 
-    public static boolean isInOrNotInOperation(@NotNull JetBinaryExpression binaryExpression) {
+    public static boolean isInOrNotInOperation(@NotNull KtBinaryExpression binaryExpression) {
         return isInOperation(binaryExpression) || isNotInOperation(binaryExpression);
     }
 
-    public static boolean isNotInOperation(@NotNull JetBinaryExpression binaryExpression) {
-        return (binaryExpression.getOperationToken() == JetTokens.NOT_IN);
+    public static boolean isNotInOperation(@NotNull KtBinaryExpression binaryExpression) {
+        return (binaryExpression.getOperationToken() == KtTokens.NOT_IN);
     }
 
-    public static boolean isNegatedOperation(@NotNull JetBinaryExpression binaryExpression) {
-        return (binaryExpression.getOperationToken() == JetTokens.EXCLEQ) || isNotInOperation(binaryExpression);
+    public static boolean isNegatedOperation(@NotNull KtBinaryExpression binaryExpression) {
+        return (binaryExpression.getOperationToken() == KtTokens.EXCLEQ) || isNotInOperation(binaryExpression);
     }
 
-    private static boolean isInOperation(@NotNull JetBinaryExpression binaryExpression) {
-        return (binaryExpression.getOperationToken() == JetTokens.IN_KEYWORD);
+    private static boolean isInOperation(@NotNull KtBinaryExpression binaryExpression) {
+        return (binaryExpression.getOperationToken() == KtTokens.IN_KEYWORD);
     }
 
     @Nullable
-    public static JetParameter getLoopParameter(@NotNull JetForExpression expression) {
+    public static KtParameter getLoopParameter(@NotNull KtForExpression expression) {
         return expression.getLoopParameter();
     }
 
     @NotNull
-    public static List<JetParameter> getPrimaryConstructorParameters(@NotNull JetClassOrObject classDeclaration) {
-        if (classDeclaration instanceof JetClass) {
+    public static List<KtParameter> getPrimaryConstructorParameters(@NotNull KtClassOrObject classDeclaration) {
+        if (classDeclaration instanceof KtClass) {
             return classDeclaration.getPrimaryConstructorParameters();
         }
         return Collections.emptyList();
     }
 
     @NotNull
-    public static JetExpression getLoopRange(@NotNull JetForExpression expression) {
-        JetExpression rangeExpression = expression.getLoopRange();
+    public static KtExpression getLoopRange(@NotNull KtForExpression expression) {
+        KtExpression rangeExpression = expression.getLoopRange();
         assert rangeExpression != null;
         return rangeExpression;
     }
 
     @NotNull
     public static CallableDescriptor getFunctionDescriptor(
-            @NotNull JetCallExpression expression,
+            @NotNull KtCallExpression expression,
             @NotNull TranslationContext context
     ) {
         ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(expression, context.bindingContext());
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/TranslationUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/TranslationUtils.java
index 66f7ecc5ce5..a249680cfff 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/TranslationUtils.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/TranslationUtils.java
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.js.translate.context.TranslationContext;
 import org.jetbrains.kotlin.js.translate.general.Translation;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -168,10 +168,10 @@ public final class TranslationUtils {
     }
 
     @Nullable
-    public static JsExpression translateInitializerForProperty(@NotNull JetProperty declaration,
+    public static JsExpression translateInitializerForProperty(@NotNull KtProperty declaration,
             @NotNull TranslationContext context) {
         JsExpression jsInitExpression = null;
-        JetExpression initializer = declaration.getInitializer();
+        KtExpression initializer = declaration.getInitializer();
         if (initializer != null) {
             jsInitExpression = Translation.translateAsExpression(initializer, context);
         }
@@ -180,51 +180,51 @@ public final class TranslationUtils {
 
     @NotNull
     public static JsExpression translateBaseExpression(@NotNull TranslationContext context,
-            @NotNull JetUnaryExpression expression) {
-        JetExpression baseExpression = PsiUtils.getBaseExpression(expression);
+            @NotNull KtUnaryExpression expression) {
+        KtExpression baseExpression = PsiUtils.getBaseExpression(expression);
         return Translation.translateAsExpression(baseExpression, context);
     }
 
     @NotNull
     public static JsExpression translateLeftExpression(@NotNull TranslationContext context,
-            @NotNull JetBinaryExpression expression) {
+            @NotNull KtBinaryExpression expression) {
         return translateLeftExpression(context, expression, context.dynamicContext().jsBlock());
     }
 
     @NotNull
     public static JsExpression translateLeftExpression(
             @NotNull TranslationContext context,
-            @NotNull JetBinaryExpression expression,
+            @NotNull KtBinaryExpression expression,
             @NotNull JsBlock block
     ) {
-        JetExpression left = expression.getLeft();
+        KtExpression left = expression.getLeft();
         assert left != null : "Binary expression should have a left expression: " + expression.getText();
         return Translation.translateAsExpression(left, context, block);
     }
 
     @NotNull
     public static JsExpression translateRightExpression(@NotNull TranslationContext context,
-            @NotNull JetBinaryExpression expression) {
+            @NotNull KtBinaryExpression expression) {
         return translateRightExpression(context, expression, context.dynamicContext().jsBlock());
     }
 
     @NotNull
     public static JsExpression translateRightExpression(
             @NotNull TranslationContext context,
-            @NotNull JetBinaryExpression expression,
+            @NotNull KtBinaryExpression expression,
             @NotNull JsBlock block) {
-        JetExpression rightExpression = expression.getRight();
+        KtExpression rightExpression = expression.getRight();
         assert rightExpression != null : "Binary expression should have a right expression";
         return Translation.translateAsExpression(rightExpression, context, block);
     }
 
     public static boolean hasCorrespondingFunctionIntrinsic(@NotNull TranslationContext context,
-            @NotNull JetOperationExpression expression) {
+            @NotNull KtOperationExpression expression) {
         CallableDescriptor operationDescriptor = getCallableDescriptorForOperationExpression(context.bindingContext(), expression);
 
         if (operationDescriptor == null || !(operationDescriptor instanceof FunctionDescriptor)) return true;
 
-        JetType returnType = operationDescriptor.getReturnType();
+        KtType returnType = operationDescriptor.getReturnType();
         if (returnType != null && (KotlinBuiltIns.isChar(returnType) || KotlinBuiltIns.isLong(returnType))) return false;
 
         if (context.intrinsics().getFunctionIntrinsic((FunctionDescriptor) operationDescriptor).exists()) return true;
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/inlineUtils.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/inlineUtils.kt
index bb33d0929c7..c8fb2c38a87 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/inlineUtils.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/inlineUtils.kt
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.js.inline.util.isCallInvocation
 import org.jetbrains.kotlin.js.translate.context.TranslationContext
 import org.jetbrains.kotlin.js.translate.reference.CallExpressionTranslator
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.inline.InlineStrategy
 
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.resolve.inline.InlineStrategy
  */
 fun setInlineCallMetadata(
         expression: JsExpression,
-        psiElement: JetExpression,
+        psiElement: KtExpression,
         resolvedCall: ResolvedCall<*>,
         context: TranslationContext
 ) {
diff --git a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/AndroidComponentRegistrar.kt b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/AndroidComponentRegistrar.kt
index 0dedb209181..9d69ed93e98 100644
--- a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/AndroidComponentRegistrar.kt
+++ b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/AndroidComponentRegistrar.kt
@@ -42,7 +42,7 @@ import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
 import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
 import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 
@@ -77,7 +77,7 @@ public class AndroidCommandLineProcessor : CommandLineProcessor {
 }
 
 public class CliAndroidDeclarationsProvider(private val project: Project) : ExternalDeclarationsProvider {
-    override fun getExternalDeclarations(moduleInfo: ModuleInfo?): Collection<JetFile> {
+    override fun getExternalDeclarations(moduleInfo: ModuleInfo?): Collection<KtFile> {
         val parser = ServiceManager.getService(project, SyntheticFileGenerator::class.java) as? CliSyntheticFileGenerator
         return parser?.getSyntheticFiles() ?: listOf()
     }
diff --git a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/AndroidConst.kt b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/AndroidConst.kt
index 2644a11bdd8..0994f7d01df 100644
--- a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/AndroidConst.kt
+++ b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/AndroidConst.kt
@@ -17,8 +17,8 @@
 package org.jetbrains.kotlin.android.synthetic
 
 import com.intellij.openapi.util.Key
-import org.jetbrains.kotlin.lexer.JetKeywordToken
-import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.lexer.KtKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens
 
 public object AndroidConst {
     val ANDROID_USER_PACKAGE: Key<String> = Key.create<String>("ANDROID_USER_PACKAGE")
@@ -50,8 +50,8 @@ public object AndroidConst {
 
     val IGNORED_XML_WIDGET_TYPES = setOf("requestFocus", "merge", "tag", "check", "blink")
 
-    val ESCAPED_IDENTIFIERS = (JetTokens.KEYWORDS.types + JetTokens.SOFT_KEYWORDS.types)
-            .map { it as? JetKeywordToken }.filterNotNull().map { it.value }.toSet()
+    val ESCAPED_IDENTIFIERS = (KtTokens.KEYWORDS.types + KtTokens.SOFT_KEYWORDS.types)
+            .map { it as? KtKeywordToken }.filterNotNull().map { it.value }.toSet()
 
     val FQNAME_RESOLVE_PACKAGES = listOf("android.widget", "android.webkit", "android.view")
 }
diff --git a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/codegen/AndroidExpressionCodegenExtension.kt b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/codegen/AndroidExpressionCodegenExtension.kt
index 4493de915ce..9bb2234b97b 100644
--- a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/codegen/AndroidExpressionCodegenExtension.kt
+++ b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/codegen/AndroidExpressionCodegenExtension.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.JetTypeMapper
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaClassDescriptor
-import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
@@ -97,7 +97,7 @@ public class AndroidExpressionCodegenExtension : ExpressionCodegenExtension {
             val classBuilder: ClassBuilder,
             val state: GenerationState,
             val descriptor: ClassDescriptor,
-            val classOrObject: JetClassOrObject,
+            val classOrObject: KtClassOrObject,
             val androidClassType: AndroidClassType)
 
     override fun applyProperty(receiver: StackValue, resolvedCall: ResolvedCall<*>, c: ExpressionCodegenExtension.Context): StackValue? {
@@ -234,7 +234,7 @@ public class AndroidExpressionCodegenExtension : ExpressionCodegenExtension {
     override fun generateClassSyntheticParts(
             classBuilder: ClassBuilder,
             state: GenerationState,
-            classOrObject: JetClassOrObject,
+            classOrObject: KtClassOrObject,
             descriptor: ClassDescriptor
     ) {
         if (descriptor.kind != ClassKind.CLASS || descriptor.isInner || DescriptorUtils.isLocal(descriptor)) return
diff --git a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/codegen/AndroidOnDestroyClassBuilderInterceptorExtension.kt b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/codegen/AndroidOnDestroyClassBuilderInterceptorExtension.kt
index 6671b95eb5b..0956656a1a5 100644
--- a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/codegen/AndroidOnDestroyClassBuilderInterceptorExtension.kt
+++ b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/codegen/AndroidOnDestroyClassBuilderInterceptorExtension.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.codegen.DelegatingClassBuilder
 import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
-import org.jetbrains.kotlin.psi.JetClass
+import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.org.objectweb.asm.*
@@ -64,7 +64,7 @@ public class AndroidOnDestroyClassBuilderInterceptorExtension : ClassBuilderInte
             internal val delegateClassBuilder: ClassBuilder,
             val bindingContext: BindingContext
     ) : DelegatingClassBuilder() {
-        private var currentClass: JetClass? = null
+        private var currentClass: KtClass? = null
         private var currentClassName: String? = null
 
         override fun getDelegate() = delegateClassBuilder
@@ -78,7 +78,7 @@ public class AndroidOnDestroyClassBuilderInterceptorExtension : ClassBuilderInte
                 superName: String,
                 interfaces: Array<out String>
         ) {
-            if (origin is JetClass) {
+            if (origin is KtClass) {
                 currentClass = origin
                 currentClassName = name
             }
diff --git a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/diagnostic/ErrorsAndroid.java b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/diagnostic/ErrorsAndroid.java
index a238baf8d42..f1eee3b9b3b 100644
--- a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/diagnostic/ErrorsAndroid.java
+++ b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/diagnostic/ErrorsAndroid.java
@@ -18,13 +18,13 @@ package org.jetbrains.kotlin.android.synthetic.diagnostic;
 
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1;
 import org.jetbrains.kotlin.diagnostics.Errors;
-import org.jetbrains.kotlin.psi.JetExpression;
+import org.jetbrains.kotlin.psi.KtExpression;
 
 import static org.jetbrains.kotlin.diagnostics.Severity.WARNING;
 
 public interface ErrorsAndroid {
-    DiagnosticFactory1<JetExpression, String> SYNTHETIC_INVALID_WIDGET_TYPE = DiagnosticFactory1.create(WARNING);
-    DiagnosticFactory1<JetExpression, String> SYNTHETIC_UNRESOLVED_WIDGET_TYPE = DiagnosticFactory1.create(WARNING);
+    DiagnosticFactory1<KtExpression, String> SYNTHETIC_INVALID_WIDGET_TYPE = DiagnosticFactory1.create(WARNING);
+    DiagnosticFactory1<KtExpression, String> SYNTHETIC_UNRESOLVED_WIDGET_TYPE = DiagnosticFactory1.create(WARNING);
 
     @SuppressWarnings("UnusedDeclaration")
     Object _initializer = new Object() {
diff --git a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/res/AndroidLayoutXmlFileManager.kt b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/res/AndroidLayoutXmlFileManager.kt
index fea91601ef1..fb95ef87657 100644
--- a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/res/AndroidLayoutXmlFileManager.kt
+++ b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/res/AndroidLayoutXmlFileManager.kt
@@ -24,14 +24,14 @@ import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiManager
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtProperty
 import java.util.*
 
 public abstract class AndroidLayoutXmlFileManager(val project: Project) {
 
     public abstract val androidModuleInfo: AndroidModuleInfo?
 
-    public open fun propertyToXmlAttributes(property: JetProperty): List<PsiElement> = listOf()
+    public open fun propertyToXmlAttributes(property: KtProperty): List<PsiElement> = listOf()
 
     public fun getLayoutXmlFiles(): Map<String, List<PsiFile>> {
         val info = androidModuleInfo ?: return mapOf()
diff --git a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/res/CliSyntheticFileGenerator.kt b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/res/CliSyntheticFileGenerator.kt
index d5bbd70450a..5bc17da480a 100644
--- a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/res/CliSyntheticFileGenerator.kt
+++ b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/res/CliSyntheticFileGenerator.kt
@@ -25,7 +25,7 @@ import com.intellij.psi.impl.PsiElementFinderImpl
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.android.synthetic.AndroidConst
 import org.jetbrains.kotlin.android.synthetic.AndroidXmlHandler
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
 public open class CliSyntheticFileGenerator(
         project: Project,
@@ -43,7 +43,7 @@ public open class CliSyntheticFileGenerator(
         CliAndroidLayoutXmlFileManager(project, manifestPath, resDirectories)
     }
 
-    public override fun getSyntheticFiles(): List<JetFile> = cachedJetFiles
+    public override fun getSyntheticFiles(): List<KtFile> = cachedJetFiles
 
     override fun extractLayoutResources(files: List<PsiFile>): List<AndroidResource> {
         val resources = arrayListOf<AndroidResource>()
diff --git a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/res/SyntheticFileGenerator.kt b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/res/SyntheticFileGenerator.kt
index 5f3acc20298..f70236e2031 100644
--- a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/res/SyntheticFileGenerator.kt
+++ b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/android/synthetic/res/SyntheticFileGenerator.kt
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.android.synthetic.AndroidConst
 import org.jetbrains.kotlin.android.synthetic.KotlinStringWriter
 import org.jetbrains.kotlin.android.synthetic.escapeAndroidIdentifier
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.types.Flexibility
 
 public class AndroidSyntheticFile(val name: String, val contents: String) {
@@ -42,7 +42,7 @@ public abstract class SyntheticFileGenerator(protected val project: Project) {
 
     public abstract val layoutXmlFileManager: AndroidLayoutXmlFileManager
 
-    public abstract fun getSyntheticFiles(): List<JetFile>
+    public abstract fun getSyntheticFiles(): List<KtFile>
 
     protected open fun generateSyntheticFiles(generateCommonFiles: Boolean, supportV4: Boolean): List<AndroidSyntheticFile> {
         val commonFiles = if (generateCommonFiles) generateCommonFiles(supportV4) else listOf()
@@ -197,14 +197,14 @@ public abstract class SyntheticFileGenerator(protected val project: Project) {
         return resourceMap.values().toList()
     }
 
-    protected fun generateSyntheticJetFiles(files: List<AndroidSyntheticFile>): List<JetFile> {
+    protected fun generateSyntheticJetFiles(files: List<AndroidSyntheticFile>): List<KtFile> {
         val psiManager = PsiManager.getInstance(project)
         val applicationPackage = layoutXmlFileManager.androidModuleInfo?.applicationPackage
 
         return files.mapIndexed { index, syntheticFile ->
             val fileName = AndroidConst.SYNTHETIC_FILENAME_PREFIX + syntheticFile.name + ".kt"
             val virtualFile = LightVirtualFile(fileName, syntheticFile.contents)
-            val jetFile = psiManager.findFile(virtualFile) as JetFile
+            val jetFile = psiManager.findFile(virtualFile) as KtFile
             if (applicationPackage != null) {
                 jetFile.putUserData(AndroidConst.ANDROID_USER_PACKAGE, applicationPackage)
             }
diff --git a/plugins/android-compiler-plugin/tests/org/jetbrains/kotlin/lang/resolve/android/test/CompilerTestUtils.kt b/plugins/android-compiler-plugin/tests/org/jetbrains/kotlin/lang/resolve/android/test/CompilerTestUtils.kt
index b13910aeb80..da2e4eafd59 100644
--- a/plugins/android-compiler-plugin/tests/org/jetbrains/kotlin/lang/resolve/android/test/CompilerTestUtils.kt
+++ b/plugins/android-compiler-plugin/tests/org/jetbrains/kotlin/lang/resolve/android/test/CompilerTestUtils.kt
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
 import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import java.io.File
 
 private class AndroidTestExternalDeclarationsProvider(
@@ -41,7 +41,7 @@ private class AndroidTestExternalDeclarationsProvider(
         val manifestPath: String,
         val supportV4: Boolean
 ) : ExternalDeclarationsProvider {
-    override fun getExternalDeclarations(moduleInfo: ModuleInfo?): Collection<JetFile> {
+    override fun getExternalDeclarations(moduleInfo: ModuleInfo?): Collection<KtFile> {
         val parser = CliSyntheticFileGeneratorForConversionTest(project, manifestPath, resPaths, supportV4)
         return parser.getSyntheticFiles()
     }
diff --git a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidFindMemberUsagesHandler.kt b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidFindMemberUsagesHandler.kt
index dde30bf58da..10485fc35ee 100644
--- a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidFindMemberUsagesHandler.kt
+++ b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidFindMemberUsagesHandler.kt
@@ -32,13 +32,13 @@ import org.jetbrains.kotlin.android.synthetic.res.SyntheticFileGenerator
 import org.jetbrains.kotlin.idea.caches.resolve.ModuleSourceInfo
 import org.jetbrains.kotlin.idea.caches.resolve.getModuleInfo
 import org.jetbrains.kotlin.plugin.findUsages.handlers.KotlinFindUsagesHandlerDecorator
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
+import org.jetbrains.kotlin.psi.KtProperty
 import java.util.ArrayList
 
 class AndroidFindUsageHandlerDecorator : KotlinFindUsagesHandlerDecorator {
     override fun decorateHandler(element: PsiElement, forHighlightUsages: Boolean, delegate: FindUsagesHandler): FindUsagesHandler {
-        if (element !is JetNamedDeclaration) return delegate
+        if (element !is KtNamedDeclaration) return delegate
         if (!isAndroidSyntheticElement(element)) return delegate
 
         return AndroidFindMemberUsagesHandler(element, delegate)
@@ -46,14 +46,14 @@ class AndroidFindUsageHandlerDecorator : KotlinFindUsagesHandlerDecorator {
 }
 
 class AndroidFindMemberUsagesHandler(
-        private val declaration: JetNamedDeclaration,
+        private val declaration: KtNamedDeclaration,
         private val delegate: FindUsagesHandler? = null
 ) : FindUsagesHandler(declaration) {
 
     override fun getPrimaryElements(): Array<PsiElement> {
         assert(isAndroidSyntheticElement(declaration))
 
-        val property = declaration as JetProperty
+        val property = declaration as KtProperty
         val moduleInfo = declaration.getModuleInfo() as? ModuleSourceInfo ?: return super.getPrimaryElements()
         val parser = ModuleServiceManager.getService(moduleInfo.module, javaClass<SyntheticFileGenerator>())
 
@@ -71,7 +71,7 @@ class AndroidFindMemberUsagesHandler(
     override fun getSecondaryElements(): Array<PsiElement> {
         assert(isAndroidSyntheticElement(declaration))
 
-        val property = declaration as JetProperty
+        val property = declaration as KtProperty
         val moduleInfo = declaration.getModuleInfo() as? ModuleSourceInfo ?: return super.getPrimaryElements()
         val parser = ModuleServiceManager.getService(moduleInfo.module, javaClass<SyntheticFileGenerator>())
 
diff --git a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidGotoDeclarationHandler.kt b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidGotoDeclarationHandler.kt
index 70a52a6853c..7786cb02510 100644
--- a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidGotoDeclarationHandler.kt
+++ b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidGotoDeclarationHandler.kt
@@ -26,16 +26,16 @@ import com.intellij.psi.xml.XmlAttribute
 import org.jetbrains.kotlin.android.synthetic.res.SyntheticFileGenerator
 import org.jetbrains.kotlin.idea.caches.resolve.ModuleSourceInfo
 import org.jetbrains.kotlin.idea.caches.resolve.getModuleInfo
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 
 public class AndroidGotoDeclarationHandler : GotoDeclarationHandler {
 
     override fun getGotoDeclarationTargets(sourceElement: PsiElement?, offset: Int, editor: Editor?): Array<PsiElement>? {
-        if (sourceElement is LeafPsiElement && sourceElement.getParent() is JetSimpleNameExpression) {
-            val resolved = JetSimpleNameReference(sourceElement.getParent() as JetSimpleNameExpression).resolve()
-            val property = resolved as? JetProperty ?: return null
+        if (sourceElement is LeafPsiElement && sourceElement.getParent() is KtSimpleNameExpression) {
+            val resolved = KtSimpleNameReference(sourceElement.getParent() as KtSimpleNameExpression).resolve()
+            val property = resolved as? KtProperty ?: return null
 
             val moduleInfo = sourceElement.getModuleInfo()
             if (moduleInfo !is ModuleSourceInfo) return null
diff --git a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidRenameProcessor.kt b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidRenameProcessor.kt
index 81143ccf419..123c5c3cde9 100644
--- a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidRenameProcessor.kt
+++ b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidRenameProcessor.kt
@@ -38,13 +38,13 @@ import org.jetbrains.kotlin.android.synthetic.res.SyntheticFileGenerator
 import org.jetbrains.kotlin.asJava.namedUnwrappedElement
 import org.jetbrains.kotlin.idea.caches.resolve.ModuleSourceInfo
 import org.jetbrains.kotlin.idea.caches.resolve.getModuleInfo
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtProperty
 
 public class AndroidRenameProcessor : RenamePsiElementProcessor() {
 
     override fun canProcessElement(element: PsiElement): Boolean {
         // Either renaming synthetic property, or value in layout xml, or R class field
-        return (element.namedUnwrappedElement is JetProperty &&
+        return (element.namedUnwrappedElement is KtProperty &&
                 isAndroidSyntheticElement(element.namedUnwrappedElement)) || element is XmlAttributeValue ||
                isRClassField(element)
     }
@@ -72,8 +72,8 @@ public class AndroidRenameProcessor : RenamePsiElementProcessor() {
             allRenames: MutableMap<PsiElement, String>,
             scope: SearchScope
     ) {
-        if (element != null && element.namedUnwrappedElement is JetProperty) {
-            renameSyntheticProperty(element.namedUnwrappedElement as JetProperty, newName, allRenames)
+        if (element != null && element.namedUnwrappedElement is KtProperty) {
+            renameSyntheticProperty(element.namedUnwrappedElement as KtProperty, newName, allRenames)
         }
         else if (element is XmlAttributeValue) {
             renameAttributeValue(element, newName, allRenames)
@@ -84,7 +84,7 @@ public class AndroidRenameProcessor : RenamePsiElementProcessor() {
     }
 
     private fun renameSyntheticProperty(
-            jetProperty: JetProperty,
+            jetProperty: KtProperty,
             newName: String,
             allRenames: MutableMap<PsiElement, String>
     ) {
@@ -132,7 +132,7 @@ public class AndroidRenameProcessor : RenamePsiElementProcessor() {
             oldPropName: String,
             processor: SyntheticFileGenerator
     ) {
-        val props = processor.getSyntheticFiles()?.flatMap { it.findChildrenByClass(javaClass<JetProperty>()).toList() }
+        val props = processor.getSyntheticFiles()?.flatMap { it.findChildrenByClass(javaClass<KtProperty>()).toList() }
         val matchedProps = props?.filter { it.getName() == oldPropName } ?: listOf()
         for (prop in matchedProps) {
             allRenames[prop] = newPropName
diff --git a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidSimpleNameReferenceExtension.kt b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidSimpleNameReferenceExtension.kt
index 399be1568da..afee4912d14 100644
--- a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidSimpleNameReferenceExtension.kt
+++ b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/AndroidSimpleNameReferenceExtension.kt
@@ -19,14 +19,14 @@ package org.jetbrains.kotlin.android.synthetic.idea
 import com.intellij.psi.PsiElement
 import org.jetbrains.android.dom.wrappers.ValueResourceElementWrapper
 import org.jetbrains.kotlin.android.synthetic.isAndroidSyntheticElement
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.plugin.references.SimpleNameReferenceExtension
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtPsiFactory
 
 public class AndroidSimpleNameReferenceExtension : SimpleNameReferenceExtension {
-    override fun isReferenceTo(reference: JetSimpleNameReference, element: PsiElement): Boolean? {
-        val resolvedElement = reference.resolve() as? JetProperty ?: return null
+    override fun isReferenceTo(reference: KtSimpleNameReference, element: PsiElement): Boolean? {
+        val resolvedElement = reference.resolve() as? KtProperty ?: return null
 
         if (isAndroidSyntheticElement(resolvedElement)) {
             if (element is ValueResourceElementWrapper) {
@@ -37,7 +37,7 @@ public class AndroidSimpleNameReferenceExtension : SimpleNameReferenceExtension
         return null
     }
 
-    override fun handleElementRename(reference: JetSimpleNameReference, psiFactory: JetPsiFactory, newElementName: String): PsiElement? {
+    override fun handleElementRename(reference: KtSimpleNameReference, psiFactory: KtPsiFactory, newElementName: String): PsiElement? {
         return if (newElementName.startsWith("@+id/"))
             psiFactory.createNameIdentifier(newElementName.substring(newElementName.indexOf('/') + 1))
         else
diff --git a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/IDEAndroidExternalDeclarationsProvider.kt b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/IDEAndroidExternalDeclarationsProvider.kt
index 35e6cc93a7f..3082a324efd 100644
--- a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/IDEAndroidExternalDeclarationsProvider.kt
+++ b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/IDEAndroidExternalDeclarationsProvider.kt
@@ -23,11 +23,11 @@ import org.jetbrains.kotlin.android.synthetic.idea.res.IDESyntheticFileGenerator
 import org.jetbrains.kotlin.android.synthetic.res.SyntheticFileGenerator
 import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
 import org.jetbrains.kotlin.idea.caches.resolve.ModuleSourceInfo
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.moduleInfo
 
 public class IDEAndroidExternalDeclarationsProvider(private val project: Project) : ExternalDeclarationsProvider {
-    override fun getExternalDeclarations(moduleInfo: ModuleInfo?): Collection<JetFile> {
+    override fun getExternalDeclarations(moduleInfo: ModuleInfo?): Collection<KtFile> {
         if (moduleInfo !is ModuleSourceInfo) return listOf()
 
         val module = moduleInfo.module
diff --git a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/res/IDEAndroidLayoutXmlFileManager.kt b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/res/IDEAndroidLayoutXmlFileManager.kt
index f79ed249dad..f684862e5a8 100644
--- a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/res/IDEAndroidLayoutXmlFileManager.kt
+++ b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/res/IDEAndroidLayoutXmlFileManager.kt
@@ -23,13 +23,13 @@ import org.jetbrains.kotlin.android.synthetic.AndroidConst
 import org.jetbrains.kotlin.android.synthetic.idea.AndroidXmlVisitor
 import org.jetbrains.kotlin.android.synthetic.res.AndroidLayoutXmlFileManager
 import org.jetbrains.kotlin.android.synthetic.res.AndroidModuleInfo
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtProperty
 
 public class IDEAndroidLayoutXmlFileManager(val module: Module) : AndroidLayoutXmlFileManager(module.project) {
 
     override val androidModuleInfo: AndroidModuleInfo? by lazy { module.androidFacet?.toAndroidModuleInfo() }
 
-    override fun propertyToXmlAttributes(property: JetProperty): List<PsiElement> {
+    override fun propertyToXmlAttributes(property: KtProperty): List<PsiElement> {
         val fqPath = property.getFqName()?.pathSegments() ?: return listOf()
         if (fqPath.size() <= AndroidConst.SYNTHETIC_PACKAGE_PATH_LENGTH) return listOf()
 
diff --git a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/res/IDESyntheticFileGenerator.kt b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/res/IDESyntheticFileGenerator.kt
index 842c64b02cb..2f62c34129f 100644
--- a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/res/IDESyntheticFileGenerator.kt
+++ b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/android/synthetic/idea/res/IDESyntheticFileGenerator.kt
@@ -28,11 +28,11 @@ import org.jetbrains.kotlin.android.synthetic.idea.AndroidXmlVisitor
 import org.jetbrains.kotlin.android.synthetic.res.AndroidResource
 import org.jetbrains.kotlin.android.synthetic.res.AndroidWidget
 import org.jetbrains.kotlin.android.synthetic.res.SyntheticFileGenerator
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 
 class IDESyntheticFileGenerator(val module: Module) : SyntheticFileGenerator(module.project) {
 
-    private val cachedJetFiles: CachedValue<List<JetFile>> by lazy {
+    private val cachedJetFiles: CachedValue<List<KtFile>> by lazy {
         cachedValue {
             val supportV4 = supportV4Available()
             Result.create(generateSyntheticJetFiles(generateSyntheticFiles(true, supportV4)), psiTreeChangePreprocessor)
@@ -45,7 +45,7 @@ class IDESyntheticFileGenerator(val module: Module) : SyntheticFileGenerator(mod
         module.project.getExtensions(PsiTreeChangePreprocessor.EP_NAME).first { it is AndroidPsiTreeChangePreprocessor }
     }
 
-    public override fun getSyntheticFiles(): List<JetFile> {
+    public override fun getSyntheticFiles(): List<KtFile> {
         if (!checkIfClassExist(AndroidConst.VIEW_FQNAME)) return listOf()
         return cachedJetFiles.value
     }
diff --git a/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidGotoTest.kt b/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidGotoTest.kt
index eb56f4d2902..7cd20ba8531 100644
--- a/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidGotoTest.kt
+++ b/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidGotoTest.kt
@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.android
 
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtProperty
 import com.intellij.codeInsight.navigation.actions.GotoDeclarationAction
 
 public abstract class AbstractAndroidGotoTest : KotlinAndroidTestCase() {
@@ -32,8 +32,8 @@ public abstract class AbstractAndroidGotoTest : KotlinAndroidTestCase() {
         f.configureFromExistingVirtualFile(virtualFile)
 
         val resolved = GotoDeclarationAction.findTargetElement(f.getProject(), f.getEditor(), f.getCaretOffset())
-        if (f.getElementAtCaret() !is JetProperty) kotlin.test.fail("element at caret must be a property, not a ${f.getElementAtCaret().javaClass}")
-        kotlin.test.assertEquals("\"@+id/${(f.getElementAtCaret() as JetProperty).getName()}\"", resolved?.getText())
+        if (f.getElementAtCaret() !is KtProperty) kotlin.test.fail("element at caret must be a property, not a ${f.getElementAtCaret().javaClass}")
+        kotlin.test.assertEquals("\"@+id/${(f.getElementAtCaret() as KtProperty).getName()}\"", resolved?.getText())
 
     }
 }
\ No newline at end of file
diff --git a/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidRenameTest.kt b/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidRenameTest.kt
index b39d268762e..48272446f82 100644
--- a/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidRenameTest.kt
+++ b/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidRenameTest.kt
@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.android
 
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtProperty
 import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil
 import com.intellij.codeInsight.TargetElementUtilBase
 import com.intellij.refactoring.rename.RenameProcessor
@@ -41,7 +41,7 @@ public abstract class AbstractAndroidRenameTest : KotlinAndroidTestCase() {
                 completionEditor, TargetElementUtilBase.REFERENCED_ELEMENT_ACCEPTED or TargetElementUtilBase.ELEMENT_NAME_ACCEPTED)
 
         assert(element != null)
-        assertTrue(element is JetProperty)
+        assertTrue(element is KtProperty)
 
         RenameProcessor(f.getProject(), element, NEW_NAME, false, true).run()
 
@@ -53,7 +53,7 @@ public abstract class AbstractAndroidRenameTest : KotlinAndroidTestCase() {
         val attributeElement = GotoDeclarationAction.findTargetElement(f.getProject(), f.getEditor(), f.getCaretOffset())
         RenameProcessor(f.getProject(), attributeElement, "@+id/$OLD_NAME", false, true).run()
 
-        assertEquals(OLD_NAME, (f.getElementAtCaret() as JetProperty).getName())
+        assertEquals(OLD_NAME, (f.getElementAtCaret() as KtProperty).getName())
     }
 
     override fun getTestDataPath() = KotlinAndroidTestCaseBase.getPluginTestDataPathBase() + "/rename/" + getTestName(true) + "/"
diff --git a/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/AnnotationCollectorPlugin.kt b/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/AnnotationCollectorPlugin.kt
index 76f13614d0f..c25029152cd 100644
--- a/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/AnnotationCollectorPlugin.kt
+++ b/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/AnnotationCollectorPlugin.kt
@@ -33,8 +33,8 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters1
 import org.jetbrains.kotlin.name.FqName
-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.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
 import java.io.BufferedWriter
diff --git a/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/StubProducerExtension.kt b/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/StubProducerExtension.kt
index 806ae549951..1718d9cb21c 100644
--- a/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/StubProducerExtension.kt
+++ b/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/StubProducerExtension.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.cli.common.output.outputUtils.writeAllTo
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
@@ -36,7 +36,7 @@ public class StubProducerExtension(val stubsOutputDir: File) : AnalysisCompleted
             project: Project,
             module: ModuleDescriptor,
             bindingContext: BindingContext,
-            files: Collection<JetFile>
+            files: Collection<KtFile>
     ): AnalysisResult? {
         val forExtraDiagnostics = BindingTraceContext()